OOPSLA Trip Report (October 21, 2005)

There was a surreal mix of cyberspace and reality at this conference. Most attendees had laptops with wireless, and the conference organizers hacked up some sort of free wireless access in the main conference areas. As usual, there were thumbtack-board areas where people posted stuff as the conference progressed, but cyberspace upped it one level. People were posting blog entries as the conference progressed, and I overhead several conversations that started, "I read what you posted on blog this morning, and I wanted to tell you that...." Science fiction is becoming reality.

The Dynamic Languages Symposium (DLS), held all day on Tuesday, was excellent. I hope it happens more! All of the invited talks were great. Gilad Bracha gave an exciting but oft-misunderstood talk about using dynamic-language runtime techniques to make a system like web-services usable . Many folks misunderstood this to mean thing like, through away your version control system, or you are at the complete mercy of the whims of your upstream service providers. I hope more people take a closer look at this idea; it sounds to me more like a Debian's apt system applied to . Or, for that matter, web services, where the provider can swap out the code behind the API any time they please. It works well with apt and with web services, and it seems promissing for continually updated components as well.

Gerald Sussman's essayic talk was about different styles of language use, and in particular about the uses of computer languages to impose formality. He paints a spectrum where programming languages are in the middle, forcing you to be formal, and in particular unambiguous. Math is at one end of the spectrum, forcing you to be rigorous in addition to just being formal (writing down 2+2=5 is a formal statement but not one that rigorous reasoning would let you get away with). The opposite end of the spectrum is fun to think about as well. Sussman calls it impressionistic communication, where you do a lot of hand waving and where you rely on shared knowledge with each other to get the point across. Overall, while a lot of his particular examples were annoying (he plaintively asks why Seymour Papert's Logo program isn't followed these days, but it's because it was tried in spades and didn't work!), I loved thinking about these different styles of language use (rigorous, fromal, and impressionistic). Besides, as a language enthusiast, it was fon to dwell on the idea of improved languages making people effectively smarter.

Jans Aasman, a high-level guy from Franz, talked about some research he is doing on practical projects implemented in multiple languages. He has collected ten programs that have been implemented elsewhere in C or Java, and his team has rewritten them in Lisp. All of them have less code, and some of them have dramatically less code -- on the order of 10%. I hope he continues this work, because it's great to do apples to apples comparison. I hope he also ponders the importance of little trivial details that customers need, though. Someone asked him about deployment, and he didn't have anything to say at all.

Brian Foote brought the house down with his talk about static typing. He had lots of great graphics, word plays, jokes, and so on, and it was great having him finish the day off for us. My favorite part of the talk is his goalie analogy that he carries through. He compares dynamic checks of all kinds -- type checks, array out-of-bounds, preconditions/postconditions, whatever -- to goalies in a soccer game ("metric football", as he calls it). These checks are like goalies trying to stop the opposing team (bugs!) try to kick a ball through the goal (crashes!). Static typing, in this analogy, corresponds to making a detailed proof that no ball will ever be kicked through the goal, and then firing the goalie and sending them home. It's theoretically possible that this approach works out, but you had better get your proof exactly right! Wouldn't you feel better, even with the proof, that there was a goalie hanging around, just in case?

On the tecnhical side, I'll try to briefly mention just half a dozen of the highlights for me. There was loads of good material:

• Layers, shown to us by Pascal Costanza, and class boxes, presented by Alexandre Bergel, are both ways to allow modular extension of existing classes. They let three people modify a class (add variables and methods) without stepping on each others' toes. This is good stuff for more complicated programs, and I hope research in this area continues.
• Marcel Weiher's higher-order messages are both disturbing and exciting. They disturb me because the higher-order messages look just like regular ones, and that seems like a possible source of confusion for programmers. On the other hand, it's just rleally cool to be able to write things like "morphs select visible" instead of "morph select: [ :m | m visible ]". A possible cleanup tossed out from the audience is to have some syntax for simple blocks where you only use the variable one time. Then the code might be something like "morph select: >>visible". I'm conflicted -- the technique clearly is convenient and reduces errors, but I also like having a restricted semantics little notion of the control-flow in the program, having a notion of which places there might be something more complicated that message-in response-out.
• Kathryn Gray presented some work on supporting hybrid Java and Scheme programs. The approach used a "dynamic" type on the Java side, and "mirrors" on both sides to wrap foreign objects. The presentation was itself was really enjoyable. She told us she is giving up computer science to start an ice cream stand, but then she realized that of course she needed a domain-specific language to record orders, and away she went. The presentation itself was given with the Dr. Scheme presentation tools and included lots of neat tricks like embedding yummy ice cream pictures in the middle of s-expressions in the middle of a live read-eval-print loop.
• Annie Liu's presentatino about "incrementalization" was very interesting. Her group is addressing the issue where the simple version of some code is inefficient because it recomputes things from scratch all the time, but where the efficient version is incomprehensible and buggy, because it has incremental updates scattered all over the code. Her technique lets you write the code in two chunks: a simple version, and a description of legal transformations that "incrementalize" the computation. I think it's fair to call this an aspects approach: there are two aspects (program definition, and speedup transformations), and then there is a weaver that combines them. Unlike most aspects work I have heard of, though, this weaver is extraordinarily complicated--it involves points-to analysis, for goodness' sake. I wondered, though, why she makes no mention of dynamic dependency mechanisms like the changed:/update: mechanism in Smalltalk, which seems like a dynamic analog to this mostly static technique.

Overall, the conference was a real blast. I found myself completely drained each night, and I crashed especially hard Thursday night after the conference ended.