Background of MDL
Date: Tue, 07 Feb 2006 09:24:39 GMT
"So your description of MDL seems to strike a chord - and I'm interested
to know what the design principles behind it were and ultimately what happened to it? I understand that it was a post-Lisp implemenation, but Wikipedia unfortunately only holds a stub (David - you should add a bit to this being a man in the know). "
We wrote MDL in 1971, at Project MAC at MIT.
It was a collaboration between Gerald Sussman and Carl Hewitt of the AI group, and Chris Reeve, Bruce Daniels, and myself of the Dynamic Modeling (DM) group.
On the DM side, the entire gruop knew we needed something in the way of a higher level language. The language search task force kept coming up without a suitable language, so we finally decided that we would build one in less time than they would find one.
I'm really not a very good person to recount the design principles of the overall design. About all I can give is my personal retrospective, clouded by 35 years of fading memory.
We decided on a lisp variant as a combination of easily implemented, yet powerful expressiveness.
Gerry Sussman wrote the evaluator. This was the "left brain" of muddle, the
executive program follower. Gerry was thinking of a language he called
"conniver" at the time, and went on to create "Scheme" at a later time.
Carl Hewitt wrote the association manager (which we called the "association
hacker"). This was the "right brain" of muddle. It kept track of the
values associated with atoms, and a whole lot more. You can think of it as
an in memory database, if you like. Carl had an idea for a language called
"planner", which he went on to work on.
Chris Reeve wrote the I/O subsystem, which included the reader and the printer. This was the heart of MDL. The reader converted MDL source language (text) into the data structures that an MDL program needed to run. The printer did the reverse. The printer also had mechanisms for printing stuff that was NOT MDL source, but we were most interested in having the printer be able to write MDL source code, given the object code. Today, that might be called "reverse engineering".
Bruce Daniels wrote the primitive functions. This was the "muscle and sinew" of MDL. Without the primitive functions, the MDL programmer would have had an elegant system in which nothing could be done. Some of the primitives were straightforward, like the ones to add and subtract numbers. Others were quite subtle, like stack analysis primitives that allowed debugging on the fly.
Chris Reeve and Bruce Daniels went on to hellp found Infocom, which was known for Zork and other interactive fiction works. Zork was originally written in MDL.
I wrote the memory management module. I guess that's the "gastrointestinal
tract" of MDL. Most of that was very routine, except for the automatic
garbage collector. Because we were supporting datatypes and arrays,
locating all the pointers was quite a bit more intricate than in original
lisp. Also, compacting the garbage into one big block involved quite a bit
of housekeeping. What we called "compacting" would today be called
"defragmenting" I guess.
Each of us had things we wanted to add to the language, and talking about the design principles would involve all five pieces. We often met to discuss the overall architecture, so that each of us could push and shove on the architecture and thus be able to write the code for our own piece. But we managed to keep the scope of the project small. It was a few months before we had a prototype suitable for a demo.
MDL lasted over ten years at project MAC. That's quite a lifespan in that environment.
A lot of the principles in the language were, frankly, over my head at the time. My job involved the internal housekeeping. It was not very "advanced programming" on an intellectual level, but it was important to get it right.
Stu Galley went on to write the MDL manual. That might outline the design principles a little better than I can. I'll try to recall as much as I can. Received on Tue Feb 07 2006 - 10:24:39 CET