Notes from the MacQueenFest

I had the excellent opportunity to attend the MacQueenFest a couple of weekends ago in honor of David MacQueen. The venue provided interesting insight into what the alumni of the ML community was up to these days. Many of the slides are now up on the website. The talks were scheduled roughly chronologically based on Dave's contributions. Most were looking forward as much as they were considering the historical significance of the contributions.

First up were Jean-Jacques Lévy and John Reppy on concurrency related topics, principally from the MacQueen-Kahn networks. There was an interesting mix of theoretical and practical here. The second talk focused on Reppy et al's recent work on Manticore. It was a refreshing summary of why Standard ML is an excellent basis for building the next generation of highly scalable, concurrent languages for utilizing future processors with 40+ cores. Though the claim was that Intel would have already made 16- or 32- core commonplace by now and made it readily available as dual- or quad-core machines, we are still definitely heading in the trajectory of considerably more cores than conventional languages can fully utilize. The Manticore project already has benchmarks for 48-core performance (an Opteron) and a good helping of both implicitly- and explicitly-threaded constructs to maximize parallelism. The design emphasized determinism, but one sticking point is parallel cases. In contrast with Haskell, Manticore is strict in evaluation order. For parallelism, the claim is that this is important because lazy evaluation requires the introduction of a lot of thunks which in turn require good parallel garbage collection. Manticore utilizes a concurrent garbage collector based on Doligez-Leroy-Gonthier's design. Looking forward, the goal is to address the limitation of Amdahl's law by maximizing the benefit of speculative execution and to re-introduction shared state in a more sensible way (with union-find being an example of why shared state remains useful). The counter-argument raised by the audience is that, in principle, there is no reason why algorithms which benefit performance-wise from shared state would be all that important in a many-core world. Thus is the world of programming language design.

More on the talks to follow...