Rick Minerich's Development Wonderland : parallelism

F# Discoveries This Week 01/13/2010

RickM — Wed, 13 Jan 2010 16:59:05 GMT

Back again this week with a fresh batch of F# Posts, Videos and Events. I’ve been enjoying Matthew Podwysocki’s “Much Ado About Monads” series quite a lot. They are well worth checking out for beginner and advanced alike.

Events

If you would like to see your event here, send me an email via the link at the top of the page.

Rick Minerich - Charleston SC Technology Users Group on the 27th of January (check out the awesome flier)

Steffen Forkmann - Frankfurt .NET Usergroup on the 21st of January

Posts

Don Syme’s Async and Parallel Design Patterns in F#: Parallelizing CPU and I/O Computations

One simple way to write parallel and reactive programs is with F# async expressions. In this and future posts, I will cover some of the basic ways in which you can use F# async programming - roughly speaking, these are design patterns enabled by F# async programming.

Don Syme’s F# Interactive Tips and Tricks: Visualizing Data in a Grid

The demos in my F# talks use a number of coding snippets to acquire, generate and display data interactively. Some of these little snippets are not so well known, but they are useful :-)

Don Syme’s F# Interactive Tips and Tricks: Formatting Data using AddPrinter, AddPrintTransformer and %A in sprintf/printf/fprintf

Here are some tips and tricks for formatting data in F# Interactive. This is not meant to be a comprehensive guide, just enough to get you started. Please let me know if you need more examples.

Matthew Podwysocki’s Much Ado About Monads – Reader Edition

So, our ultimate goal would be instead to have our environment set once and then read from it implicitly. We still want to keep what we have here in terms of our script, but change the underlying mechanism for how it happens.

Anton Schwaighofer’s SkillsMatter.com talk: F# and Units-of-measure for Technical Computing

I will start by giving an introduction to units-of-measure and their implementation in F#. I'll work through smaller and larger code examples that make use of units-of-measure.

Nancy Strickland’s MSDev.com Training Session on F#

Visual Studio 2010 includes a new programming language, F#. This session explains and provides a walk-through demonstration of basic programming in F#.

Julien Ortin continues his series on Purely Functional Data Structures with a Lazy Pairing Heap, a Real-time Queue and Bottom-up Merge Sort

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

Mauricio Scheffer’s Translating Haskell to F# and other considerations

BUT, syntactic similarity does not imply that they're semantically the same. There's a fundamental difference from the original code: Haskell is a lazy language, while F#, coming from the ML-family, does eager evaluation.

Mark Needham’s F#: Refactoring to pattern matching

I was looking through some of the F# code I've written recently and I realised that I was very much writing C# in F# with respect to the number of if statements I've been using.

Mark Needham’s F# attempt at Roy Osherove’s TDD Kata

As I've mentioned in a few of my recent posts I've been having another go at Roy Osherove's TDD Kata but this time in F#.

Holoed’s Weak Subscribe to an IObservable Source

A code snippet describing how to subscribe to an event via a weak reference.

Erik Schulz’s Resource Pool in F#

I’ve been toying around with F# recently, it’s good to see an example that you can easily compare and contrast with the C# version.

Ade Miller’s Gotchas: Common Traps for the F# n00b

I spent a bunch of time over the holidays getting to know F# a bit better. I think I now consider myself to be truly dangerous with it. A couple of things which repeatedly bit me as I stumbled through learning F# as a n00b.

F# and You! - New Hampshire User’s Group and Beyond

RickM — Mon, 26 Oct 2009 16:24:49 GMT

I’ve been working for a while on a new presentation which I was finally able to give last week at the New Hampshire .NET User Group. F# and You! focuses on painting the big picture about F# instead of the off-putting details like having to learn new syntax.

For this new presentation I start by discussing the adoption of functional programming on other platforms by using Scala, Erlang and Haskell as examples. I then continue on to how the algorithmic programmers are moving to functional languages while UI developers are moving towards declarative.

This then naturally raises the question of why programmers would choose a specific style of programming for a specific task. The answer, of course, is that when you work close to a domain you can build things more quickly and with a lower error rate.

This then transitions easily into the specific beneficial properties of functional programming (and F#).

General Overview:

The Separation of UI and Back End
What is Functional Programming? (Functional Concepts)

Pure functions
Immutability
Lambda Expressions
Higher Order Functions
Recursion

The Benefits of Functional Programming

Code Compression
Parallelism
Robustness

Proof is in the Pudding

TrueSkill
Grange Insurance Rating Engine
MSN adCenter

Wrap-up

I’ve also found that it is useful to show the latest circulating version of the Ant Colony simulation I wrote over a year ago. I found a version in Don Syme’s JAOO Talk code samples but am not sure who has been keeping it up to date. A big thanks to whoever that person is. It provides some sweet eye candy to dull the bitterness of the technical Functional Concepts section.

Planned (and Past) “F# and You!” Locations:

11/10/2009 – CT .NET Developers Group (Farmington, CT)
10/28/2009 – Technology Users Group (Charleston, SC)
10/21/2009 – New Hampshire .NET User Group (Nashua, NH)

See the new Other Events section of our F# User Group site for information on other upcoming F# talks.

Downloads:

Latest Slides
VS2008 Code Samples

Discoveries This Week 08/02/2009

RickM — Mon, 03 Aug 2009 03:57:00 GMT

Tomorrow Matthew Podwysocki will be speaking at the New England F# User Group. I also have some great links today with Don Syme at QCon08, why we need the rec keyword, regular expression parsing and graphing with GLEE.

Tomorrow @ FSUG: Matthew Podwysocki on Parallelism in F#

With the increasing amount of data available to us, we need new ways of thinking around how to create scalable solutions in order to best exploit it.

I’m a long time fan of Matt’s blog and am looking forward to see him speak. We’ve gotten most of the bugs out of our video workflow and so I hope to have his talk up on the New England F# User Group site early this week.

Don Syme at QCon08, F# – Succinct, Expressive, Efficient Functional Programming for .NET

Don Syme presents F# basics, a typed functional language for .NET that combines the succinctness, expressivity, and compositionality of functional programming with the runtime support, libraries, interoperability, tools, and object model of .NET.

I’m always happy to find another instance of Don Syme speaking. In this talk he focuses on why functional programming is worth Microsoft’s investment in time.

Code Crafter, F#: Why the rec?

One of the first things that I noticed is that in order to declare a recursive function you have to be explicit about it in the function definition. You have to declare it with the rec keyword. […] But I don't know why they didn't do this by default.

Interestingly enough, it turns out that the reason for the rec keyword is required is due to the way Hindley-Milner type inference algorithm handles mutually recursive functions. Without the keyword the algorithm would be unable to generalize types appropriately.

Steve Horsfield, F#: Building a Regular Expression Pattern Parser

One of the habits of a good functional programmer is to use tail-recursion. This allows the compiler to convert recursion into iterative methods that can handle any length of input. I have attempted to use this. […] I have also structured the code into modules to demonstrate some of F#’s features in this regard.

Beautifully structured code for a first stab at F#.

Steve Horsfield, F#: A Data Structure For Modelling Directional Graphs and F#: Graphing with GLEE

In my previous post, I described how to parse a regular expression pattern into an abstract syntax representation. The next phase is to transform the parsed syntax into a finite state machine. I have chosen to model the FSM as a mathematical directional graph (digraph). This post describes the implementation of this module in preparation for the actual compilation step.

Another excellent couple of samples from Steve. I had not seen GLEE in the past and have had a number of projects in which it would have been quite useful.