Rick Minerich's Development Wonderland : F#, C#, roundup

F# Discoveries This Week 11/22/2009

RickM — Sun, 22 Nov 2009 23:49:52 GMT

Over this past week at PDC I was lucky enough to see some fantastic sessions and spend time with members of the F# and greater Visual Studio language teams. Naturally, these experiences have left me both floored and swimming in new ideas. This edition of Discoveries This Week includes both the very best of what I saw at PDC 2009 and the most outstanding things I’ve glimpsed going on in the F# community. Please do enjoy.

Reflection on the PDC Keynotes

For the most information in the shortest amount of time I suggest watching the day one and day two PDC keynotes. They are both jam packed with exciting announcements and demos. While at PDC I wrote about my experience watching these here (day one) and here (day two).

Microsoft Perspectives on the Future of Programming

Come hear from several of the Microsoft senior technical leaders about the future of programming, programming languages, and tools.

If you watch just one PDC session let this be it.

With Butler Lampson, Erik Meijer, Don Box, Jeffrey Snover, Herb Sutter, and Burton Smith, Microsoft’s best gathered to debate the future of programming in a twitter driven panel at PDC. I was happy to be able to contribute with a question on type systems which erupted into quite a disagreement. I will be writing about this session at length, and reflecting on my past thoughts about this topic, in the near future.

Luke Hoban’s F# for Parallel and Asynchronous Programming

F#, a functional and object-oriented language for Microsoft .NET, adds many tools to make parallel and asynchronous programming both fun and easy. Come hear the core concepts of the F# language, and see how ideas like immutability, functional design, async workflows, agents, and more can be used to meet the challenges of today’s real-world applications.

By combining small, easily understood, ideas Luke constructs F#’s big picture in the most engaging way I’ve seen to date. This is now my go to talk for people who are interested in, but new to, the F# programming language.

Jomo Fisher’s F# Scripting, .NET 4.0 and Mixed-mode assemblies

One of the recent problems we’ve seen is that, because of the support for side-by-side runtimes, .NET 4.0 has changed the way that it binds to older mixed-mode assemblies. These assemblies are, for example, those that are compiled from C++\CLI. Currently available DirectX assemblies are mixed mode.

This clever approach to switching the F# REPL to 2.0 binding mode is particularly handy to know.

Matthew Moloney’s Collaborative Development Using F# Interactive

This is a proof of concept of an interactive collaborative development environment I built using F# Interactive. The aim here is to explore different ideas for further development, not so much as to present an alternative to Visual Studio.

I couldn’t pass this very cool idea up. I can’t help but think about extending this to full feldged explorative programming community websites.

Bart Czernicki’s Silverlight 3 and F# Support in Visual Studio 2010

The goal of this blog post is to make you aware of F# support in Silverlight in Visual Studio 2010. In addition, this blog post shows an example why F# is going to be very important for Silverlight architects and developers. Note: This is NOT an intro to F#.

A great post. I am always interested in seeing concrete examples of F# adding value to existing technologies and platforms. I have a sneaking suspicion that there are very few places where it won’t.

F# Discoveries This Week 11/02/2009

RickM — Mon, 02 Nov 2009 15:05:22 GMT

F# events are popping up all over the place and so I’ve included a separate section for them today. As far as posts go I’ve stumbled across immutable queue and range libraries, a post on the underlying implementation of discriminated unions, using the reactive framework and finally, a Microsoft research project: F7 Refinement Types.

-- Events --

Talbott Crowell is Presenting at the New England Visual Basic Professionals, November 5th

Introducing F# at 6:15pm

I am Presenting at Fairfield / Westchester Code Camp 2009 on November 7th

Why F# at 11:15am in Track 2
F# for Testing and Analysis at 2:40pm in Track 4

NashDotNet - F# Firestarter in Franklin, TN on November 14th

Come with an open mind and a laptop. Be prepared to learn, share, and chat. No prior knowledge or experience with F# is expected.

-- Posts --

Julien’s An Immutable Range Library in F#

An immutable range library in F# where a range is only defined by a minimum and a maximum value (hence, there is no step).

and Julien’s An immutable Queue Library in F#

An immutable queue library in F#. The queue is divided into two lists : one for dequeueing, and one for enqueueing. All operations are based on the List module.

I hope that Julien considers contributing these gems to the F# Power Pack.

F7: Refinement Types for F#

F7 is an enhanced type checker for the F# programming language. F7 supports static checking of properties expressed with refinement types. Our motivation is to check various security properties of F# implementation code by typing.

I took a peek at the included samples and found myself quite lost. It would be great if a walkthrough on how to use F7 were to pop up.

Using F# Discriminated Unions in C# (VS2010 Beta 2)

While updating my VsVim editor extensions for Beta2 [1] I got hit by a change in the way F# exposed discriminated unions in metadata.

A quick romp through how discriminated unions work under the hood and how you use them from C#.

IObservable/IObserver – Using the Reactive Framework with F#

One of the nice new features in .NET 4.0 beta 2 is the IObservable<T>/IObserver<T> support from the Reactive Framework (“Rx Framework” or sometimes “LinqToEvents”). It is a really powerful way to use reactive programming in .NET and especially in F# developed by Erik Meijer and his team.

F# Discoveries This Week 10/04/2009

RickM — Mon, 05 Oct 2009 01:57:00 GMT

I’m back from my three week vacation and am just about buried in fascinating functional programming links. I’ve managed to get through most of them and have selected the best of these for this very special welcome back edition of Discoveries This Week.

CUFP (Commercial Users of Functional Programming) 2009 Videos

“Functional languages have been under academic development for over 25 years, and remain fertile ground for programming language research. Recently, however, developers in industrial, governmental, and open-source projects have begun to use functional programming successfully in practical applications. In these settings, functional programming has often provided dramatic leverage, including whole new ways of thinking about the original problem.”

M<’a> Lib (F# and C# LINQ) Monads Library

“Unified collection of Monads (M, unit, *) implemented in the Microsoft F# Language.”

Implemented so far: Identity, Maybe, State and List with many more to come. The project lead is actively looking for help.

Flying Frog’s F# vs OCaml: Image Processing

“Fortunately, this inefficiency can be overcome by using Just-In-Time (JIT) compilation instead of static compilation and partially specializing polymorphism away before JIT compilation. This is the intended design for polymorphism in HLVM and the inspiration was drawn from Microsoft's excellent implementation of the CLR.

Consequently, the equivalent F# program is 100× faster than the OCaml.”

This JIT optimization speed enhancement is astounding by any measure.

HPC Development Using F#

“This white paper introduces the F# programming language in the context of technical computing, and demonstrates how F# can be used for both shared-memory parallel programming using the Task Parallel Library, and distributed parallel programming using a Windows HPC Server 2008-based cluster and the Message Passing Interface (MPI).”

Matthew Podwysocki’s Generically Constraining F# Pars One, Two and Three

“Generic constraints inside .NET has always been a fun enterprise, especially given how C# handles them There has been some discussion on Jon Skeet’s blog about the fact that C# does not allow for generic constraints referring to a number of types. […] However, as Jon correctly points out, this is indeed supported by the CLR directly. In fact, with our knowledge of F# constraints, we can write this exact function in F# without any such issue.”

Discoveries This Week 04/03/2009

RickM — Sun, 05 Apr 2009 01:42:00 GMT

With the start of our F# User’s Group this next Monday and New England Code Camp 11 last weekend, things have been extremely busy this past week. Meanwhile, the F# sociocosm is growing at a rapid pace. This week we have a talk by Don Syme, a look at F# quotations, and finally, some discussion on Seq.unfold.

Chris Bowen’s Post, Announcing F# User Group in Cambridge - April 6

A shameless plug here for our new user group. A big thanks to Chris for helping us find the resources we needed to start out. Without him this might never have come together.

Don Syme’s Talk, F# and functional programming in .NET

As Don Syme is the father of F#, when he speaks the community listens. In this talk Don focuses on the pleasure and speed inherent in using FP and F#. He does this by describing the functional methodology and constructs which provide a simpler and more elegant model for building programs.

Alex P’s Post, F# quotations at their simplest

A simple example on the surface for sure. However, if you haven’t seen the power of F#’s language oriented programming features this is sure to be of interest.

For a deeper look at the power of quotations check out Tomáš Petříček’s F# quotations visualizer. If his past projects are any indication Tom’s upcoming book is a must have for any F# enthusiast. I preordered a copy just today.

Martin Peck’s Post, Solving Problems in C# and F# - Part 2
(and update)

One of the most fantastic things F# has to offer is the rich functional programming heritage of sequence operations. To demonstrate how elegant they can make your code, I would like to offer the following alternative F# solution:

let fibs = 
  Seq.unfold (fun (a, b) -> Some( a, (b, a+b) )) (0I, 1I)

Seq.find (fun n -> n >= 10I ** 999I ) fibs

I’m going to take this opportunity to point out the obvious: we have here two lines of F# which does almost exactly the same thing as thirty six of C#. Now that’s what I call power and elegance. The unfold function pretty much does exactly what yield was doing before, but implicitly in terms of the unfold function. The idea of unfold can be confounding at first and so here is a breakdown of how it works:

let fibs =
  Seq.unfold 
    (fun (a, b) -> //generator function, 
                   //(a, b) is the previous state
      Some //Option monad, needed for unfold
        (a, (b, a + b))) //returned tuple: (value, state)
                         //or (first, (second, third))
      (0I, 1I) //Initial function state (first, second)

Note that in this version the state of the next two values in the sequence are always pre-calculated. However, it is easy to avoid this if you instead consider the state in terms of the previous two values:

let fibs = 
  Seq.unfold (fun (l, l2) -> 
    let n = l + l2 in Some( n, ( n, l ) ))
    (0I, 1I) //(previous, second previous)

If you want to learn more about unfold I recommend checking out:

Dustin Campell’s Post, Apples and Oranges

This is the best description of how unfold works I’ve seen to date.

Let’s Wax Functional 03/06/2009

RickM — Sat, 07 Mar 2009 23:09:00 GMT

This week we have MapReduce, WebTools and yet another F# to C# language comparison. I spent yesterday at a seminar led by Michael de la Maza. He, Talbot Crowell and I will soon be starting a F# user’s group in Boston, Massachusetts. I’m interested in any comments you might have. Please feel free to send me an email if you would like to discuss speaking at it or content you would like to see covered.

Blog - Matthew Podwysocki’s Exploring MapReduce with F#

Google’s MapReduce software framework has revolutionized the way software engineers think about processing large data sets. Since it’s introduction at least 15 variants have been developed. Thorough as always, Matthew explores what MapReduce is, how it relates to functional programming and, finally, shows his own light-weight MapReduce implementation.

Software – Thomas Petricek’s FSharp.WebTools

The F# Web Tools augment the F# distribution with tools to author homogeneous client/server/database web applications in one type-checked project.

It does this by generating Javascript from F#. The big advantage here is that you can effectively have statically checked Javascript and so avoid a whole class of bugs that come along with dynamically typed programming. While many are excited about this prospect, at least one person seems to have had trouble getting it to work. Currently, only the source tree is available and it must be manually compiled. I know I’m not the only one hoping for a tested release in the near future.

Blog – Martin Peck’s Solving Problems in C# and F# – Part 1

In this post Martin compares solutions to Project Euler problems 10 and 12 in both C# and F#. In competition with his friend Giles Knap, he wrote his answers in C# while Giles wrote in F#. Afterward, each set of answers is discussed independently. He concludes that the languages were equally readable but the F# implementations were slower.

I wish Giles had written a rebuttal post as Martin seems to be a die hard C# fan. I don’t agree that they were equally readable. The F# problems lacked much of the syntactic cruft and whitespace found in the C# examples.

Also, as single core results are fast becoming meaningless, it would be very if they would agree to use asynchronous workflows in F# and compare that with the .NET Parallel Extensions in C#. By constraining the answers to be single thread only, it seems like they avoided much of F#’s inherent benefit in multicore processing.

I also can’t help wondering how each of their prime generating examples would compare with the memoizing example I mentioned two weeks ago. I’d be shocked to see a similar C# implementation in anywhere near as little space.

Let’s Wax Functional 02/27/2009

RickM — Fri, 27 Feb 2009 21:22:24 GMT

This week I have a very diverse set of topics: First, using the functional programming concept of folds in C# to reimplement much of LINQ. Then a bit of reflection on F# Grammar Parsers. Finally, some community discussion on real world F# applications.

Blog – Matthew Podwysocki’s Functional C#, Fun With Folds

In this post Matthew reimplements much of LINQ using folds over IEnumerable. This post is a great opportunity for those who are living in the C# world to see how some of the constructs in the functional programming world work. I particularly like how Matt went the extra mile and included Pex tests for his examples. It gives extra clarity to his already well defined extension methods.

Software – FParsec, A Parser Combinator Library for F#

The basic idea behind a Parser Combinator is that you use it to build a parser with a large vocabulary out of a set of single vocabulary sub parsers. The claim is that, while this technique may not result in code that is as easy to read as something along the lines of fsyacc, it supports grammars which are much more complex while simultaneously allowing for an ultimately more extensible implementation.

I personally have not yet spent much time with either fsyacc or FParsec, but it’s interesting to contrast their different bottom up and top down approaches. Fsyacc seems ideal for parsing simple grammars such as SQL. The resulting code is very to understand and looks as though it would be similarly fast to write. However, if you wanted to implement something along the lines of regular expressions, FParsec seems a much better choice due to it’s direct support of infinite look-ahead.

Stack Overflow – What areas of code are you using F# for?

A quick survey of Stack-Overflowers shows some uses cases for F# beyond DSL and Concurrency. My personal favorites are statistical calculations and visualizations as they can be a nightmare to deal with in C#. Also, as Talbott Crowell awed many with at the recent MSDN Boston conference, F# can be leveraged to easily make some amazing time-sensitive visualizations.

I was also surprised that more people weren’t using F# for testing or scripting as they are also both very good use cases.

A Note From Rick

I apologize for so frequently changing the name of my weekly roundup post. Over the last few months it’s moved more and more in the direction of FP in .NET and so I felt “Discoveries this Week” was no longer appropriate. Last week I decided to change the name but, after some reflection, it seems my choice was much too wordy. I think I’ve finally found a name that fits.

Functional Discoveries in the Microsoft Sociocosm 02/20/2009

RickM — Fri, 20 Feb 2009 17:41:00 GMT

This week we have practical examples of Lazy Evaluation with Memoization, an interview with Don Syme and a discussion on the Visitor Pattern’s place in F#. Also, any comments on the new title for my weekly posting would be appreciated.

Forum – Memoization and Lazy Evaluation in F# on HubFS

In this thread brianmcm (Brian McNamara) and divisortheory (???) explore using memorization and LazyLists to optimize a Trial Division driven prime generator. It’s interesting to look at how their prime generator evolved over time as they incorporated these ideas and optimized.

Article – Kathryn Edwards interviews Don Syme on F# Development

In this technically light but still extremely interesting interview, Kathryn mainly directs the conversation in the direction of the development and adoption of the F# programming language. The most interesting thing I gleaned from the interview?

One of the key designers of Haskell, Simon Peyton-Jones, is just down the corridor from me at Microsoft Research Cambridge and has been a great help with F#.

Perhaps my F#/Haskell genealogy graph needs an additional arrow.

Blog – Stephen Easey’s (?) Visitor Patten in C# and F#

In this post Stephen explores the Visitor Patten in both C# and F#. I always love to see examples of how much more beautiful and concise F# is than C#. The 218 line C# implementation shown beside the same implementation in 64 lines of F# makes for a great comparison in this regard.

I agree with Stephen’s conclusion in that, given the purpose of the visitor pattern is to separate algorithm from object via a double dispatch layer, in many situations the visitor pattern is unnecessary in F# because of its advanced pattern matching capabilities.

However, I feel that he may not have considered the perspective of an API provider. In this context, it may be desirable for the consumer of an API to be able to extend the dispatch process to handle new cases. The issue with a single monolithic matching function is that all of the logic is contained within that single function and so the system is no longer nearly as open to extension. This violation of the Open Closed Principle (which applies to building APIs in any type of language) will make for difficult to reuse software.

Perhaps a F# pattern matching equivalent could be made with lambda functions for each branch. Lambdas could be curried into the matching function and so each branch could potentially be replaced with new logic by the consumer. However, this is feels to me like reimplementing OO with FP constructs.

Discoveries This Week 01/23/2009

RickM — Fri, 23 Jan 2009 18:17:00 GMT

Another very exciting week. I’ve barely had time to catch my breath.

Meanwhile I’ve decided to take my weekly roundup post consistently in the direction of functional programming in the Microsoft universe for the foreseeable future. This will be with a heavy slant towards software engineering and, of course, F#.

Post: Ted Neward’s Building WCF Services with F# Part 1

It’s always interesting to see F# applied to existing Microsoft .NET infrastructure. In this case I was particularly impressed with how well the ideologies of the two technologies fit together.

However, the most important thing about Ted’s post is that it notes a bug in WCF that could cause quite a bit of headache if it caught you unaware. When using a F# declared interface, if no name is explicitly specified for a function parameter, WCF will throw an ArgumentNullException.

This will be manifest in the following situations:

When svcutil.exe is run on the assembly.
When you attempt to construct a ServiceHost with the interface.

The issue stems from that fact that traditional .NET languages cannot have nameless parameters. Thanks for figuring out this problem for us Ted.

Code: Ray Vernagus’s WCF F# Examples

As he posted in response to Ted’s above, Ray has been working towards getting his MCTS 70-503 certification and has decided to do all of his examples in F#. Making this kind of information available is a fantastic contribution to the F# community. I hope that in the future ray will both write more in more depth about his experiences and continue to provide samples.

Code: Nada Amin’s Probabilistic Modeling in Three Languages

In Chapter 9 of Expert F# the idea of using a Monad to represent a probability distribution is presented with code examples. Nada has rewritten this example in both Haskell and Scala. While they may not all be optimal implementations for each language, this provides an interesting opportunity to compare each language syntactically. I’m somewhat tempted to submit a Clojure implementation to round it off.

Code: Microsoft’s Official F# Samples Version 0.1

Yesterday, at the Boston MSDN Conference, Talbott Crowell showed off some really amazing examples from this package. This is a must have for any potential F# developer as the samples not only show how off the features of the API, they also demonstrate proper coding practices.

Software: Ora (Visual Studio Add-in)

Ora is a add-in which provides a simple yet dynamic overview of the file you are currently editing in Visual Studio. Although I haven’t had a chance to test it in F# as of yet, Ora is my new favorite tool for every-day use in Visual Studio.

I no longer scroll up and down the code or try to sort through Visual Studio’s terrible method dropdown. Instead, I have access to a custom visualization of the class I am working on all of the time. The best part is that it fits perfectly over my properties window which I rarely use and have always considered to be a waste of space.

Discoveries This Week 01/16/2009

RickM — Fri, 16 Jan 2009 16:17:00 GMT

This week’s theme is functional programming. Included are discussions on Software Transactional Memory, Functional Architecture and the impact of the CLR on functional Programming in .NET.

Blog: Brandon Werner’s Software Transactional Memory: Debunked!

In starting with a title that is decidedly sensationalistic, Brandon effectively trashes STM over its expensive overhead based on a paper published by ACM. His position, and that of the researchers, is that most programmers see assignment as inexpensive and so would not understand that they need to optimize for atomic transactions when using STM.

Brian Hurt responded at length in his blog post The Problem with STM: your languages still suck. Brian’s view is that the fundamental issue here is that most programming languages encourage heavy use of mutable variables and so many expensive assignments and reads are happening when STM is used. If instead one is using a functional programming language which discourages variable mutations, the high cost of STM is much less of an issue. Brian then further flushes out his ideas in a follow up blog in which he responds to responses to his first.

While I don’t agree that ACM’s analysis “puts a deep nail in the coffin of STM”, I also don’t think it’s reasonable to expect most programmers will be jumping on the functional programming bandwagon in the near future. The main issue is that it’s just too different from what they are used to.

For now FP will remain the domain of the motivated and pragmatic programmer. It will be necessary to slowly ease the majority into this new, different world via things like functional C# extensions. I do think that some kind of STM with training wheels for mainstream programmers would be a good way to promote this over the long term. However, it would be extremely important that the inherent overhead is explicitly stated.

Finally, I wanted to note that Sasha Dadiomov of the Microsoft STM team has an interesting piece on the difficulties involved in debugging STM. It’s an informative glimpse of how Microsoft’s implementation of STM is shaping up.

Blog: Chris Smith’s Speech Recognition is gun [sic] and easy!

It’s possible he meant fun and easy but I can’t be sure.

A quick but fun piece on leveraging System.Speech.Dll inside of F#. The result is a 10 line program that takes your speech as input and prints it to the console. Very simple yet quite cool.

Blog: Matthew Podwysocki’s How would the CLR Be Different?

In this post Matthew discusses how the CLR might be better implemented to serve the needs of functional programming languages. I especially like the idea of including some new functionality for type manipulation and construction.

However, I would like to see specific examples of exactly what Matthew would like changed under the hood. He mentions a lot of general goals with reasoning to back them up but not how they might be implemented. I also feel that it would be inappropriate to implement some of these ideas at the CLR level instead of the language or API level.

For example, non-null references. I’m all for Spec# style pre and post conditions but why is it necessary that this be implemented at the CLR level? This belongs in the language instead. Also, the issue with immutability in .NET mostly has to do with Microsoft’s .NET API design. The stack based nature of IL is completely compatible with the idea.

The CLR should be designed with the most general case in mind and not with the slant towards any particular language. If the CLR is to be viable long term, flexibility must be emphasized over specific optimizations.

Paper: Sebastiaan Visser’s Building a Wiki in Haskell

A study on implementing a Wiki in Haskell which is a purely functional programming language. This paper is a must read for both those interested in functional project architecture and those who question the viability of using FP for large applications. The complete source of the project is available for your viewing pleasure.

Discoveries This Week 01/09/2008

RickM — Fri, 09 Jan 2009 16:37:00 GMT

It’s been a very exciting week. I actually had more things to post than time would allow me to write about. I’ll have to save them for next time. Blog: Daniel Spiewak’s What is Hindley-Milner? (and why is it cool?) Hindley-Milner is the algorithm all...(read more)