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.

5 Replies to “OOPSLA 2006”

  1. Pupil: “I warped my source to fit the computer – so now it doesn´t compute to me.”
    Master: “Loose the source, Luke. And get an universal translator.”

    Subtext solves three problems:
    1. It let you specify dataflow by explicit links instead of by the uses of variable names, manually and correctly ordered in a topologically sorted procedure: The model is based on relations instead of positions.
    2. It let you specify the function in the programflow instead of the actions.
    3. It let you see the program step by step in action.

    There are some further issues with text-based programming languages:
    4. They are by far to dependent on one syntax and one compiler.
    5. They are a really lousy way to describe relations, organizations and behaviour.
    In other words: The programmer is forced to translate the program he is working with (and needs to understand) to a dumb computer (the compiler). To do so he must use a text. And the compiler interprets any text as the source to the program.

    To understand a text you need two things: The organization of the text and the relations in the text.
    The organization describes the logical structure in the text, while the relations describes the information and interactions in the text.
    The organization controls how the text being read (code, string, comment), while the relations controls how the text being parsed.
    But the problem with a typical programming language is that:
    6. The organization of the text is defined in the syntax (not open for negotiation).
    7. The transformations of the relations from the text are concealed in the compiler.

    Ergo: The programmer needs a better translator.
    A better organized source (and a more cooperative compiler) can let the programmer describe, in the same source, both the translator and the text to-be translated, and let the programmer work iteratively and interactively, with every level in the text and every relation in the translations from the text.
    Lets give it a name:
    AMETIST – Autoloading Multilingual Embedded Traceable Interactive Source Transformer.

  2. I found a shorter name:
    RIDE – Relational Interactive Decoder Encoder.

    It describes how different encodings “rides” on the same text, with an explicit encoded logical structure with types you can define and use in your code.
    The encoded text can be in another file, with a reference to it in the logically structured text.

    The code is text and other communications, the relations are represented in the system.
    The system decodes from text to relations and encodes from relations to text.
    It also transforms from relations to relations.

    And the user can follow what the system does (and why it does it) in tests and simulations, like with Subtext.

  3. If RIDE is the infra structure in the system, then MUST can be the user:

    Modular Universal Source Transformer
    Relational Interactive Decoder Encoder

    MUST can do the process logic and the tranformations, read the scripts and do the in/out of texts, while RIDE does the relationstores, namespaces, process-spaces, decodings and encodings, the specifications of encoding forms, escape sequences etc.

    MUST RIDE can be a mark-up standard for source-codes, like XML is it for text document formats, but with a totally different logical structure and semantics.

    Finally: A bit of future appetizing.

    Does your precious programming-language sometimes make you feel like you are struggling in the Turing Tar Pit? And you MUST get a RIDE?

    MUST – Modular Universal Source Transformer
    RIDE – Relational Interactive Decoder Encoder

  4. To reliably tell MUST what to do with the texts there must be a standard semantics, abstract structure and representation for parts of the texts (and escape-mechanisms to safely jump over the rest):

    SURF – Source codes Universal Representation Form

Comments are closed.