OOPSLA 2007

I’ve just returned from the OOPSLA 2007 conference (www.oopsla.org) in Montreal. This was the single best conference I’ve ever been to. As you’ll see, the conference was much less about “object-oriented languages” (a topic which was used up years ago) than about software development and engineering in general.

Actually I attended three events: the Dynamic Languages Symposium, the Montreal Scheme and Lisp User’s Group Meeting, and OOPSLA itself. This meant that I went to evening activities every night, so it was non-stop and exhausting. On top of that, I developed some kind of stomach virus the day I left and was somewhat sick the whole time I was there! But the conference was so energizing that I mostly forgot that I was sick, aside from the fact that I didn’t eat very much. There wasn’t any time to get to real restaurants anyway so all I had was fast food, although some of it was quite good. There were plenty of other parallel activities that I could not get to, such as a day-long symposium about garbage collection, an APL conference, a Wiki symposium, an educator’s symposium, and on and on.

Two other ITA friends came: Francois-Rene (”Fare”) Rideau, and Alexy Radul who is just finishing an internship at ITA. Alexy had previously been an intern at Google with Arthur Gleckler, and the four of us ate and hung out together a lot. Arthur knows so many people who I know that it’s amazing we had never met before. He was one of Gerry Sussman’s grad students, and has worked with my old friends Charles Frankston and Carl Hoffman. We talked about everything, and I found out more about what life is like at Google, where Arthur works on mobile computing.

Many of the conference luminaries and keynote speakers were old friends of mine. Richard Gabriel of IBM Research, who was the conference chair, I had worked with on the Common Lisp spec, and later when his company, Lucid, was using my company’s Objectstore object-oriented database. I had worked with Guy L. Steele Jr., now of Sun Research, for years at the MIT Artificial Intelligence Lab in the late 70’s. I’ve known Gregor Kiczales, now professor at U. of British Columbia, for years. And so on. Dick Gabriel started working on this conference over two years ago and has done nothing for the last year but arrange the conference. I feel that his work was a huge success.

I met and spent time with several other very impressive people:

Mark Miller, formerly of Xerox PARC, and now of Google Research. He’s open source coordinator for the E programming language, a pioneer of agoric (market-based secure distributed) computing, and an architect of the Xanadu hypertext publishing system. I found him to be a remarkably clear thinker and good explainer.

David Ungar, formerly of Stanford and then of Sun Research and now at IBM, was co-designer of the “Self” language, a particularly simple object-oriented langauge in which there are no classes: objects just inherit from objects. He achieved an amazingly performant implementation.

Richard Tibbetts, formerly of MIT, is a co-founder, architect, and team lead at StreamBase, developing a Complex Event Processing Platform. This is one of the startups based on Mike Stonebraker’s recent research work. We talked about databases, startups, and also about back-home things since we live near each other.

Michael Ernst, an MIT professor working on adding abstract types to Java (JSR-308). This will be one of the major language upgrades in Java 7. It’s great to see that there is interest at MIT in Java in specific and programmer productivity in general. He gave a talk later that I wasn’t able to get to, about his Javarifier (inferring annotations to the code) and Javari (type checker) tools.

One thing I heard from many people was a uniformly negative verdict on the new R6 Scheme standard. This is really too bad, since a lot of work went into that standard and the Scheme community really does need a standard. But there are so many problems with the new standard that nobody seems to like it and many Scheme implementors are not intending to support it.

There were so many interesting papers that I can only hit the high points of the most prominent ones. Here goes.

The Dynamic Language Symposium:

Mark Miller of Google Research talked about security: fighting the malware crisis by running everything with least privilege, using capability principles in languages. He discussed various approaches to retrofitting such concepts into existing languages. JOE-E (Google, HP Labs, U.C. Berkeley) is a subset of Java (so all the tools still work and there is no slowdown), checked by a static verifier. W7 (Jonathan Rees’s thesis) and Cava (at Google) work by inserting runtime checks, which allows more flexibility but there’s a slowdown. I am pretty convinced that capability-based systems are the way of the future and if I ever get to work on them, I’ll follow all the references in this talk.

Alexy gave a shortened version of the talk on Probabilistic Scheme that he gave at ITA recently. I felt that it got a good reception.

Morten Kromberg, of APL-vendor Dyalog, talked about how they have added object-oriented programming to APL. APL is still alive and well, being used by engineers, financial analysts, actuaries, and data miners. Apparently many domain experts can learn to program APL themselves, which gives them a lot of personal power. Insurance companies are particularly APL’s sweet spot. The objects use the Microsoft CLR, and APL can treat the contents of an Excel spreadsheet as an APL array!

Shriram Krishnamurthi, a well-known Scheme and languages professor from Brown who I first met at the original Lightweight Languages Workshop at MIT, talked about Relationally-Parametric Polymorphic Contracts. It was about how to do contracts in your language less painfully without giving up power, involving inferencing at runtime using unification (in the sense of things like Prolog).

Jim Hugunin of Microsoft talked about the new Dynamic Language Runtime, essentially an extension of the Common Language Runtime to make it easier to write .NET compilers for dynamic languages. Jim, who had earlier implemented Jython (Python in the Java Virtual Machine), set out to show that the CLR was no good for dynamic languages by showing how bad Python would run. But after he implemented IronPython for the CLR, he was surprised to see that it actually performed very well! Although it has to do some gross things to work dynamically (e.g. each add has to check both argument datatypes manually), it still runs quickly in comparison to the original Python because the original Python is an interpreter, whereas IronPython takes advantage of the JIT compiler in the CLR. His group is also doing a JavaScript, and they intend for the CLR/DLR to be a suitable platform for Ruby, PERL, and so on. He went into a lot of detail and answered many questions.

The Montreal Scheme and Lisp User Group:

Manual Serrano, from INRIA (the French research institute), maintainer of Bigloo Scheme, talked about “HOP”, his system for allowing you to create highly dynamic web sites with much more elegant code than the usual jumble of HTML, CSS, JavaScript, and so on. His language lets you write code and succinctly flag which parts should run on the client and which on the server, at a very fine grain. He showed some very advanced web behavior in only a few lines of code. Very impressive!

Pascal Costanza of the Programming Technology Lab of the Vrije Universiteit Brussel, Belgium, talked about his work in context-oriented programming based on CLOS. (Pascal is also known for his Common Lisp documentation and for work on aspect-oriented programming in CLOS.) Context-oriented programming lets you create “layers”, which can be turned on and off orthogonally and dynamically within a thread. When a layer is established, an associated set of instance variables and methods become visible in CLOS classes. Amazingly, he was able to build all of this on top of the CLOS meta-object protocol!

Finally, the OOPSLA conference itself:

Kathy Sierra talked about how to create passionate users; that is, how to make products that will get users excited and enthusiastic. This was completely fascinating and I took two whole pages of notes. She has given this talk before, and there is commentary on the web about it already; see:

http://conferences.oreillynet.com/cs/os2005/view/e_sess/7077

http://www.oreillynet.com/onlamp/blog/2005/08/tutorial_review_creating_passi.html

And a blog at:

http://headrush.typepad.com/creating_passionate_users/

She’ll also be writing a book about it soon, to be published by O’Reilley. She’s also the co-author of a series of books called “Head First xxx”.

Jim Purbrick and Mark Lentczner of Linden Labs, the creators of Second Life, explained a great deal about what Second Life is and how it works. The most interesting thing is that 15% of the residents actually do coding, in a language that lets you make active objects. There are 30,000,000 running scripts, 2.5 billion lines of code. Generally there are 15,000 scripts actively running on each “region” (processor), updating at 45 frames per second, and there are 4,000 processors. There are 30,000,000 concurrent threads. The language itself they described as “terrible”; they are working on bringing up the Mono implementation of the CLR so they can provide good languages. There are some complicated issues in which threads must be migrated from one CPU to another as an object moves around within regions of the Second Life world. The most impressive thing is how many people with little or no technical training are doing programming. They also talked about how the Linden Labs developers, eight of them at five physical locations, use Second Life itself as a collaborative development environment; they say it works really well, particularly due to having stereo audio that’s good enough that you can tell where sounds are coming from. During the talk they showed Second Life on the big screen and moved around and interacted with people, so that you could see what it’s like. I, myself, hardly have enough time to live my first life, let alone a second life, but it was quite fascinating to see what’s going on in there.

That evening, Guy L. Steele Jr. and Richard Gabriel did a presentation that I can only describe as a cross between a lecture on the history of programming languages, and piece of performance art. They said exactly 50 things, each in exactly 50 words, so it sounded like haiku a lot of the time. They presented many real languages from the 50’s to the present, including some very weird ones, plus several joke languages (such as the famous Intercal which does all its output in Roman numerals). I was particularly thrilled when they used the xkcd.com cartoon called “Lisp”, as well as a hilarious “filk” song about how God created the universe in Lisp. The performance got a huge standing ovation. These guys are so amazingly clever.

Fredrick Brooks Jr., author of the classic book “The Mythical Man-Month”, talked about telecollaboration. Most of the talk was about collaboration itself, and under what circumstances it’s a good thing: not always! His main point is that collaboration is great for determining system requirements and brainstorming about possible approaches, but that you really need a single system architect in order to achive conceptual integrity. The system architect can delegate parts of the architecture to others (e.g. the user interface czar), but he distinguishes sharply between delegating design (OK) and sharing design (not OK). He had insightful things to say about the open source process (good for some kinds of software but not others), pair programming (he likes it), and object-oriented programming (the most powerful technique to come along so far to improve software productivity). He is an extremely clear speaker with a lot of good points to make. He’ll be writing a book of essays soon.

Then there was a panel session entitled “No Silver Bullet Reloaded”, based on the famous 1986 paper “No Silver Bullet” by Fredrick Brooks. See

http://en.wikipedia.org/wiki/No_Silver_Bullet

and follow the link to the paper. This is one of the best and most important papers ever written about software engineering; if you haven’t read it, you should.

The paper starts: “Of all the monsters that fill the nightmares of our folklore, none terrify more than werewolves, because they transform unexpectedly from the familiar into horrors. For these, one seeks bullets of silver that can magically lay them to rest.” The paper surveys all the major techniques that have been proposed for making software engineering far more productive, considering each carefully and explaining why none is a “silver bullet” for solving the “essential” complexity of software. At the panel, well-known author Martin Fowler converted himself into a werewolf (with a funny mask) and made all his points in the negative, which was hilarious. Of course all the panelists agreed that there are no silver bullets. David Parnas was the most specific about what he meant by a “silver bullet”: there is no technique that’s easy to learn (e.g. a three-day seminar) that’ll solve the hard problems of software design and construction. They also all agreed that it’s hard to talk about what techniqes improve productivity by a factor of ten since there really isn’t any good way to measure productivity. Many good and interesting points were made. Brooks highly recommends the book “Peopleware” (I have a copy but haven’t read it yet; clearly I should.)

The next keynote speaker was John McCarthy, one of the creators of the field of Artificial Intelligence, the creator of the Lisp language, the long-time director of the Stanford Artificial Intelligence Lab, winner of the Turning Award in 1971. Unfortunately, this was the one disappointing talk of the conference. He had very little to say, and he just read his slides.

David Parnas of the University of Limerick, one of the first people to define and expound upon modularity in software, was the next keynote speaker. He defines object-orientation as “designing software by desiging and implementing data-holding objects that make the job easier” and insists that you don’t need any special language to do it: object-oriented is about how you design. His talk stressed our inability to write clear specifications for software. (The EU is currently fining Microsoft $3M/day until Microsoft produces a clear and precise specification for their server [I'm not sure exactly what software we mean here], but it’s just too big and hard to do. Microsoft offered the sources, but nobody wants that, since the sources just say what the software happens to do now, not what it’s defined to do over time.) He advocates much more precise and specific documentation, kept up to date, to the point where if someone asks a question about the software, a programmer would go to the documentation rather than the code to answer the question. It finally turns out that he wants extremely precise specs written in a mathematical notation, which is very possibly appropriate for the kinds of software projects that he was discussing (avionics, nuclear power plant safety) but not for anything I’ve worked on. I’m in sympathy with the call for far better code documentation, though.

Next up was my old friend Gregor Kiczales, one of the creators of the Common Lisp Object System and the father of Aspect-Oriented Programming. He talked about Effectiveness Without Formality. This talk was very deep and philosophical. It was based heavily on the work of two Xerox PARC scientists/philosophers, Lucy Suchman (”Human-Machine Reconfigurations”) and Brian Cantwell Smith (”On the Origin of Objects”, known to be a difficult book to read). Unfortunately I had no familiarity or touch-points for their work, and partly for that reason, Gregor’s talk was, frankly, over my head. Among his key points: There is conflict between the power of programming langauges and the flexibility of design patterns. There is conflict between the mathematical foundations of programming and the way people really work. The world is sloppy and imprecise. There is a big distinction between programming languages that are “effective” (actually make things happen), and formal abstractions which are not “effective”. People never understand each other precisely, but we can deal with this. He talked a lot about “intensionality”, which he described as “the ability to be ‘about’ something”, and the intensional relationships between users, code, bug databases, and all the other entities of software development. The world is as far from formal as you can imagine! Abstractions are transient, shifting, and negotiated. That’s about as much as I got from this. If it were not Gregor, I would have been dubious about the whole thing. I asked whether he had any idea how these ideas might turn into something useful, and he said, not yet. On the way out of the room, Mark Miller said that this was not only the best talk at the conference but the best talk he had heard in years. So if the people smarter than me think that, I should probably try harder to understand.

Jonathan Edwards, a researcher at MIT CSAIL, gave a very interesting talk about conditionals as tables. He presented a two-dimensional graphical notation for representing conditionals, which, as I see it, takes something that was imperative and makes it declarative, always a source of power. This makes it much easier to specify multi-armed conditionals, in that you say what you want rather than how to achieve it, much as in a database query language. So far this only works for functional (no side-effect) programs and it’s not clear yet whether the idea scales to larger programs (he showed a very elegant Fibonacci example). A lot of the smart people in the audience were very impressed.

Sebastian Fleisner from Hong Kong talked about Epi-Aspects: Aspect-Oriented Conscientious Software. By “conscientous” he means “self-sustaining”, continuing to work in the face of failure. This is based on a paper last year by Richard Gabriel and Ron Goldman about “Conscientious Software”. Its abstract is: “Software needs to grow up and become responsible for itself and its own future by participating in its own installation and customization, maintaining its own health, and adapting itself to new circumstances, new users, and new uses. To create such software will require us to change some of our underlying assumptions about how we write programs. A promising approach seems to be to separate software that does the work (allopoietic) from software that keeps the system alive (autopoietic).” The presentation talked about the latter part as having operations like monitor, test, repair, and kill. Their proposal has to do with using aspect-oriented programming to achieve this. What they’re talking about sounds a lot like some of what I’m currently doing in my own work on Hot Upgrade, and I intend to read both papers and see if there are any good ideas I can use.

Pattie Maes, from the MIT Media Lab, was the next keynote speaker. (As you can see, they had a lot of keynote speaker and I spent most of the conference at keynotes!) She talked all about interesting projects being done at the Media Lab to try to give people access to information at their fingertips when they’re not sitting at the computer. This was all quite interesting and fun although it didn’t have much to do with the subject matter of the conference.

Finally, the last talk was by Brian Foote of Industrial Logic Inc.: “Big Ball of Mud: An Introduction to Post-Modular Programming”. The key point was that most real-world systems use a “big ball of mud” (totally unmodular) architecture, and why is this architecture so popular and successful? Maybe we should give up trying to teach people to be modular, and embrace the big ball of mud. The talk was very rambling and often funny, and I can’t figure out whether it was three-quarters tongue-in-cheek or entirely tongue-in-cheek. By this time I was so exhausted that I was yawning through the talk, anyway.

There were plenty of other talks that sounded interesting, but I could only be in one place at a time, and I’m not sure that I could have absorbed even more material in one week anyway! The set of speaker was nothing short of stunning, and I also learned a great deal from casual conversations during the breaks. I’m back home now and nearly over my illness, and ready to read all the “to do” and “read this” notes I wrote during the conference and get started.