OOPSLA 2006

Greetings from Portland, Oregon. Here are my impressions of OOPSLA 2006.

The high point for me was that a number of grad students and young professors told me that they had found Subtext interesting and even inspirational. I suppose that is actually the best outcome I can reasonably hope for – to infect some young minds with my ideas.

The power failure was memorable. We were left sitting in the dim emergency lights, without projectors, mikes, or networking. Some people with Apple laptops set up an adhoc wifi network, and the speaker shared his slides over it. So we sat in little clusters on the floor around laptops, paging through the slides in synchrony with the speaker. Homo Digitus in the wild, huddled around the light of the laptop.

As usual, there was a lot going on. I noticed one trend: providing alternative code presentations within an IDE (Eclipse, in almost all cases).

Charles Simonyi gave a rather stuffy presentation of his “intentional programming” project. They are calling their product “Domain Workbench”. The demo showed how you could viz C# code in different ways, as typeset formulas, or spreadsheets (for unit tests), and various stylistic transformations. Actually a rather weak demo that showed only a fraction of their capabilities, and didn’t touch on Domain Specific Languages, which is what the talk was supposed to be about. I guess he is paranoid about revealing “secrets” to the “competition”. I gave Magnus Christerson an earful about the folly of being secretive and proprietary in today’s world, but I think he already knew that. Maybe the problem is that billionaires don’t get contradicted.

The Safari project at IBM is an attempt to do something similar: building generic IDE’s from a DSL definition. They are focused on adding support for their X10 language into Eclipse, but have done it in a very general grammar-driven fashion that would enable many sorts of DSL’s to be supported. What is most impressive is how well integrated it is into Eclipse. They even have basic support for debugging in the DSL source language, which none of the competing projects has addressed yet. I would say Safari is the most impressive implementation of the IDE-generating idea I have seen. I would really like to know what Teitelbaum and Reps think about it (they first proposed the idea 30 years ago in the Cornell Program Synthesizer).

Andrew Eisenberg, a student of Gregor Kiczales, demonstrated a framework for “language extension through presentation” (which happens to be a slogan from my Subtext paper). He is using Java annotations to encode mappings into alternative views of fragments of code. His custom Eclipse editor notices those annotations and presents the alternative view, such as a mathematical formula, or even a state machine diagram. These views are fully editable. I didn’t ask the obvious questions: what happens if you modify the underlying Java code, like adding behavior to the state machine transitions. And how you debug it. Nevertheless a nice piece of work, notable because it was done by one grad student, rather than the big teams at IBM, IntentSoft, and Jetbrains.

There were some more specialized code presentation techniques demonstrated. Emerson Murphy-Hill, a student of Andrew Black, showed how to visualize a potential refactoring by drawing various sorts of boxes and arrows in the code, and further indicate the errors blocking those refactorings. Terry Hon, another student of Gregor, demonstrated “Fluid AOP”, which is basically doing aspect weaving incrementally in the IDE. You can define an aspect and see the code being inserted all over the place incrementally as you type. You can query your code on join points producing an (editable) view that gathers them together. A cute visualization is collapsing these gathered methods together to show what parts are common, and what parts vary (the parts that vary become gray boxes). You can edit the common parts and see the changes propagate into all the sources. This is so obviously the right way to do aspects.

The whole idea of multiple custom views of code is catching on. Steve Reiss tried this in the 80’s but got little traction. What has changed since then is Eclipse (and the CPU speedup that made Eclipse possible). Almost all of the above work leverages off of Eclipse, which is turning out to be a great platform for research. I hope my little demo of example centric programming in Eclipse 2 years ago helped push this trend along. Andrew Black and Gregor Kiczales are leading the way in the academic space. I had a good chat with Andrew, who calls his group the Multiview Project.
See this paper for an eloquent statement of the idea.

George Fairbanks, a student of David Garlan and Bill Scherlis, demoed his idea of “framework design fragments”. This was also implemented via custom views in Eclipse, but stands out from some of the above projects in that it goes beyond the zero-sum game of visualization, instead providing a way to add information to the code that isn’t already there. The idea is that complex frameworks (libraries on steroids, like J2EE or Eclipse itself) establish many ad hoc patterns of usage within their gargantuan API’s. Like what you need to do to register a URL protocol handler in a web framework. This can be specified as a subset of classes and methods both within the framework and the client, with various responsibilities assigned. The client classes and methods are assigned “roles” in this pattern, called a design fragment. The key idea is that you can annotate the client code to document the fragment roles it plays. This annotation can be done automatically for existing code, and as a side effect of letting these patterns guide the introduction of new code. The annotations drive custom views of the code that explicate pattern usage. He is also working on statically verifying various properties that these roles must satisfy, though I think the main advantage will rather be the documentation effect of capturing these patterns explicitly, and the IDE guidance (like completion) they can provide. What is nice about this work is that, unlike fancier “architecture description languages”, it is lightweight and semi-formal. I want to do similar things in Subtext.

Tons of other stuff of course. Guy Steele gave an awesome talk about the design of Fortress. Phil Wadler, donning a red cape and a blue lambda shirt, made the point that if we are visited by aliens, they are unlikely to recognize C++, but will surely know lambda calculus. A lot of talk about “Ultra Large Scale Systems”, primarily because the Army may dump some major funding on it.

Next year OOPSLA is in Montreal. Au revoir.