GHC is still busy as ever. The GHC 7.0 branch has come and gone, and now that the branch has been closed we have finally made the long-planned switch from darcs to git. Meanwhile, we are busily working towards the 7.2 branch, and hope to make the 7.2.1 release in June. Some of the forthcoming highlights are:
GHC's intermediate language (which we call "Core") is a simple,
explicitly-typed lambda in the style of System F. Core is far,
far simpler than Haskell (CoreExpr has only eight data
constructors), so GHC can type-check Core very fast and reliably.
In theory, such a typecheck is redundant (since the original
Haskell program was typechecked), but in practice, typechecking
Core is a very powerful internal consistency check on GHC itself:
many compiler bugs generate type-incorrect Core. This consistency
check is run by -dcore-lint.
With the advent of GADTs and type families, the type system of the
Core had to grow a little. For a few
years we have been using an extension of System F, called System
FC, as described in our 2007 paper [http://research.microsoft.com/~simonpj/papers/ext-f/ FC](http://research.microsoft.com/~simonpj/papers/ext-f/ FC). However, the way that System FC
was actually implemented in GHC's Core language was a bit unsatisfactory
so, with help from Brent Yorgey, Simon PJ is busy re-engineering it.
In particular, FC has coercion terms, and these will now
be represented by their own data type Coercion, rather than being
squeezed into Type. Moreover, these coercion terms can get big,
so there's a new "coercion optimiser" to replace big coercions by
equivalent smaller ones. All this is described in our new paper NewFC.
These changes will (finally) complete the type-family story by
making so-called "equality superclasses" work for the first time in GHC 7.2.
Edward Yang has spearheaded a flurry of work on the new
code generation backend (-fuse-new-codegen, the rewrite of
the part of GHC that turns STG syntax into C--). Hoopl is now
fully part of GHC [http://research.microsoft.com/~simonpj/papers/c--/ Hoopl](http://research.microsoft.com/~simonpj/papers/c--/ Hoopl), and the new path uses it extensively; we’ve
ironed out most of the bugs in the backend; and now we’re
working on new optimization passes and fixing inefficiencies to
get the generated code as good (or better) than the old code
generator. We’re still not at the point where the new code
generator will generate better code, but we’re pretty close!
Simon Marlow Has been busy implementing and benchmarking a new garbage collector. GHC's current garbage collector is of the parallel "stop-the-world" variety, where to collect the heap all cores stop running the program and collect the heap in parallel. The new collector is a "local heap" collector, in which each core has a private heap that can be collected independently of the other cores, meanwhile there is a shared global heap that is collected (much less frequently) by the usual parallel stop-the-world algorithm. We have a paper describing the new design which has been accepted at ISMM'11 (and will be online shortly). The results are mixed; while on average performance improves with the new collector for parallel programs, the improvements are not dramatic (at least up to 24 cores). The new collector is significantly more complex than GHC's current collector. Hence we do not plan to merge it into the mainline yet, but will maintain it on a git branch for the time being, while we continue to experiment with and tune it. Some improvements from the branch that were independent of the new GC algorithm have already been merged into the mainline, so 7.2.1 will see some small improvements in GC performance and stats reporting.
We are fortunate to have a growing team of people willing to roll up their
sleeves and help us with GHC. Amongst those who have been active recently are:
Mark Lentczner and Dan Knapp have been working on cross-compilation support
Continued work on the new I/O manager by Johan Tibell.
Various improvements and build fixes for OS X, from PHO, Greg Wright, Thorkil Naur and William Knop
Solaris fixes from Karel Gardas and Christian Maeder
Gentoo fixes (for SE Linux and x86 FreeBSD support) from Sergei Trofimovich
Other FreeBSD fixes from Marco Silva
Linux PowerPC fixes from Erik de Castro Lopo
Objective C support has been added by Austin Seipp
Documentation updates from Orphi
Various improvements from Michal Terepeta
General tidyups from Matthias Kilian
Primop improvements from Daniel Peebles
Some GHCi improvements from Vivian McPhail and Boris Lykah
More GHCi debugger fixes from Pepe Iborra
LLVM development continues with David Terei
Many people have given git help to those of us new to git
At GHC HQ we are having way too much fun; if you wait for us to
do something you have to wait a long time. So don't wait; join in!
GHC continues to act as an incubator for interesting new language developments.
Here's a selection that we know about.
Jeff Epstein, in collaboration with Andrew Black, has implemented a library that brings Erlang's programming model to Haskell programmers. In particular, you can write a Haskell program that runs on a cluster of machines that do not share memory. It is all based on a modest but powerful language extension that makes it possible for a programmer to work with "static" functions; that is, ones consisting of pure code with no free variables. The paper that describes all this is called "Haskell for the cloud" [http://research.microsoft.com/~simonpj/papers/parallel/ Cloud](http://research.microsoft.com/~simonpj/papers/parallel/ Cloud).
David Terei at Stanford is busy implementing Safe Haskell, a flag for GHC that will guarantee that your program has certain properties such as referential transparency and constructor access control, while still having the same semantics as it normally would. The flag basically allows you to trust the types of your program, giving you if you will a more 'pure' version of Haskell where 'unsafePerformIO' is outlawed, abstract data types are actually abstract and safety is provided by the compiler not the user. This is being done as part of a larger project by the Stanford Secure Computing Systems group involving the use of dynamic information flow based security in Haskell to build a secure web framework that allows the inclusion of third party untrusted code.
Microsoft Research is funding a 2-year project to develop the real-world use of parallel Haskell. The project is now underway with four industrial partners:
Dragonfly (New Zealand)
IIJ Innovation Institute Inc. (Japan)
Los Alamos National Laboratory (USA)
Willow Garage Inc. (USA)
with consulting and engineering support from Well-Typed. Each organisation is working on its own particular project making use of parallel Haskell. The overall goal is to demonstrate successful serious use of parallel Haskell, and along the way to apply engineering effort to any problems with the tools that the organisations might run into.