Jason Self Wed, Nov 11, 2015 at 3:35 PM
To: greg.pfister@gmail.com
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... :)
Greg Pfister 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.
Greg
Greg Pfister
Sic Crustulum Frangitur
Quidquid latine dictum sit, altum videtur.
[Quoted text hidden]
Jason Self 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 [4] 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 [0] [1] [2] [3]. 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. :)
[0] http://www.dtic.mil/docs/citations/ADA070930
[1] http://www.dtic.mil/docs/citations/ADA050191
[2] http://ifarchive.flavorplex.com/ifarchive/
programming/mdl/manuals/MDL_Programming_Language.pdf
[3] http://ifarchive.flavorplex.com/ifarchive/
programming/mdl/manuals/MDL_Programming_Environment.pdf
[4] http://www.dtic.mil/docs/citations/ADA197342
> Quidquid latine dictum sit, altum videtur.
Indeed!
Greg Pfister 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.)
Greg
[Quoted text hidden]
Jason Self Thu, Nov 12, 2015 at 12:29 PM
To: Greg Pfister
Greg Pfister wrote ..
> 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
> administrator.)
Do you know where the Muddle name came from or how it got
started or
what it was supposed to be about or whatever?
Greg Pfister Thu, Nov 12,
2015 at 2:13 PM
To: Jason Self
On Thu, Nov 12, 2015 at 12:29 PM, Jason Self
wrote:
Greg Pfister wrote ..
>> 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
>> administrator.)
> 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.
Greg
