Rick Minerich's Development Wonderland : wpf

F# Discoveries This Week 10/11/2010

RickM — Mon, 11 Oct 2010 19:45:16 GMT

As always, a ton of great posts this week on a large number of interesting topics. It’s great to be part of such a productive community. I particularly enjoyed Vladimir’s Zebra Puzzle post. The code is just beautiful.

I also have some bittersweet news to share. I’ll soon be leaving Atalasoft to join a yet unnamed company in the NYC area. I’ll miss Atalasoft for sure, it’s a great company full of very smart people. Keep an eye on the career page and you might just be lucky enough to work with these fine folks.

I’m planning on starting a NYC F# user group once I get settled. Please let me know if you’re interested in helping to get it off of the ground.

News

October Community for F# meeting - Trees, Language Oriented Programming and F# with Robert Pickering

When: Tuesday, Oct 19, 2010 11:00 AM (PDT)

“In this presentation Robert Pickering will take a look at the concept of the tree data structure, and we’ll see how trees are everywhere we look in programing”

Adam Granicz's F# MVP Award - 2010

Sorry I missed you last week Adam! Congrats on the award!

Summary of CUFP 2010

“The star of the show was definitely F# in my opinion. The weakest part of the conference was the lack of outlets.”

Mono 2.8 Released

“Mono 2.8 is a portable and open source implementation of the .NET framework for Unix, Windows, MacOS and other operating systems.”

Audio and Video

Anton Tayanovskyy - Developing WebSharper 2.0 Applications

“In this talk Anton will present a pre-release version of WebSharper 2.0 by developing and testing a small standalone JavaScript component.”

Tools / Projects

huwmancode - Release: Release 0.2 Alpha

“Features seamless debug support enabled for VS 2010 - Place a breakpoint in your service code and run! (Make sure to install the service first!)”

RouteTester

“ A sitemap-based url tester that runs in parallel (F#).”

IronJS at 0.1.90-preview

“IronJS - A Javascript implementation for the DLR written in F#”

F# Sample: Google Reader API Port

“This F# Google Reader API code is a port from a project that was originally developed in C#. It supports the 'unofficial' reader API and can get lists of subscriptions, posts, tags etc. for a Google Reader account.”

FSharp.Reactive

“Extensions and wrappers for using the Reactive Extensions (Rx) with F#.”

General

Vladimir Matveev's Solving Zebra Puzzle

“Zebra puzzle (often referred as Einstein's problem) is a well-known class of logic puzzles where you need to reconstruct the missing parts from the set of known facts”

Diego Echeverris Starting with WebSharper Interface Generator

“Sometimes though, the library you want to create wraps for contains hundreds of classes, configuration objects and enumerations. Doing this manually is not only error-prone but extremely boring.”

Steve Gilham's Computing per-service SIDs without sc.exe

“Here's a quick script to do it, that can be the basis for including the computation programmatically into e.g. installer generation.”

Ashley Feniello's 8-Queens in 8 Lines

“Brushing up on “whiteboard coding” for internal interviews… Inspired by Hal Ableson’s streams-based solution to this old classic in the SICP lectures, here’s a pretty concise n-Queens solution:”

Brian McNamara’s Unit tests + debugger = code understanding

“When you have good unit tests, everything is better; if you’re already a TDD-er, then saying that is just preaching to the choir. And when you have a good debugger, using that tool is a great way to learn about an unfamiliar code base (stepping through code, setting breakpoints, looking at stacks, changing values of locals or the next statement to see how things react). Put those two together, and the effect is even more powerful.”

Phillip Trelford's Game of Life

“Michael used a video of Jon Conway himself to explain the rules; which he followed up by showing a very interesting implementation using APL. Afterwards we all paired up to try implementations in various languages. After about half an hour my pair came up with the following F# implementation.”

Dean Chalk's Interacting With WPF Dispatcher Via F# Interactive Window

“So what this means now is that we can create sophosticated WPF controls, invoke them in the FSI window, and then apply long-running upddates via FSI without the WPF window freezing on us.”

Teaching and Basics

Embedded WebBrowser in F#

“Luckily, Winforms provides an embedded web browser through System.Windows.Forms.WebBrowser. The Mono implementation relies on the Mozilla Gecko engine.”

F# Discoveries This Week 08/08/2010

RickM — Sun, 08 Aug 2010 18:57:45 GMT

So many links, all well worth your time. I know one thing I won’t be missing is Don Syme’s online talk at C4FSharp on 8/17. It’s great to be part of a language community in which the founder interacts in such a direct way.

News

Draft F# Component Design Guidelines now Available (pdf)

Don Syme will be speaking online for the Community for F# on 8/17

I’ll be speaking at the NYC ALT.NET User Group on 8/25

Kevin Hazzard’s Slides from DevConnections are up

Howard Mansell will present Eden: (An F#/WPF framework for building GUI tools) at CUFP

F# is now at 93% on langref, only 1% behind scala. (Great Going!)

PexForFun.com now has puzzles for F#

FSharp Cross Platform Packages and Samples 1.1 Released

Audio/Video

Jon Harrop at the London F-Sharp User Group: QR Decomposition

This lecture takes the audience from a tiny numerically-robust implementation of a common linear algebra algorithm through several stages of optimization, culminating in a high-performance solution that easily outperforms Intel’s Math Kernel Library. The algorithm studied is QR decomposition, which is commonly used for linear least squares best fit.

F# Articles

Adam Granicz’s Expert F# 2.0 – what’s new?

There comes a time when you just have to stop working for a minute and take a few moments to enjoy the fruits of your hard labor. For me, one of these moments lately came when I received the author copies of our book, Expert F# 2.0

Daniel Mohl’s F# Templates Now On Visual Studio Gallery

As Don Syme mentioned in a recent blog post, I've been working to get the five F# templates that have been announced on this blog up on Visual Studio Gallery. I'm happy to say that all are now available.

Vagif Abilov’s Mock framework challenges in F#

So far I only tried very basic mocking described in the first post of Richard’s series: faking return value. As I expected, even such a simple operation became a challenge when executed from F# code. I managed to make tests work only for two and half frameworks.

Mauricio Scheffer’s Figment: a web DSL for F#

As I said, this is very much work in progress, and there's still a lot to do. I intend to make it fully open source when I finish writing my thesis.

Neil Carrier’s Segment Tree in F#

Suffice to say that a segment tree stores a group of intervals on an ordered set, in such a way that all the intervals containing a given value can be efficiently located. Such a query is sometimes called a “stabbing query,” because it’s like sticking a spear through the data and seeing which entries get stabbed.

Neil Carrier’s F# Sequence Lazy Evaluation Gotchas

Today’s post will be old news to experienced F# programmers. Actually, it’s old news to me, relative newcomer that I am. However, it’s one of those things I tend to forget until it jumps up to bite me, as it did today.

Edgar Sanchez’s F#, the ACM, and the SEC

And it is this last recommendation on DSLs that carries interesting news for F# because at the end of page 6 it states “Experience seems to show that higher-order programming languages such as F# provide a particularly good basis for domain-specific languages.

Jon Harrop’s Pure F# now only 2× slower than OCaml

This is a surprising and encouraging result not only because it makes F# competitive for an even wider variety of tasks but because it also implies that Microsoft are taking F# so seriously that they are optimizing the .NET garbage collector for it!

Steve Hawley’s Protect Yourself

One solution is to label things that need to be protected, disassemble the output, run a regular expression to search/replace the accessibility and reassemble.

F# and .NET needed at Credit Suisse? Is there a future for this and Microsoft in the quant world?

As I said, when you compare to these other languages in the world of quant, F# appears to be taking an early lead.

Stefano Ricciardi’s Project Euler Problem 4 in F#

The actual algorithm uses brute force to test for palindromicity (neologism?) all the numbers that can be composed multiplying together 3 digits numbers (those from 100 to 999), picking the highest one.

Miscellaneous

Lambda the Ultimate’s OSCON 2010 Emerging Languages Camp Roundup

F# Discoveries this Week 07/09/2010

RickM — Fri, 09 Jul 2010 17:42:10 GMT

This week we once again reap another huge crop of fantastic F# content. In fact, it’s been getting so overwhelming that I’ll be moving to an every week format from here on out. Please come in, read, and enjoy!

News

A New F# Case Study on Microsoft.com

With its new tools, the bank can speed development by 50 percent or more, improve quality, and reduce costs.

Next F# London Meetup Announced: July 28th

The next meetup of the F#unctional London Meetup Group will be held on July 28, with Zach Bray talking on Agile Acceptance Testing with F#

Tim Anderson (of The Register) Interviews Don Syme

I met Syme at the QCon conference in London, in March 2010, and interviewed him shortly afterwards. Some quotes from that interviewed have already been published in an article for The Register, but I am now posting nearly all of it here.

DotNetKicks Now has a F# Section

Thanks to everyone on twitter who voted!

Quantifa 0.0.2 Released

Quantifa is an F# open-source library for quantitative finance and risk management.

F#-mode for Emacs updated to 0.3

The F# mode for Emacs is two years old, and has been downloaded more than 1,000 times.

Tables: Organize Your Files. Written in F#

Tabbles is a new way of organizing files: it combines virtual folders and tags, and auto-organizes and tags your files in very intelligent ways.

Audio / Video

Svea Ekonomi on F# for automated billing system for the Telecom industry

In earlier versions of the billing system, much of the business logic resided in SQL Server and various Perl and Java programs. That made the solution hard to maintain and tailor to the needs of the customers. By using F# instead of an object oriented language the developers at Svea Ekonomi can be a lot more productive.

Articles

Ian Voyce’s Minilight renderer in F#

I’m a sucker for eye-candy, and the other day I came across the beautifully lit renders produced by Minilight. It’s a nice, minimal implementation of a global illumination renderer that’s been ported to a wide variety of different languages from C to ActionScript. So of course, I couldn’t resist trying to implement it in F#.

Jon Harrop’s F# vs Mathematica: fast pricer for American options

Another example from Sal Mangano's Mathematica Cookbook, this time taken from Andreas Lauschke's example, is a "fast" pricer for American options. The relevant section of the book stresses the importance of performance in this context and the Mathematica code presented was heavily optimized by experts.

Jon Harrop’s F# vs Mathematica: parametric plots

Another example from Sal Mangano's Mathematica Cookbook (p.520) is an elegant little Mathematica program that uses a crude numerical integrator to plot the trajectory of a differential equation representing the populations of predators (foxes) and prey (rabbits):

Jon Harrop’s F# vs Mathematica: red-black trees

The simpler F# solution is also 20× faster at inserting 100k elements and 100× faster at computing the range of depths in the resulting tree.

Jon Harrop’s Lorenz Attractor

The Lorenz attractor is a fractal derived from the trajectory of a 3-dimensional dynamical system that exhibits chaotic flow. This blog post describes a 35-line program that computes trajectories of this attractor and visualizes them as a beautiful whisp using Windows Presentation Foundation.

Neil Carrier’s Composable Order Relations

Even before I started experimenting, I realized that checking a list for sorting was just a specific example of checking whether the pairs in a list satisfied a certain binary order relation. So I decided to work directly on a more general solution.

Neil Carrier’s Continuation-Passing Mnemonics

Learning to construct continuations can be tough. It’s easy to state how they work: they facilitate tail recursion by recursively passing the remainder of a computation. But it can be a lot harder to actually get one working from scratch.

Neil Carrier’s Dijkstra’s Shunting-Yard Algorithm

Without further ado, here is my first F# implementation of Dijkstra’s shunting-yard algorithm, including a basic test (based on the example at Wikipedia). This is probably not a minimal or most-efficient implementation, but it is a starting place.

Neil Carrier’s Arity and Unit Arguments in F# 2.0

While working on an internal domain-specific language, I encountered a case where passing a unit into a function made the syntax somewhat more readable. The completely artificial example below illustrates the concept as the function xfer1. I also tried a two-unit version, which is illustrated as xfer2.

Daniel Mohl’s Presentation: 5 Best Practices for F# Development slides and examples

Thanks to all who come out to the New England F# User Group meeting tonight!

Tomas Petricek’s Dynamic in F#: Reading data from SQL database

If you ever tried to call a SQL stored procedure directly using the SqlCommand, then you can surely appreciate the elegance of this code snippet. Let's now take a look at a larger example and some of the neat tricks that make this possible...

Erik Schulz’s Cartesian Tree Sort – Revisited, Cartesian Tree Sort – Skew Heap and Beating Quick Sort - Cartesian Tree Merge

After looking at skew heap, merge sort and Cartesian tree, I figured there has to be a way to combine all three.

Julien Ortin’s SEO Analysis in F#, and SEO Analysis in F#, a friendly application

Last time, we created a library of Search Engine Optimization (SEO) helpers. This time we’ll see how to use them to actually fetch information about your webiste rankings (and your competitors’).

Julien Ortin’s European Central Bank – extracting reference rates with F#

Every day, the European Central Bank publishes “official” reference FX (foreign exchange) rates where currencies are quoted against the Euro (expressed as EUR/XXX), or 1 EUR = xxx XXX. The exchange rates of the last thirty sessions are available in xml format which we shall try to parse. In order to do so, we use F# and active patterns, based on Don Syme’s draft paper.

Anton Tayanovskyy’s Optimizing JavaScript with F#

The need for optimizing JavaScript is very peculiar. This is not about delivering top wall-clock performance, but rather delivering the most compact (in Release mode) and most readable (in Debug mode) source. In the case of WebSharper™, it is also about relieving the compiler and the macro writer from the burden of emitting optimal code.

Chris Ballard’s My First F# Post

That said, this post will take you through my solution for Euler 54, which (somewhat unusually) isn't a particularly mathematical problem, but turns out to be a great way to demonstrate some of the features of the F# language. The basic principle of this problem is to compare two hands of cards in the game of poker, and to determine which is the winning hand.

Chris Ballard’s Prime Numbers - Building the EulerMaths library in F#

Those of you who are doing Project Euler know what I am talking about by the EulerMaths library. There are certain fundamentals which crop up again and again in the questions and it is important to work these into a reusable and performant library.

Daniel Mohl’s WPF MVVM Multi-Project Template: A Polyglot Approach

As an advocate for using the right tool for the job, I have created a new WPF MVVM multi-project template composed of an C# View project, an F# ViewModel project, and an F# Model project.

Rodolfo Ortega’s Eliza like chat bot in F# language for fun

This is a very simple Eliza like chat bot. I call it Meliza Sharp. I wrote it for having fun learning the F# language shipped with Visual Studio 2010.

Mauricio Scheffer’s Abusing PrintfFormat in F#

Pretty cool, huh? This trick can be used for other things, since PrintfFormatProc is fully reusable. For example, I'm currently using PrintfFormat manipulation to define type-safe routing in a web application

Mark Pearl’s Depressingly simple text file access

Today I was doing some work work and kept having to parse a log file. After a few hours of doing the same routine stuff I thought I might try and automate it using F#.

Mathias’s On the road from C# to F#: reading stock quotes and more stocks

Mads Kristensen has a nice post where he shows how to read stock quotes from Yahoo finance using C#, which was very helpful to get started. I figured it would be interesting to try out a conversion to F# and see what the result looked like.

F# Discoveries This Week 05/28/2010

RickM — Fri, 28 May 2010 17:24:01 GMT

Come in and see what’s new in the F# world. Every week is seems there is ever more content on an increasingly wider variety of topics. The community is growing at a very fast pace. Because of this, I’ve decided to change things up a bit with a new format. I hope you’ll find it enhances your experience in exploring this mountain of fresh F# information.

News

Silverlight 4 runtime has been released with F# support

The F# PowerPack 2.0.0.0 is out and supports Silverlight 3 and 4

WebSharper 2010 1.0 is out and is free for commercial use

F# Project Extender 0.9.2.1 has been released

The CUFP 2010 and ML 2010 Call for Presentations is active

F# is on InformationWeek 500: 20 Great Ideas To Steal

Video / Audio

Don Syme Talks with Sadek Drobi About F# 2.0, a First Class Citizen in Visual Studio 2010

Don Syme speaks about F# 2.0, its application fields, its integration in Visual Studio 2010 and F# open source Power Pack library. Don also discusses the genesis of F#, the ties with OCaml as well as its specificity.

Don Syme Answering Questions on F#, C#, Haskell and Scala

In this interview made by InfoQ’s Sadek Drobi, Don Syme, a Senior Researcher at Microsoft Research, answers questions mostly on F#, but also on functional programming, C# generics, type classes in Haskell, similarities between F# and Scala.

Amanda Laucher and Josh Graham – The state of the Art on .NET

Amanda Laucher and Josh Graham present at an introductory level some of the most important elements of the .NET ecosystem: F#, M, Boo, NUnit, RhinoMocks, Moq, NHibernate, Castle, Windsor, NVelocity, Guerilla WCF, Azure, MEF.

.NET Rocks F# Panel Live from NERD Center, Cambridge, MA

While on the Road Trip, Carl and Richard recorded this panel discussion with Talbott Crowell, Rick Minerich and Richard Hale Shaw on F# at the Microsoft New England Research and Development Center. The panel makes a very compelling case for adding a functional language to your toolchest.

Blogs

Brian McNamara’s Proggit Subreddit Graph in F# and DGML

Dear Proggit: graphs are cool, but I prefer F#, so I graphed the subreddit interconnections with F# and DGML

James’ Implementing map-reduce in F#

Again, F# proves to be a remarkably succinct language to express problems, in this case the built in syntactic sugar for tuples is a godsend!

Daniel Mohl’s F# ASP.NET MVC 2 Web Application Template and
Creating an F# Template for Visual Studio 2010

Tomas Petricek recently provided a great blog post on creating MVC web applications in F#. I thought it might be nice to also have a template that replicates the functionality of the standard C# ASP.NET MVC 2 Web Application template.

Daniel Mohl’s A Simple Inversion of Control (IoC) Container in F#

In this post I will show how to build a simple Inversion of Control (IoC) container in F#

Daniel Mohl’s Getting Started with WebSharper Platform 2010

A little while ago a cool new product was brought to my attention that allows client-based web development in F#. The name of this product is WebSharper Platform 2010. In this post, I will show a simple example for getting started with WebSharper Platform 2010.

Neil Carrier’s Computation Expressions with .NET Data Types

I’m still working on my proof-of-concept and it’s going well. One thing that’s been on my mind is the desire to use computation expressions in it somewhere. So I’ve been trying to make sure I understood computation expressions well enough to use them to good purpose.

Neil Carrier’s Active Pattern Activity and More Active Pattern Activity

I have to say the F# proof of concept is still going a lot better than I had ever hoped. Not only is it easy to port the basic algorithms from C# where applicable, but the kind of straightforward design that “functional-thinking” encourages is making for a better program with much less source code.

Phillip Trelford’s Exposing F# Dynamic Lookup to C#, WPF and Silverlight

Sometimes dynamic typing can be a pragmatic way of solving a specific problem. For example say you’re a solutions provider with a core product and have a number of clients with bespoke requirements. One client asks for a product rating feature. This can be relatively easily achieved using dynamic properties:

Phillip Trelford’s F# operator overloads for WPF dependency properties

Creating WPF elements directly from F# can produce good self-contained code, but at time is a little less readable than the XAML equivalent. Lets consider placing a button bound to a command on a grid at a certain position.

Clive Tong’s Towards an F# .NET Reflector add-in

When I had the opportunity to spent some time during Red Gate's recent "down tools" week on a project of my choice, the obvious project was an F# add-in for Reflector.

Clive Tong’s F# and the rose-tinted reflection

We're already seeing increasing use of many cores on client desktops. It is a change that has been long predicted.

Julien Ortin’s Technical analysis indicators in F# – Metadata and Reflection

In this part, we show how to use reflection to fetch the metadata attributes we have described in the first part of the technical analysis series.

Steve Gilham’s F# - excessively lazy sequences and stateful visitors

Doing something a little bit complicated here: the functional equivalent of a visitor pattern, where I want to apply a few functions to a long and potentially expensive to traverse sequence of items (so ruling out a series of iterations over the visited nodes)

Jon Harrop’s Mini hash table

Imagine you're stuck on a desert island with only a few keystrokes and you desperately need to create your own rudimentary hash table. What might you do?

Jomo Fisher’s How to Enumerate all WMI Classes

This is the F# code you would use to enumerate all WMI classes on your system and show the properties of each. of each.

Fredrik Holmstrom’s F# short hand syntax for maps and sets

I’ve always though it a shame that there is no in language short hand syntax for maps and sets in F#, something like {{foo = 1; bar = 2}} and {#1, 2#} – but having a very flexible language at my disposal I set out to find some way to achieve this, mostly for fun – but maybe someone will find a practical use of it.

Community

From StackOverflow: Scala vs F#, How do they unify OO and FP?

What are the key differences between the approaches taken by Scala and F# to unify OO and FP paradigms?

From StackOverflow: F# Static Member Type Constraints

I'm trying to define a function, factorize, which uses structural type constraints (requires static members Zero, One, +, and /) similar to Seq.sum so that it can be used with int, long, bigint, etc. I can't seem to get the syntax right, and can't find a lot of resources on the subject. This is what I have, please help.

F# Discoveries This Week 05/14/2010

RickM — Fri, 14 May 2010 21:06:49 GMT

Today, I’d like to thank all of the F# users on twitter.

Twitter’s a great place to stay up to date on the latest F# happenings and many of the posts you see here are either written by or passed on from members of this community. So, if you are interested in becoming part of the F# Twitter Community, I suggest starting with these frequent F# tweeters: @dmohl, @TigerHasse, @robertpi, @sforkmann, and @ptrelford.

I’ve also been known to occasionally tweet on F# and other programming topics. Now, on to the links.

Brian McNamara’s More F# Screencasts

My previous two screencasts (‘Getting started with F# in VS2010’ and ‘Editing F# source code in VS2010’) have been moved to MSDN, which means they’re now available in a variety of video formats. A new screencast (‘Managing F# projects in VS2010’) has also been added, so check it out!

Robert Pickering’s F# Talks in London

I’ve been in London for the past few days. I arrived Tuesday afternoon and gave at talk at “The F#unctional Londoners Meetup Group” on the Tuesday evening.

James McCaffrey’s Combinations and Permutations with F#

Understanding combinations and permutations is a fundamental skill in software testing. In this month’s Test Run column I show you how to work with combinations and permutations using code written in the new F# language.

Amanda Laucher and Josh Graham’s Pragmatic F# in Action (video)

Amanda Laucher and Josh Graham introduce the audience to F# basics showing some of its main features, emphasizing what makes it better than imperative languages.

Tomas Petricek’s ASP.NET and F# Part 1 – Creating MVC Web Applications in F#

If you want to use F# for creating an MVC application, you have a few options. It should be possible to create the web application solely as an F# project. However, we'll use a more convenient approach. We'll create a standard C# MVC project and move all the actual implementation to an F# library.

Steffen Forkmann’s FAKE – F# Make 1.20.0 Released and
Using a MailboxProcessor to speedup “FAKE – F# MAKE”

Today I released a new bugfix release for “FAKE – F# Make”. We fixed some path and logging issues and as a new feature we introduced the @@ operator which allows to combine paths.

Phillip Trelford’s Trading on IM with F#

The slides from my Trading on IM talk will be attached to this post, and the video/podcast should be appear on the Skills Matter website. I’ll also attach the 100 lines of code for shopping checkout sample, that works with a barcode scanner, I showed at the start of my presentation.

Daniel Mohl’s Integrating F# and Erlang Using OTP.NET

Recently, I ran across a post that talked about a .NET library named OTP.NET. OTP.NET is a port of a Java library named JInterface that allows a .NET application to act as an Erlang node. OTP.NET hasn't been updated in a while and the API is a bit clunky, but the provided functionality is very cool.

Nick Grattan’s Creating Web Parts with F# and
An EDSL for Emitting HTML Tables in Web Parts using F#

When writing web parts in C# for SharePoint the System.Web “table” class or “table” HTML elements are most often used for controlling layout (“div” aficionados keep your ears covered…). The code quickly gets ugly and difficult to manage – there’s no direct control to ensure correct matching of opening and closing of tags. So how about writing an EDSL that provides a syntax and constructs for doing this?

Neil Carrier’s Tiny Expert System using Monads

Below is a tiny expert system implemented using computation expressions. I managed to find a way to use the following computation expression methods: Bind, Delay, and Return.

Neil Carrier’s A Simple DSL: Tokenization to Evaluation,
S-Expressions for Semantic Networks and
A Half-Baked Scheme

This post presents a small example of the above process. It implements a small interpreter which analyzes and evaluates LISP-like prefix expressions involving integers, multiplication, and division. For example: (+ (* 1 2) (* 3 4) evaluates to a data element containing the number 14. To make clear what is happening, be sure and examine the value of tokenList before it is evaluated.

Julien Ortin’s Technical analysis indicators in F# – Bands, Signal and Ehlers

This is part of a series on technical analysis indicators in F#, based on the multi-language TA-Lib. Quick disclaimer : some of these indicators are not verified.

Yin Zhu’s F# for Project Euler Problems

Some problems have two versions of solutions, the version I first learned F# and the version based on my current knowledge of F#. The first version is usually quite easy to understand even if the reader does not know F#, while the second uses some nice F# feature or good functional programming practice in general.

Jon Harrop’s Java vs. F#

What Cliff forgot to mention is that .NET also provides value types and a far more compelling example than complex numbers is the humble hash table.

Tim Ng’s F# + WPF + Events

I recently had to do some travelling for the VS launch event in Las Vegas and QCON event in Beijing. One of the things thats nice about travelling is that it gives you time to do some things you may not otherwise do - in my case, I had a chance to try to (re) learn WPF and see how I can use F# with WPF.

Mark Needham’s Tacit Programming

I realised that this approach quite closely describes what I've been trying to drive towards in my most recent playing around with F# and it's actually quite fun trying to drive any intermediate state or storing of data in variables out of a program and just relying completely on function composition and higher order functions.

Mark Needham’s F#: My current coding approach

I spent a bit of time over the weekend coding a simple generic builder for test objects in F# and I noticed that although there were similarity with the ways I drive code in C# or Java my approach didn't seem to be exactly the same.

Ebru Cucen’s F# vs C# Samples

After my talk at ldnUG yesterday, I got nice suggestions from Zi Makki, and here is the first one: comparison between F# and C#, especially using LINQ. This subject had been quite popular once in a while, now it is probably my time to focus on this subject.

Bjorn Rochel’s Kata StringCalculator in F#

Two meetings ago we decided to do some coding on every meeting. The previous meeting we solved Kata FizzBuzz and on yesterday’s meeting we tried to dance with Roy Osheroves Kata StringCalculator.

Gunnar Peipman’s F# in ASP.NET, mathematics and testing

Starting from Visual Studio 2010 F# is full member of .NET Framework languages family. It is functional language with syntax specific to functional languages but I think it is time for us also notice and study functional languages. In this posting I will show you some examples about cool things other people have done using F#.

Luis Diego Fallas’s Defining mutually recursive classes in F#

As explained in Adventures in F#--Corecursion defining mutually recursive functions requires the use of the and keyword between function definitions. As briefly mentioned in the Type Definitions section of the manual, the and keyword can also be used in types.

Nancy Strickland’s New Features in F# 2.0 Training Video

Describes the new features in F# version 2.0, which comes included in Visual Studio 2010.

DotNetRocks in Boston (with F# Panel)

The panel suggested we add F# to our repertoire and understand its strengths, and use it where it's beneficial. I'm going to take that advice. Bottom line is if I can replace 50 lines of confusing C# code with 10 lines of elegant F#, I've done myself a service.

F# Discoveries This Week 04/16/2010

RickM — Fri, 16 Apr 2010 18:16:13 GMT

It’s finally here. After years of work, F# 2.0 is out and ready to change the way you program in .NET. Come in for launch information, updates to projects written in F# and some great posts on actually using the language.

Don Syme’s F# 2.0 Released!

F# is a productive functional and object-oriented programming language for .NET that enables users to write simple code to solve complex problems. Its succinct syntax and powerful type inference lets users stay closer to the domain they are working in, and the integration into .NET and Visual Studio gives rich access to the expansive .NET platform.

Lisa Feigenbaum’s VS 2010 Keyboard Shortcut Posters Now Available for VB, C#, F# & C++

The Visual Studio keyboard shortcut posters are always very popular and are now available for Visual Studio 2010! Please choose the one that corresponds to your choice of Visual Studio Development Settings. Print out a poster to place on the wall, or a quick reference card to keep on your desk.

Chris Smith’s Good News and Sad News - Leaving Microsoft

For me at least, the excitement and buzz of the Visual Studio 2010 launch will be short lived. Earlier this month I’ve accepted a position at another software company and will be leaving Microsoft. […]

However, I will still be part of the F# community and you will definitely see a second edition of Programming F# when the time comes. In fact, next Tuesday 4/20 I’ll be giving a talk: Writing a Java to x86 Compiler in F# at 11:00AM PST.

Steffen Forkmann’s “FAKE – F# Make” and NaturalSpec 1.0 Released

Yesterday Microsoft released the RTM versions of Visual Studio 2010, .NET Framework 4.0 and F# 2.0.0.0 and so it is time to announce the first official releases of “Fake – F# Make” and NaturalSpec. Both projects are now compatible with Visual Studio 2010 RC and RTM and the corresponding F# versions.

F# Refactor (No Release Yet, Check out the Repository)

Deisgned to bring Code Refactoring capabilities to the F# Language in Visual Studio 2010.

Brian McNamara’s Using VS2010 to edit F# source code (and a little LOGO EDSL) and Fun with turtle-graphics in F#

The code on the screen during the video is a little EDSL (Embedded Domain-Specific Language) for a subset of LOGO. The full code is below; you can just copy it into an F# application project to run it.

Brian McNamara and Chris Smith’s Alt.NET Workshop slides and code

Chris and I each had our own slide deck, so to go in order you’ll have to switch back and forth between the two decks, like we did during the talk (Chris’s intro, my part on functional programming, Chris’s section on OO programming, my part on Async, Chris’s case study). At the end of my deck there’s also some bonus slides on units of measure that we didn’t have time for.

David Worthington’s ‘Midori’ concepts materialize in .NET

"Midori is an attempt to create a new foundation for the operating system that runs ‘inside the box,’ on the desktop and in the rack.

Neil Carrier’s Sliding Block Puzzle in F# and WPF and
Simple WPF Animation

I realized that I wanted something more visual with which to test my search algorithms. I have also been wanting to learn how to write WPF applications using F#. To that end, I offer the following F#/WPF application of the famous Fifteen Puzzle, the ancestor of all sliding-block puzzles.

Neil Carrier’s Generic Binary Heap

I'm pretty sure I'm going to need a priority queue for my A* search, so I decided to code a generic heap class in F#. The F# code below is largely a translation from Robert Sedgewick's Algorithms in C (Parts 1-4).

Phillip Trelford’s What’s happening? Loosely coupled events

For example if you wanted to publish an event from any window that could be observed by any other window without them all having intimate knowledge of each other.

Phillip Trelford’s Implementing IObservable and extending Observable

Following on from my post yesterday on implementing loosely coupled events; the following somewhat longer F# sample provides a simple System.IObservable<T> implementation for event consumers.

Daniel Mohl’s A DHT in F#: Using Higher Order Functions for the Service Operation Calls

In my last post, I provided a start to a distributed hash table in F# using WCF. One of the major limitations of that example was that only two nodes could ever be on the node network at a given time.

Daniel Mohl’s Talking to CouchDB via F# and Symbiote

Alex Robson recently announced a set of libraries that, among other things, makes talking with CouchDB from a .NET language very easy. […] As you can see, interacting with CouchDB via F# and Symbiote is a snap.

Vladimir Matveev’s MailboxProcessors: Erlang-style concurrency

MailboxProcessor is combination of message queue and message handler build atop of Asyncs infrastructure.

Mark Pearl’s F# and the useful infinite Sequence (I think)

So the question is begged - how would you create a sequence that you are sure will be large enough to hold the solution to the problem? Well… You can’t know!

Mark Needham’s F#: The ‘defaultArg’ function

While reading through an old blog post by Matthew Podwysocki about writing F# code in a functional rather than imperative way I came across the 'defaultArg' function which I haven't seen previously.

F# Discoveries This Week 03/26/2010

RickM — Fri, 26 Mar 2010 16:47:24 GMT

A ton of new posts this week, far too many to enumerate. My “Favorite New F# Blogger of the Week” (seems like this is becoming a trend) is the mysterious Neil of Techneilogy. I’ve been enjoying his honest exploration of F# and semantic networks very much.

Also, I’ve been hanging around in the ##fsharp channel on irc.freenode.net a bit. There’s a bunch of great people there, some of whom are already using F# at work and are eager to talk about it. Check it out if you have the inclination.

Chris Smith’s Writing a StarCraft Bot in F#

We now have all the pieces in place, but creating an AI-bot for a program not meant to be extended will be tricky. StarCraft Bot 9K has the following architecture, which follows the footsteps of the Java ProxyBot available on the AIIDE Website.

Don Syme’s Video Introductions to F# C9 Series

Who better to lecture on the topic than Don? This three part series will serve as an introduction to F#, including insights into the rationale behind the history and creation of Microsoft’s newest language.

Luca Bolognese’s Tracing spread trades in F# parts one (XUnit and FsCheck) and two (WPF and MVVM).

I have a bunch of spread trades open. Spread trades are trades where you buy something and you sell something else generally in the same amount. You hope to profit from the widening of the spread between the price of the two instruments.

Robert Pickering’s #Develop, F# and Google Summer of Code

Chris told me one area they are interested in extending is the F# integration into #Develop; particularly they’d like to get the auto-completion working. So if you’re a CS student on the lookout for a summer job, you could end up being paid by Google to work on F#!

Robert Pickering’s Beginning F# Workshop and Progressive.Net

I’ll in London on the 10th/11th May giving a two day course entitle “Beginning F# Workshop” in conjunction with the lovely folks at Skills Matter.

Edinburgh University’s Advances in Programming Languages Course, Lecture 19: Heterogeneous Metaprogramming in F#

General overview of metaprogramming, with a range of examples in different languages ranging from C macros through Java reflection to MetaOCaml. Brief summary of the F# language, its history, features, and upcoming release in VS 2010.

Matt Moloney’s Dynamically extending applications using MEF and the new F# CodeDom.

I wrote this little applet to see what the combination of MEF and the F# CodeDom would look like, and for the record it looks really really good. This combination opens a whole lot of doors. By using the F# CodeDom the plugin source code can brought in from anywhere;

Julien Ortin’s Technical analysis indicators in F# – Momentum

This is part of a series on technical analysis indicators in F#, based on the multi-language TA-Lib.

Vladimir Matveev’s Solving Python Challenge with F# – The Chronicles

WARNING!!! If you are going to pass through the Python challenge then stop reading this post, cause it contains solution to 24 level.

Vladimir Matveev’s Data structures: Finger Tree (Part 1.5)

Last time we stopped on “immutable deque” stage. Today we will explore a few additions that can endow deque with super (hmm..human/deque?) powers.

Vladimir Matveev’s Fun with recursion

Recursion is an extremly useful tool in the toolbox of every developer. Many problems have recursive nature and thus best solved with recursion. Tree-like stucture is a very nice candidate for demonstration.

Vladimir Matveev’s F# and WPF or how to make life a bit easier

Not so long ago I was working of small F# script (excellent feature BTW) that performs some data processing and displays summary (using WPF)at the end. All the WPF samples I met in the web utilize object model to create UI, but let's make a confession: making relatively complex UI with object model sucks.

Phillip Trelford’s F# Agents and Retlang: quick comparison

Erlang style message passing is a great way of simplifying concurrency. The open source Retlang library aims to bring some of the benefits to .Net languages like C# and VB.Net. Whereas F# has built-in message passing support with the MailboxProcessor also referred to as Agents.

Neil’s Recap of Tiny Expert System and Next Step in the Tiny Expert System?

Before I move on, let me post a re-do of the the original lazy-evaluated style tiny expert system, incorporating all I've learned about F# over the last couple of weeks.

Neil’s Refined Semantic Network, Data-Driven Semantic Network, Latest Semantic Net Experiment, Yet Another Semantic Network and Semantic Net Search 0.1

Continuing on the path of using classic A.I. tutorial examples to teach myself F#, here is an example using semantic networks. So I created a system in which basic semantic nodes and links can be reified into object instances.

Neil’s Search Using Continuations and Improved Continuation Search

This one returns a list in the right order, and the example shows how to detect circularities. It's a little tricky; the tail recursion involves both a direct tail recursion and a continuation that results in a tail call. I had to run tests to convince myself it really wasn't eating up the stack, lol.

Oliver Strum’s DevWeek 2010 Slides and Samples

Last week I was down in London and spoke at DevWeek 2010. As usual, it was a great conference! Thanks to everybody who attended my talks!

Can Erten’s Happy Pi Day and Monte Carlo Method

Calculating Pi is generally the hello world of Monte Carlo Method in Stochastic Calculus. So for today, I will try to give a sample calculation of pi as monte carlo in F#.

Ade Miller’s NBody.net F# Integrators Code Available

A Forward Euler integrator and a wrapper for it which implements a Barnes-Hut tree code. I’ve blogged about this before. It’s an Octree implementation in F# which uses the asynchronous computations feature to scale across multiple cores.

Matt Davey’s F# and XSD.EXE

Which, thanks to Luke over on the F# Visual Studio team, means I can do this: […] Which now means I can stop hand crafting FpML types in my F# cashflow code.

Ebru Cucen’s F# Samples

If you had the chance to start playing with F#, here are some nice challenges for you. If not you may want to look at from where to start.

Daniel Mohl’s Code Kata and Project Euler - Problems One and Two,

See also: Mike Robert’s solution to problem one and Steffen Forkmann’s solution to problem two.

Recently, I've been thinking about the concept of Code Kata and the personal improvement that this type of practice can bring. I started thinking of types of exercises that I could do to utilize this concept. After looking around on the web, I landed on projecteuler.net and found that the problems listed seemed to fit my agenda perfectly.

F# Discoveries This Week 02/08/2010

RickM — Mon, 08 Feb 2010 19:28:41 GMT

Back again with another F# community roundup. There’s been a ton of great content this week, almost too much. To try to combat this I’ve attempted to sort posts roughly in terms of how interesting I found them. All were worth the read though.

Also, I’ll be speaking this Wednesday on F# at the Boston .NET User Group. If you find yourself there, be sure to say hello!

Don Syme’s Introduction to F# (Video 1 of 3)

Dr. Don Syme is a principal researcher in MSR Cambridge. He has a rich history in programming language research, design, and implementation (C# generics being one of his most recognized implementations), and is the principle creator of F#.

Ashley Feniello’s FScheme Part 8: Language vs. Library

Perhaps this post should have gone along with the one about macros and how Lisp is a “programmable programming language.” The common tension in any language or runtime design is how much to build in as primitives and how much to implement as libraries within the language or atop the runtime.

Luke Hoban’s F# for Parallel and Asynchronous Programming

Last November at PDC 2009 in Los Angeles I gave a talk on F# for Parallel and Asynchronous Programming. The talk begins by covering basic F# concepts, and then focuses on four challenging issues related to concurrency and the tools F# brings for addressing these - immutability, async workflows, and agents.

Andrew Brehaut’s On Iteration (Could just as well be entitled “Why Programmers Leave Python/C#/Java")

There is an observable trend in Python programmers that results in a reasonable section of them moving to functional programming languages. This trend is encouraged by the Python language, and has a couple of temporal considerations.

Matthew Podwysocki’s Using and Abusing the F# Dynamic Lookup Operator

Much like C# 4.0 has the ability to do dynamic lookup, F# also has the same capability, although in a different capacity. The language has support for a dynamic lookup get operator ( ? ) and set operator ( ?<- ), but note that I said support and not actual implementation. The actual implementation is up to you and how you want to use it.

Matthew Podwysocki’s A Kick in the Monads – Writer Edition

In the past couple of Monads posts, we’ve talked briefly about the State and Reader Monads and their potential uses and misuses. Before this series completes, I have a few more to cover including the Writer, Continuation and eventually Observable monad. Today, we’ll get started looking at the Writer Monad and what it can do for us.

Ashley Feniello’s Recursion Is the New Iteration

Not all recursive expressions represent recursive behavior. In fact, iteration can be expressed recursively. One trick when considering the process that an expression represents is to think of functions as reducing to values rather than returning them. In a pure functional style (precisely because of referential transparency) you can do analysis by successive substitution.

Julien Ortin continues his series on Purely Functional Data Structures with a Real-time double-ended queue, a Skew binary random access list and a Binary random access list

This post describes the F# implementation of the <insert data structure here> from Chris Okasaki’s “Purely functional data structures”.

Flying Frog Consultancy Presents - John Conway’s Game of Life in 32 lines of F#

John Conway's Game of Life is a famous example of a simple cellular automaton that produces remarkably diverse results. The game can be implemented in only 32 lines of F# including real-time visualization using Windows Presentation Foundation as follows:

Brian McNamara’s An RSS Dashboard in F# (Part 3)

Last time I covered IObservables and we created a useful ObservableSource class. Today I’ll cover the next technology piece of the app: reading RSS feeds. I’ll discuss the design considerations regarding how to poll feed for updates and publish feed items as IObservables, and walk through one implementation.

Nick Gravelyn’s Pong in F# with XNA Game Studio

A few of my colleagues were discussing F# today and when/where/how it is/isn’t better than C#. I haven’t ever really used F# beyond a very, very brief look at the syntax, so tonight I decided to see what it was all about. As a little project, I decided to make Pong with XNA Game Studio using F# with Visual Studio 2010.

Jim Burger’s Maybe F# isn’t for you…

If you aren’t excited about new ways to tackle the concurrency problem, or new approaches to handling generic and mathematical problems, and if the thought of breaking out the shiny new lexer and parser don’t give you a tingle, then maybe F# isn’t actually marketed at you at all.

Alex Turner’s Calling F# from COBOL and Back Again (CodeProject)

Running languages on .NET is ultra-powerful. Using managed COBOL (from Micro Focus), it is possible to use F# code to work with COBOL code. Imagine a Cloud based F# map reduce system consuming legacy COBOL - yes, that really is on the horizon.

Steffen Forkmann’s New syntactic sugar for “FAKE – F# Make”

The new version 0.27 of “FAKE – F# Make” comes with new syntactic sugar for build targets and build dependencies. Don’t be afraid the old version is still supported – all scripts should still work with the new version.

Jared Parsons’s Having fun with events in F#

Recently I ran into a situation where I needed to handle some events in F# in a special way. In this particular case I wanted to be able to disable and re-enable my handler based on changes in the program. Essentially the C# equivalent of continually adding and removing the handlers.

Steve Gilham’s “Hello Glade#” from F#

Another bit of spiking, a rather tardy follow up from raw GTK#, starting from the C# example at the Mono Project site, but incorporating the earlier example, so as to build in a clean application exit, for one thing.

Luis Diego Fallas’s Using a Webcam with WIA and F#

In this post I'm going to show a small example of taking a picture using a Webcam with Windows Image Adquisition 1.0 . This API seems to have changed in Vista and above, the following code only applies to XP.

Flying Frog Consultancy’s WPF Tic-tac-toe demo

The article walks through the design and implementation of a multithreaded program that uses logic programming to create an unbeatable computer opponent and Windows Presentation Foundation to provide a graphical user interface in only 115 lines of elegant F# code!

A (Relatively Reasonable) Discussion of F# on Slashdot

OCatenac passes along an interview with Don Syme, chief designer of F#, which is Microsoft Research's offering for functional programming on the .Net platform. Like Scala, which we discussed last fall, F# aims at being an optimal blend of functional and object-oriented languages.

F# Discoveries This Week 08/31/2009

RickM — Mon, 31 Aug 2009 17:44:43 GMT

This week we have a fresh video interview with Chris Smith. This is in addition to some excellent writing on prototyping DSLs, asynchronous workflows, WPF, functional composition and the open/closed principle.

I would also like to note that for the next few weeks I will be off vacationing. I apologize in advance for any missed or delayed updates. If you live in Japan and would like to discuss F# or functional programming in general, I would love to meet up with you for tea or a beer.

Chris Smith is interviewed on Technology and Friends

Chris Smith is a software design engineer on the Microsoft Visual F# team. In this interview, Chris describes the uses of F# and how it differs from object-oriented languages, such as C# and Visual Basic.

Adam Granicz discusses Prototyping DSLs in F#

To build a domain specific language, you need a quick and effective prototyping process that can parse your language syntax and perform semantic checking.

Daniel Mohl writes an Asynchronous Directory.GetFiles and File.Copy

The following examples show how it could be solved with F# both synchronously and asynchronously. While this is definitely not production ready, it provides a few samples of how asynchronous workflows can be used in the wild.

Steve Horsfield describes programmatic addition of a WPF Data Template to a Resource Dictionary

I have noticed some interest in my earlier post on how to add a WPF data template to a resource dictionary in code and so this post is a demonstration of the technique. The code is presented in F# but I have deliberately kept the code simple and fairly non-functional so that those of a C# or VB.NET background can follow the process easily.

Steve Horsfield explores function composition operators

Following on from my last post, and in preparation for a series on producing a full WPF application in F#, in this post I discuss the differences between the |> and >> operators and some additional functions I find helpful for composing functions.

Steffen Forkmann demonstrates the open/closed principle in F#

In object-oriented programming, the open/closed principle states "software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification”

If we follow this principle we get lot’s of small and testable classes. I want to demonstrate this with a simple spam checker for mails.

F# Discoveries This Week 08/23/2009

RickM — Mon, 24 Aug 2009 02:18:00 GMT

This week Steve Horsfield continues his adventures with WPF while Matthew Podwysocki posts more on the .NET Event Model. Meanwhile, John Harrop shares a video tutorial on F# interactive and Chris Smith provokes meta discussion on the best way to present F#.

Upcoming Events

Houston F# Users Group – Meeting August 27th 7:00pm.
New England F# User Group – Meeting September 7th 6:30pm.

If you would like your F# event to be listed here, please let me know via the email link at the top of this page.

Posts of Note

Steve Horsfield on WPF, Resources and F#

The problem is a simple one: add a toolbar image into an assembly and make it available as a resource in WPF, but use only XAML and F#.

Steve Horsfield on Chaining Side Effects in F#

The first question that any functional programmer should ask is, “why are there side effects?!” Side effects are anathema to functional programming purists because they introduce many kinds of undesirable characteristics into code, limiting optimization and restructuring options.

Matthew Podwysocki on Creating and Disposing .NET Event Handlers

So far in this series, I’ve covered a bit about what first class events are in F# and how you might use them. […] This time, let’s look at how we might manage the lifetime of a given event subscription.

Jon Harrop’s F# Interactive Tutorial Video for Beginners

This is a quick teaching on the use of the F# Interactive Mode which lets you, like the OCaml top level, type code in in real time.

Chris Smith’s F# for Architects: Hitting the Sweet Spot

When I was at DevLink last week I gave a talk designed to specifically identify why and when you should use F#. I was going to post the slides, but then I realized that they are in the form of a ‘presentation deck’ rather than a ‘reading deck’. So rather than having a few vague slogans and images in a .pptx file, I’ve transcribed my talking points.

I would consider Chris Smith’s post a must read for anyone giving talks on, or otherwise promoting, F#. I gave much thought to a number of different aspects of my F# presentations after reading this.

F# Discoveries This Week 08/16/2009

RickM — Sun, 16 Aug 2009 23:53:00 GMT

This week we have some user group meeting announcements, WPF dependency properties, first class composable events, and a few interesting statistical modeling techniques.

Houston F# Users Group – Meeting August 27th 7:00pm.

We'll be having an interactive, hands-on session where we'll actually get to code some F#. All levels of knowledge are welcome, and there will be food!

New England F# User Group – Meeting September 7th 6:30pm.

Robert Pickering will be speaking on why F# is the way it is.

Steve Horsfield on Creating WPF Dependency Properties in F#

This is a quick post demonstrating how to create WPF Dependency Properties in F#. There is a bit of a trick to it as you have to use the val keyword to define a field and that field must be mutable and you also have to use explicit interface access.

Matthew Podpysocki on First Class Composable Events in F#

Event-based programming is a pretty common scenario in .NET programming today, especially used in user interface programming. These events are a way of a class to notify when something of interest happens to an object, such as clicking a button on a form. Just as you would do in C#, programming with events is fairly straight forward to add and remove event handlers from an object.

The Mad Economist on General Linear Regression in F#

In the general linear regression model, one of the assumptions is that the variance is constant across all observation points.

The Mad Economist on Serial Correlation in F# (Part 1)

The question here is to see how sensitive coal consumption is the relative price of coal versus natural gas. For example, it is interesting to know how easily electric utilities can swap coal for gas depending on their relative prices.

The Mad Economist on Serial Correlation (Part 2)

In my last post I set up an example dataset and then showed how use the Durbin-Watson statistic to test for serial correlation. Once we have recognized that serial correlation exists, we need to make the appropriate adjustments because OLS is no longer the best estimation technique. We need to rely on GLS to perform our estimation.

Discoveries This Week 07/19/2009

RickM — Sun, 19 Jul 2009 18:45:06 GMT

With the impending release of Visual Studio 2010, the F# Community continues to wind up. This week we have finally gotten our F# User Group Videos up. In addition, we also have a wide ranging selection of fresh F# content including Units of Measure, XML parsing, WPF Games and Pattern Matching.

New England F# User Group Talks

Note: As the server is currently moving to a new location, our site may be temporarily down. If you encounter an error, please try again later.

This past week we’ve managed to get up video from a bunch of our past FSUG talks. Original F# video content here from such famed speakers as Richard Hale Shaw and Amanda Laucher.

Matthew Podwysocki’s Modeling DSLs with F# and Units of Measure

The conciseness of the language makes it an ideal candidate for scientific DSLs where such units of measure are important, but as we can see from this example, it could even apply to the general physics of game play.

In this post, Matthew elegantly displays the beauty of Units of Measure outside of it’s standard scientific computation context. If you are in the Boston area, be sure to catch him speak at our next F# user group meeting on August 3rd.

Mark Needham’s F#: Active patterns for parsing xml

Making use of the active pattern in the code has made it much easier to work with than passing around a sequence of tuples as I was doing previously. It has also made it easy to exit from the program early if there is a problem with the data inputted.

I find XML parsing to be one of the most consistently painful programming tasks. No matter what constructs seem to be added to the .NET platform, differences between the declarative and imperative seem to become most obvious when the two paradigms collide.

However in this case, I found Mark’s approach to XML parsing via reactive patterns refreshing. I also like his test-first approach. He is one of few bloggers I have seen practicing anything close to true TDD.

Phillip Trelford’s Mastermind F# WPF Game Sample

While playing around with the F# September CTP over the last week, I made a short, <300 lines, implementation of the Mastermind board game using some Windows Presentation Foundation (WPF) controls.

Seeing game or simulation implementations in F# never ceases to amaze me. In this case, what would be a moderately large project in C# is not even 300 lines of F#. Phillip’s Mastermind is also interesting in that it demonstrates how seamlessly WPF integrates with F#.

Gordon Hogenson’s Talk, Patterns and Match Expressions in F#

In this video, programming writer, Gordon Hogenson explains and gives examples of patterns in F# and explains the use of the match expression to control branching based on patterns in data.

I don’t believe I have seen Gordon speak in the past and enjoyed this talk very much. He does a great job at presenting pattern matching in a way which is very accessible to the every day C# programmer.

Rick Minerich's Development Wonderland : wpf

F# Discoveries This Week 10/11/2010

News

Audio and Video

Tools / Projects

General

Teaching and Basics

F# Discoveries This Week 08/08/2010

News

Audio/Video

F# Articles

Miscellaneous

F# Discoveries this Week 07/09/2010

News

Audio / Video

Articles

Erik Schulz’s Cartesian Tree Sort – Revisited, Cartesian Tree Sort – Skew Heap and Beating Quick Sort - Cartesian Tree Merge

Julien Ortin’s SEO Analysis in F#, and SEO Analysis in F#, a friendly application

Mathias’s On the road from C# to F#: reading stock quotes and more stocks

F# Discoveries This Week 05/28/2010

News

The CUFP 2010 and ML 2010 Call for Presentations is active

Video / Audio

Blogs

Daniel Mohl’s F# ASP.NET MVC 2 Web Application Template and Creating an F# Template for Visual Studio 2010

Neil Carrier’s Active Pattern Activity and More Active Pattern Activity

Community

F# Discoveries This Week 05/14/2010

Steffen Forkmann’s FAKE – F# Make 1.20.0 Released and Using a MailboxProcessor to speedup “FAKE – F# MAKE”

Nick Grattan’s Creating Web Parts with F# and An EDSL for Emitting HTML Tables in Web Parts using F#

Neil Carrier’s A Simple DSL: Tokenization to Evaluation, S-Expressions for Semantic Networks and A Half-Baked Scheme

Julien Ortin’s Technical analysis indicators in F# – Bands, Signal and Ehlers

Daniel Mohl’s F# ASP.NET MVC 2 Web Application Template and
Creating an F# Template for Visual Studio 2010

Steffen Forkmann’s FAKE – F# Make 1.20.0 Released and
Using a MailboxProcessor to speedup “FAKE – F# MAKE”

Nick Grattan’s Creating Web Parts with F# and
An EDSL for Emitting HTML Tables in Web Parts using F#

Neil Carrier’s A Simple DSL: Tokenization to Evaluation,
S-Expressions for Semantic Networks and
A Half-Baked Scheme