March 25th, 2009 (08:35 pm)

Sunday through today I was at the International Lisp Conference at MIT. It was the first academic conference I've been to. (I've been to IETF meetings, which have a strong academic feel, but are more oriented to getting work done.)

Sunday was tutorials. I went to one on CLOS and the MOP, and one on ContextL, both given by Pascal Costanza. The first was calibrated a little too low for a Lisp conference—Pascal said he usually gives it for Java programmers. In fact, it turned out that I already knew most of what he said, since I've read The Art of the Metaobject Protocol. The talk on ContextL (an extension to CLOS for context-oriented programming) was more interesting, but focused too much on explaining how ContextL is implemented with the MOP and not enough on why or how one would use COP. (COP is basically an extension of AOP, to be more dynamic. Since "not dangerous enough" was not one of the reasons I wasn't interested in AOP, I'm still not convinced that COP is a good idea.)

Monday the talks started. The morning talks weren't that interesting—the "software demos", in particular, were a bad idea. There was no software actually demoed; instead, we had reports from people who had used Lisp in their projects and attributed their success to Lisp. Well, yeah, we know Lisp is good; that's why we were there. Things picked up after lunch, with a talk by David Moon on the macro system in a language he's been working on—full-power macro systems are generally limited to homoiconic languages like Lisp, but he's developed one that works by (a) standardizing the AST and (b) letting particular identifiers, when parsed, take control of the parser. It's an idea I'll probably want to use sometime.

Other talks Monday afternoon included an interesting presentation on propagators, which are a dataflow-oriented approach to computation. The tricky part comes when data may flow into the same node from more than one direction: if the data don't agree, then backtracking may be needed.

The last session before dinner was a panel discussion on the future of Lisp—the theme of the conference (since Lisp turned 50 last year) was "the next 50 years". Everybody seemed to agree that, yes, if we want Lisp to thrive, we need to make it easier to find and use libraries, and we need to market Lisp better. There was disagreement on whether the Common Lisp standard had held back innovation. I think the best position I heard there was someone pointing out that, before the standard, half the community was complaining that the lack of a standard was holding back innovation (since people didn't want to spend too much effort building on an unstable foundation); this someone opined that the half of the community now complaining was the half that wasn't complaining before.

After dinner, we convened for a debate: Are Macros A Menace? Nothing new there; it basically rehashed the standard arguments—the pro-macro side saying they were so powerful they're incredibly useful, the anti-macro side saying they were so powerful they're incredibly dangerous. It was interesting, though, to hear the details from a collection of people who really knew the topic, and could tell you what Lisp dialects had what kinds of macros when, over the past 50 years.

Tuesday morning, more papers. The only two that really stick in my mind are one on reconciling CLOS generic functions with the actor model (I don't remember enough details to be useful, so I'll have to read the paper) and one on comparing the performance of object instantiation in CLOS versus C++. Interestingly, CLOS was generally faster, sometimes much faster, especially in deep inheritance heirarchies—since C++ runs one constructor at a time, instead of initializing the whole object in one function. After lunch there was a talk by Gerald Sussman (coauthor of SICP) on "Evolvability and Robust Design", making the point that strict design-first discipline just can't work, and the best thing today is (a) build your components to tolerate slop in each other and (b) make sure you can improve the system later.

Tuesday night was a banquet at the Hyatt Regency, in a 16th-floor room overlooking the Charles; that was nice. The entertainment wasn't something I can recommend, though: a guy and a robot arm (not a real robot, just a machine) playing chess and disputing the differences between humans and robots. No real insights that aren't in, say, Asimov, but it was funny at first. It dragged on much too long, though; it should be cut in half.

Wednesday had some interesting papers. First was one on an access control mechanism for CLOS—it was based on the idea of gates, as in Multics. A gate is basically a function call that gets run with different permissions than the caller (the most common example is a system call). The all-in-CLOS implementation isn't perfect (it's still possible to subvert it by starting up with a different implementation of CLOS), but it points the way to what could be done with support from the OS and/or hardware. Another was a study of evolving SAT solvers via genetic programming, which turned out to outperform the best known algorithms by a large margin. There was also a talk on Bootstrap, an after-school curriculum for middle-school students, using Scheme in ways that let them do interesting things (games, which can run on their laptop or on certain cellphones) and that leverage and reinforce the algebra they're learning in math class. (It's news to me that kids are taking algebra in middle school now; I didn't get it until 9th grade.) The interesting bit there, technically, was that they have the kids do all their work without mutable state; instead, an event handler gets passed a World object, and returns a new World object with different values. This will eventually allow for concurrency, for example, in ways that just wouldn't work if the program were messing around with global variables and such-like. (It's rather like monads, really.)

Some of the most interesting bits were lightning talks: 5-minute talks, that anybody could sign up to give, on whatever they wanted to talk about. (The 5-minute limit was strictly enforced; you then got 2 minutes to answer questions while the next speaker set up his laptop.) I gave one on Adder, a Lisp-on-Python I've been hacking on for about 3 months now. That was fun; I didn't get a whole lot of questions, but I did get people afterwards telling me it sounded cool. To make it stick in people's minds, I put out bowls of gummy worms at lunch, labeled "Gummy Adders" (that was cvirtue's idea).

I mentioned in the talk that, this weekend, I'd be releasing the code, under the GPL. So, of course, the first question someone asking why the GPL. I had expected this, and was ready with an answer: "I don't want to have that argument at this time.". See, there are lots of people who believe that a BSD-style license gives more freedom than the GPL's viral approach; I disagree—it's really a choice between the freedom of anarchy and the freedom of a bill of rights—but the one thing that everybody can agree on is that it leads to long and bitter arguments, which would not have been appropriate for a Lisp conference.

Oh, and I wound up playing a little Magic—I hadn't played in over 10 years, but Pascal Costanza had posted to the mailing list beforehand, asking if anybody wanted to play in gaps between talks. I played with him, and Alexey Radul (who gave the talk on propagators), and Mason Bliss (who turned out to know dsrtao). It was fun, even though I couldn't come close to winning—I was using hastily-assembled weenie decks, which require a lot of time to power up, and I was playing against fast-acting decks. (It seems that modern Magic includes many cards that let you get powered up faster.)

All in all, I'm glad I went. However, I'm also glad I didn't have to travel for it.