Lightweight Languages 2003

The Lightweight Languages 2003 conference happened on Saturday. Here's my take, presented in chronological order. Skip to the parts on bluespec and Father Time for the interesting parts.

• The ACME talk, about a "lightweight testing framework for distributed systems", was pretty vacuous. The net takeaway for me was "we like jabber". I've written a lightweight language for controlling distributed systems, and there are some interesting problems in that space (I didn't solve any of them, but I had hoped they might). However, no interesting problems were even mentioned during this talk.

  The best part of this talk were the questions fired at the presenter from the PLT Scheme group (sic 'em Shriram!). The questions were merely a thinly disguised version of "our scheme is better than your testing framework", but they managed to raise the level of discourse, despite that. Besides which, I'm now curious to find out what Mattias meant when he talked about the "shape" of a computation.

• The WASH/CGI talk was mildly interesting. I had previously looked at CGI programming libraries for haskell but had been turned off by the coupling of CGI handling with HTML generation. In my mind, these are distinctly different operations. WASH/CGI at least has the advantage that it's based on four different sublanguages (of which CGI handling and HTML generation are but two), so you can ignore the HTML part if you like. Or at least I think you can (depends on whether they actually implemented it "the right way" or not).

  On the other hand, the presenter for the WASH/CGI talk seemed to think that having your language statically guarantee that you generate valid XHTML was a useful thing -- indeed a driving motivation. To me, that's almost irrelevant, since it's easily verified, and any error would presumably be caused by a simple, localized bug in the program. What's much more interesting to me is language support for writing web applications and dealing with the statelessness of HTTP.

  WASH/CGI has some support for dealing with statelessness, but as was pointed out by Shriram after the talk, it forces you to write your entire program in continuation-passing-style. The PLT Scheme webserver, on the other hand, is based on transparent continuations. This allows you to write programs in the usual stateful manner, instead of transforming the whole thing to CPS.

  I'd be interested to see a discussion (or paper) on whether transparent continuations can fit into Haskell's mindset of side-effect-free evaluation.

• The "lisp on lego mindstorms" talk was amusing and entertaining, but not really interesting to me personally.

• The Bluespec talk was very interesting to me, in a philosphical way. They've created a language that has two distinct phases: at compile-time you have very sophisticated concepts like higher-order functions and numeric types, while at run-time you have state-machines that use rule rewriting to control their execution. I'm personally very interested in meta-description of programs, and so I found the distinction between static elaboration and dynamic execution interesting in an abstract way. For example, I'd like to be able to write underspecified programs. That kind of thing requires making a distinction between the static specification and the runtime operation. Unfortunately, while the approach is abstractly similar, none of the details seem directly applicable to my own interests.

• The talk on the implementation of Lua was probably the most apropos for the conference, since it discussed the efficient implementation of a data structure that is both a list and a hashtable, as well as the pros and cons of stack versus register machines. It was pleasant and mindless in the same way as reading a favorite book for the tenth time.

• The talk on embedding Lua in O'Caml was mildly interesting, mostly as a demonstration of how to use a domain-specific-language for describing (and then auto-generating) the necessary glue code to bridge two languages. Since O'Caml has good support for DSL's, the result is quite concise and maintainable.

• My favorite talk, by far, was the talk on "functional reactive programming". This is exactly what I was talking about when I wrote the Dataflow Languages post. I'm going to write another post to elaborate on just this one talk, so I won't go into it too much here. I'll just mention that I talked with Shriram just before that talk, and I pointed out that once you have dataflow, you very quickly want transactions. He agreed and responded that they currently have a PhD student working on exactly that problem. I was so excited during this conversation that I was literally jumping up and down. He seemed to take this in stride.

• The boundaries talk was too long. One could say it needed a more clearly defined end boundary. By his own admission, Dan only finished writing the talk twenty minutes before giving it, and it showed. If he wanted to talk off-the-cuff, he should have talked about Parrott instead.

After LL1, I remember thinking "I should check out Scheme". After LL2, I remember thinking "I should really check out Scheme some more". And after LL3, I find myself thinking "Those PLT Scheme folks are doing some of the best programming language research around". They recognize what it takes for a language to actually be useful, and they're putting in the work it takes to get there. For example, they're playing around with type systems, but only because they're useful. This is contrast to most other language researchers who seem to think that their job is not so much language design as computability proofs.

I also met Jay McCarthy, and Ben, both of whom I had met in blogspace but never seen before. Ben left a dodecahedron in my car. Jay has posted his own notes on the conference.