blog.well-typed.com

I’m talking about the Haskell Platform at the London Haskell Users Group this Thursday.

It is an extended version of the 10-minute talk Haskell: Batteries Included that Don Stewart and I presented at the recent Haskell Symposium.

• Slides from the talk

Abstract:

Some people pick a programming language because it has the best type system, the best facilities for abstraction or perhaps the fastest compiler. Most people however pick a whole programming platform that lets them solve their problem the quickest or best. A programming platform consists of a language, a compiler, and a set of standard libraries and tools. Other popular programming languages have a standard platform that puts together everything you need to get started.

This talk is about the Haskell Platform. We’ll cover what the Haskell Platform is and who it is for. We’ll also look at the technical infrastructure and the social aspects of how it will be managed.

Not all of the details are set in stone. We need to have a discussion within the Haskell community about how the platform will be managed and extended, especially since it needs buy-in from package maintainers. My hope is to use this talk to kick off that discussion.

Don and I are doing our quick talk about hackage and the Haskell platform tomorrow. Chris and Eelco from Tupil have been helping us prepare some cool visualisations of Hackage. This one shows each package as a circle with the size indicating the number of other packages that use it. So the base package is the biggest of course with 754 other packages that use it.

Here we have Neil and the Tupil guys brainstorming about the user interaction and visual design of the new hackage. The big idea is using search (i.e. hoogle) as the primary interface.

The new hackage server implementation is something that Lemmih (of HAppS fame) and myself have been working on in the last couple months. We’ll be demoing it in the talk tomorrow. I promise I’ll announce it properly some time soon.

ICFP is great fun as usual. There have been some good talks and there’s a packed schedule for the next few days. Of course the most important business takes place during the coffee breaks and in the pubs in the evenings.

One thing that feels pretty new and exciting this year is the number of Haskell hackers going professional and independent. Apart from Well-Typed of course there’s also the Tupil guys doing web development and Conal Elliott has himself up as a consultant doing functional graphics.

Thursday will be the Haskell Symposium. Don Stewart and I will be giving a short about the Haskell Platform. You can see the two page summary paper and I promise I’ll post the slides. I hope it will be videoed (guerrilla style so it will not just disappear into the black hole that is the ACM digital library).

Don and I will also be chairing the “Future of Haskell” discussion on Thursday afternoon. There are some interesting things to talk about, we’ll probably hear about progress on goals from last year, in particular SMP and Haskell-prime. Then we’ll open discussion to the floor to talk about key goals for next year. So I’m looking forward to that.

As I’m sure you remember, as part of the Haskell OpenSPARC project, Sun has donated a SPARC Enterprise T5120 Server to the Haskell.org community.

Björn took delivery of the server a month or so ago and now that the IT folk at Chalmers are back from holiday it’s installed in the server room. It’s just been given a public IP and I’ve been able to log in for the first time. We’ve now got to get software configured and get ghc working, so don’t ask for accounts just yet.

Björn took some photos as he was getting it set up:

So that’s what 32GB of memory looks like! Under that little heatsink is the T2 CPU with its 8 cores, each core multiplexing 8 threads.

It’s a 1U form factor so it uses lots of little fans which you can see at the left and clear plastic ducts to channel the airflow over the memory and the CPU heatsink. In the bottom right you can see the dual power supplies.

Remember, if you want to hack on this project for three months, the closing deadline for applications is Friday the 5th of September.

I should make it clear that although I am a consultant with Well-Typed and also the coordinator for the OpenSPARC project, the project is really nothing to do with Well-Typed. It’s a joint project between Sun Microsystems and the Haskell.org community. I’m wearing my community hat for this one.

I am very pleased to be mentoring Andrea Vezzosi (aka Saizan) on a Google Summer of Code project to develop a make-like dependency framework for use in Cabal. I’m really looking forward to working with Saizan on this. It should be a fun and useful project.

Congratulations to Saizan and good luck with the project!

The project itself is to start prototyping one of the big features we need for Cabal to become a really excellent build system. At the moment Cabal calls out to ghc --make to do the hard work of figuring out what needs to be rebuilt. This only works for .hs files of course while we need it to work for all preprocessors. More generally there are a lot of things that Cabal does that would benefit from being done in a dependency style — not just limited to running external programs that update files. In addition everyone has multi-core CPUs now and we’d like to do parallel builds.

The Real World Haskell book is now available for pre-order!

I’ve just ordered my copy from Amazon UK for £30.99 and it’s available from Amazon in the US for $49.99.

I’d like to be able to recommend a canonical “learning Haskell” bookshelf. The slot for an introductory book has been filled by the excellent Programming in Haskell (you can read my review). Judging by the material the Real World Haskell book aims to cover, it looks like it should be a pretty good complement, mostly picking up where Programming in Haskell leaves off and covering the language techniques and tools you need to get started writing serious programs.

We ended up with quite a big group of people interested in various aspects of Cabal, cabal-install and Hackage. So I ended up spending much more time talking than hacking. I’m sure that’s a good thing though. Hackathons should be about sharing ideas, brainstorming and experimenting.

I arrived at the hackathon with ideas about three main areas I wanted to get people to work on:

• a make-like dependency framework for the Cabal library
• a package dependency resolver for cabal-install
• cabal-install/hackage build reporting

In fact these are more or less exactly the topics for proposed Google Summer of Code projects, but there’s no harm in starting early and exploring possible solutions.

I expounded a bit on the dependency framework issue though we didn’t end up working on that in the end. It’s actually an interesting research problem. I’ll write about it another time.

Josef Svenningsson got interested in the cabal-install dependency resolver issue. He spent much of the hackathon prototyping a BDD-style approach. Hopefully Josef will post his current ideas to the cabal-devel mailing list in the next week or so.

Thomas Schilling (aka nominolo) worked on the last remaining feature we wanted to get into Cabal-1.4. When configuring a package want to be able to specify additional constraints on the versions of dependent packages. As a developer we might want this just to be able to test building a package against an old rather than the latest version of a dependency. The reason we really want it for Cabal-1.4 though is so that we can use it in cabal-install. In cabal-install we want to work out up front exactly how we will configure a whole set of packages. We need a way to get Cabal to configure a package exactly how we wanted it in our global plan, rather than making some local decision. Thomas got this finished and I’ll be integrating the patches some time soon.

Lennart Kolmodin (with some help from David Waern and myself) spent quite a while hacking on build reporting in cabal-install. The idea here is that we want to get cabal-install to report build success and failure back to the hackage server so we can discover what packages build in what environments. On the client side most of the work involves information plumbing — gathering information from various places within Cabal to include into a build report. We realised that most of the information for a build report is discovered once we’ve decided how we’re going to configure the package. So we spent most time hacking on some code I’d written previously for representing installation plans and extending it to collect information on the outcome of installation. We managed to get it integrated though it still needs more work because our new InstallPlan type has a much more demanding notion of validity than the abstraction it replaces, so the current dependency resolver needs to be updated to produce valid InstallPlans.

Hac4 is now over, everyone has arrived home safely and all the equipment has been returned. 27 people attended, though not everyone could come every day. 10 attendees travelled from several European countries and from the US. People hacked on lots of projects, including Yi, Cabal, ByteString, a new web application interface, QuickCheck, CGI, first-order logic reasoning, Allegro bindings, Haddock, the community server, HAppS-HSP, replacing libgmp in GHC, Squiggle, restricted monads, and more.

We also decided to set up a Haskell Hackathon Steering Committee which will help find hosts for future hackathons and aid the local organizers.

Thanks to sponsorship from Credit Suisse and Galois, we could provide food for everyone during the whole hackathon. This made it possible to keep the group together and keep hacking (some stayed well into the night). The Department of Computer Science and Engineering at Chalmers University of Technology and University of Gothenburg provided space and networking. 

A big thank you to everybody who made this happen by sponsoring, attending and helping out with the organization!

Pictures from the third and last day of Hac4:

Some pictures from the second day of Hac4: