I've been in Utrecht all week. As per usual I've spent most my time talking about Haskell and plotting world domination with friends and colleagues.
Andres Löh invited Don Stewart and me to give guest talks on the last day of the Utrecht summer school on applied functional programming. The idea was to give the summer school participants some perspective from people who make a living working with Haskell. Don talked about how Galois have been using Haskell for the last 10 years; what features, tools and techniques they have found to be important. I gave a semi-technical talk entitled "Monoids monoids everywhere!" about functional design patterns. The point was that identifying, capturing and abstracting over patterns is useful in real programs. I used monoids as the running example partly because they're nice and simple but also because it's somewhat surprising how far you can go with such a simple concept.
Several people have asked for the slides from the talk and I've promised to post them soon. In the live talk I drew some diagrams on the whiteboard and I'd like to add the diagrams to the slides so that the slides will make some sense on their own.
Over the weekend we had a mini-hackathon. Ian caught the ferry over and Johan Tibell flew in to join us. Johan and Don worked on optimising the Data.Map implementation. I spent much of my time reviewing Cabal patches. In particular I spent quite a while reviewing a big pile of patches from Thomas Tuegel which implement the new "cabal test" feature that he's been working for his GSoC project. He'll be presenting it at the Haskell Implementors' Workshop next month.
The latter half of the week Don, Andres and I have been at IFL. There's been lots of interesting talks on a fairly wide range of FP topics. There's been plenty of talks on parallelism and concurrency. I've been slightly surprised by the number of talks on low-level, hardware and embedded topics.
Don and I had several interesting chats with Kevin Hammond and his colleagues from the University of St Andrews about their continuing work on parallel and distributed Haskell. I think I've finally sorted out the confusion in my mind about the relationship between "GpH", "GdH", "GUM" and "Eden". For reference:
- GpH (Glasgow parallel Haskell): A language specification; this is ordinary Haskell plus the 'par' and 'pseq' primitives. GHC is an implementation of GpH for shared memory systems.
- GUM: an implementation of GpH for distributed memory systems. That is, you can write ordinary parallel Haskell programs using 'par', 'pseq' and strategies and then run it on a cluster.
- GdH (Glasgow distributed Haskell): A language plus an implementation; roughly speaking it takes parallel + concurrent Haskell (ie par, pseq, forkIO) and adds extra support for things like explicit placing of threads on nodes and node-private resources. Like the distributed implementation of GpH, it uses a global graph.
- Eden: another language plus implementation. It is like parallel Haskell but with an explicit notion of processes. Processes send values to each other but they do not share any global graph.
Oh and I finally gave in and signed Well-Typed up to twitter.