Another day, another parenthetical note. It's probably worth repeating that these are just personal impressions, take them with a salt lick.

François-René Rideau spoke about XCVB, a packaging system for Common Lisp. Slides here. From what I gather, XCVB tries to make separate compilation of Lisp libraries more robust via mechanisms that isolate compile-time side-effects.

More interesting was where he headed at the end of his talk, and expanded on in a lightning talk: that the things that we do are intertwined with the stories we tell others and ourselves. The bad stories are about things. The better stories are about people making things.

Next up was a presentation by Gary King from Franz Inc., about AllegroGraph, a massive RDF triple-store capable of storing and searching billions and billions of triples. Specifically, as far as I could tell, it was about adding temporal and geospatial capabilities to queries -- so you could ask "Of the people that Bob called last week, who has a friend within 5 miles of the Boston area?"

It was quite impressive, but it makes me queasy too. Who has billions and billions of facts and needs to query them? Well, the CIA, the NSA, and similar organizations. Others too of course, epidemiologists for example, but that doesn't ease the quease.

Next up, something totally different. John Hastings lives in Nebraska and has a problem with grasshoppers -- they tend to eat up all of the grass that cattle graze on. Ranchers out there would douse their land with chemicals at any word of a grasshopper outbreak. But that's not good for the land, and it's also expensive. So he wrote an expert system to help ranchers say what the conditions are where they live, in Lisp, and help them decide what to do. The program gets deployed into peoples' web browsers via one of the Lisp-on-the-JVM projects. Voilà fewer chemicals!

Next, a talk by an engineer at Cadence Design Systems, on how they use Lisp to lay out certain kinds of electronics called "systems-in-a-package", such as the circuit boards and the amplifiers and conditioners and such. His point appeared to be that giving the user a way to extend and specialize certain designs via generic functions lets them deliver applications without source, but still allow some extensibility. I didn't care for the "freedom subtracted" aspect, but seeing more about chip design processes was interesting.

Jorge Vallejos from the Vrije Universiteit in Brussels took the floor next. His talk was on distributed computing within the Actors paradigm, whereby objects on different machines can reference and send messages to each other. The interesting part was how he used actors as containers for unadorned objects, and used generic functions to "invoke" remote objects. The meta-object protocol allowed him to extend base Lisp to have remote asynchronous procedure calls, while keeping a natural Lisp feel. It was fine, but something about RPC as a distributed programming metaphor doesn't sit right with me. I probably missed something.

Didier Verna followed, with a delightful talk comparing the speed of Common Lisp and C++. He works at a lab in France that does lots of numerical processing on images, and is the only Lisper in a roomful of C++ wizards. The funny thing is that he says he doesn't care about speed, because things are fast enough, but that he was tired of getting shit from his C++-loving coworkers, so he decided to do some measuring.

This guy is serious. This is his second paper in a projected series of 5 or so; his last installment showed that Lisp and C are comparable in speed. This talk compared instantiation time for C++ objects to instantiation of Lisp structures and CLOS objects, showing again that Lisp was comparable in speed with C++. Unfortunately the paper and slides don't appear to be online; I'll ask him about this.

Also, Verna gave a lightning talk in which he explained that Lisp is Jazz and Jazz is Lisp. When asked by the audience about other things, he explained that they were Jazz too. Also Lisp is Aikido, and buy his CD.

* * *

In a later post, I'll get to Sussman's talk on evolvability and robust design. It will take some thinking to summarize.