Wed, Nov 11, 2015 at 3:35 PM
Hello, are you the Greg Pfister that worked on Muddle (MDL) back in the
day? Here's hoping you are and that this email address works when I
click on Send... :)
Wed, Nov 11,
2015 at 7:05 PM
To: Jason Self
Yes, that's me.
However, I didn't really work on the language or its implementation; rather, I documented it. Some did think that was the bigger feat, since it was rather huge had kind of just grown without documentation of any kind.
Sic Crustulum Frangitur
Quidquid latine dictum sit, altum videtur.
[Quoted text hidden]
Wed, Nov 11, 2015 at 8:25 PM
To: Greg Pfister
> However, I didn't really work on the language or its implementation;
> rather, I documented it. Some did think that was the bigger feat,
> since it was rather huge had kind of just grown without documentation
> of any kind.
Documentation seems to be all that survives today. Perhaps it is enough.
A group of people (3 or 4 counting myself) are looking into the possibility of reimplementing Muddle on modern systems (GNU/Linux.) It seems an interesting technical challenge. I have learned from  that Muddle was ported to UNIX at some point, but sadly none of that code seems to have survived to the present day. I've also learned that MIT had an extensive Muddle library on a machine called mitajax (or perhaps just ajax) but it seems to have been decommissioned and no one knows what happened. Just a few PDFs seem to be all that's left, and those cover much but not everything    . Those PDFs refer to other documents which I can't seem to find, like EDIT: The MDL Editor and etc. I'm wondering if you might have additional information on Muddle or know where it could be found? For example: I've learned through my research that Muddle had a machine independent virtual machine but no documentation of it (bytecode, etc.) seems to exist or at least I've not been able to find it if it does.
And there is always the "you don't know what you don't know" aspect
too - so I'm not interested in just EDIT and the virtual machine but anything can be learned.
And even if you have no further information, thanks for taking the time to listen to me. :)
 http://ifarchive.flavorplex.com/ifarchive/ programming/mdl/manuals/MDL_Programming_Language.pdf
 http://ifarchive.flavorplex.com/ifarchive/ programming/mdl/manuals/MDL_Programming_Environment.pdf
> Quidquid latine dictum sit, altum videtur.
Wed, Nov 11,
2015 at 10:01 PM
To: Jason Self
I think your best bet is to try contacting Dave Lebling.
After leaving LCS, where he worked in the same group I (and Muddle) was, he founded Infocom, creating Zork. And Zork, I was told, was written in a port of Muddle (very sure of that) which was made machine & OS independent (less sure of that; it's obviously desirable for a game, just hard) (and would explain the VM).
Who knows, best case maybe he kept a copy for old time's sake.
Dave should be fairly easy to contact; he even has a Wikipedia page. He also had (has) a phenomenal talent for creating really good games.
Hope this helps! Let me know how things turn out. Muddle was fun.
(And it will always be Muddle to me. "MDL" was "Oh #$&% we're going to lose our DARPA funding for a funny name" from a fearful administrator.)
[Quoted text hidden]
Thu, Nov 12, 2015 at 12:29 PM
To: Greg Pfister
> I think your best bet is to try contacting Dave Lebling.
Thank you. I am in contact with Dave Lebling.
> (And it will always be Muddle to me. "MDL" was "Oh #$&% we're going
> to lose our DARPA funding for a funny name" from a fearful
Do you know where the Muddle name came from or how it got started or
what it was supposed to be about or whatever?
Thu, Nov 12,
2015 at 2:13 PM
To: Jason Self
On Thu, Nov 12, 2015 at 12:29 PM, Jason Self
>> I think your best bet is to try contacting Dave Lebling.
> Thank you. I am in contact with Dave Lebling.
Good. He's sure to know something.
>> (And it will always be Muddle to me. "MDL" was "Oh #$&% we're going
>> to lose our DARPA funding for a funny name" from a fearful
> Do you know where the Muddle name came from or how it got started or
> what it was supposed to be about or whatever?
The backronym was "MAC's User Defined Data and Language Evaluator." But that was well after the fact. I don't recall, if I ever knew, where the original name came from.
"MAC" was from "Project MAC", the original name for the MIT lab where Multics (and other things) was developed. It stood for "Machine Aided Cognition." That name was changed to LCS shortly after I left. During a visit back there just after the name was changed, I noticed that the men's room door to the 9th floor (AI lab) had acquired the label "Lavatory of Computer Science." (Hackers don't usually respond favorably to what they perceive as unnecessary changes to their environment.)
There may have been a name connection to Carl Hewitt's proposed language Planner, for AI, since there certainly were other connections. Muddle follows Planner syntax very closely. It also follows the simpler parts of Planner semantics closely, like notions of evaluating an array or other data, and arrays, strings, etc., being first class objects (unlike LISP at the time). It didn't try to do his automatically enabled backtracking, though. That was insane.
An aside: I seem to recall that I was the author of the first inline editor/debugger written in Muddle for Muddle. I also wrote -- or rewrote; there may have been a less fancy one before I started hacking it -- nearly all of of the first pretty printer. That's rather necessary if you want to save changes you made in the debugger. It helped that comments were also first class objects that stayed with the program during interpretation, although prettyprinting them was a bitch.
Other general background, a.k.a. Giant Aside:
Making up new languages was in the air those days. I now consider that a big mistake, and believe nobody should even consider creating a new language until he/she has written at least 100,000 LOC in at least four other languages, each. Of course none of us had done that, but we didn't know better at the time. I made up one myself, called Dali (a name I cringe at now), for writing animations of objects in computer graphics. It was based on what now would be called objects with closures, several years before objects hit the scene. (Closures were all over the LISP language world.) Object closure execution was triggered on events like a request to move or resize an object, so, for example, trying to move a ball would make it bounce and trying to move a human figure would make it walk. (This was a Long Time before OOP.) Anyway, Dali and Planner and Muddle to say nothing of dataflow languages were part of the "new language" trend.
Planner, with its automated backtracking, got a huge boost when Winograd used a simple Planner LISP extension to implement his "blocks world" AI microworld, which was regarded with awe in the AI community. Planner as a result was the kickoff of a "procedural embedding of knowledge" fad in AI. (A few years after all this, I spoke with another AI grad student whose thesis title was that phrase, asking him what he found out. His answer: "Don't embed knowledge in procedures." A somewhat shortlived fad.)
Hewitt responded to the reflected fame by developing syntax and semantics to beat the band, leaving LISP syntax far behind. Muddle might well have began as an informal attempt to implement part of it; it was never explicitly funded at its start, and even was done in a group with a different funding contract.
Hewitt kept on adding features and filigree to Panner until it was getting ridiculous, IMHO, and its description, his thesis, kept getting longer and longer.
Eventually Gerry Sussman – who was then a grad student in the AI lab, along with Hewitt; I was a grad student in MAC – got seriously fed up with Planner. Exactly why, I'm not sure; he certainly considered it bloated and rococo, which it definitely was at that point. He also wanted something usable (and implementable in finite time) in which to program his own thesis. Or maybe it was Hewitt's newfound predilection for wearing ascots.
So Sussman defined and implemented another language which he called Conniver, explicitly referring to it as "the Jewish Planner."
(Hewitt was 100% blond WASP, from Texas I believe; Sussman was NYC Jewish, with one of his goals being to get an airplane pilot's license before a (car) driving license).
Conniver was lean and mean. It just added closures to LISP, with a very few primitives to manipulate them. His manual was short, decorated with entomological insect pictures (bugs, or course) and his crowning touch was a one page implementation of Planner in Conniver.
Well, that one page at least implemented the entire backtracking core of Planner, which was the main thing anybody really ever wanted.
I believe Sussman used Conniver for his thesis. All I recall about that is he had programs which looked at whether other subprograms were failing, and modified them to do better. The reason I remember that: Minsky seized on it to proclaim that programs were now conscious! They examine themselves! Gack.
I don't know if Planner ever got used for anything significant other than the blocks world. I seem to remember that people didn't like it because it was too uncontrollable; once it started backtracking you couldn't tell why things happened.
Muddle, of course, went on to be the implementation language of Zork.
I implemented Dali as an extension of Muddle. Dali never went anywhere either, although when I ran into Alan Kay (of Xerox PARC and computer graphics fame) at a conference many years later he acted very happy to meet me and said he was using the principles in Dali as the core of the latest thing he was doing. So maybe it had some impact.
Can't leave this out: The person who deserves the credit for implementing Muddle at MAC is Chris Reeve. The last (and only) email I have from him puts him in AMD. I've no idea where he is now. Before AMD, he worked in France for a compiler company whose name I don't recall.
Dang, this got long enough that I think I'll copy and publish it in my "Random Gorp" blog.