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.

Rick Minerich's Development Wonderland : functional, stm, haskell, F#, C#

Discoveries This Week 01/16/2009

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

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

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

Paper: Sebastiaan Visser’s Building a Wiki in Haskell