[its-hackers] ITSPKG WINAGE

Jack Haverty jack at 3kitty.org
Wed Jun 9 19:49:24 CEST 2021

Yes!  When I think about the editor, I recall the face of one of the 
guys who wrote it.  Couldn't remember the name until you mentioned it -- 
Neal Ryan.

The EDITor was entirely written in MDL.  I think it also depended on 
using an Imlac for your display, which wasn't a problem since almost all 
TTYs were Imlacs.

My recollection is that you primarily used the Imlac's arrow keys to 
navigate around the data object being editted (usually a program 
fragment).  The left/right arrows moved to the previous/next object 
(e.g., when your "cursor" was inside a list).  The up/down arrows moved 
to the next higher or lower level of the structure.

By using these keys, you could pretty quickly get to wherever you wanted 
to do something.   After each keystroke, the Imlac display would change 
to show the new position of your cursor.   The "ampersand printer" did a 
very clever job at showing the most important pieces of the data.

When you got to the place you wanted, you could just type in some new 
data object, and the editor prevented unmatched or misplaced brackets.   
E.g., if you typed ( the editor would insert () and put your cursor in 
place to enter the first list element, e.g., you would see (|) on the 
screen.  Same for strings, type " and "|" appears on the screen.

It was virtually impossible to make a syntax error, so most programming 
effort became focussed on getting the algorithm and logic right, rather 
than worrying about parentheses and such.   The printout also always 
showed the actual code structure - no more getting confused because the 
indentation you used in the text file didn't have some > or ) in quite 
the right place so what was on the screen wasn't what was real in the 

There were of course lots of other short-cut keys, in the spirit of 
Emacs.   So CTL-SHIFT-<x> probably did something useful for all values 
of x.   I think a lot of that was Neal Ryan's work.

This occurred fairly late in MDL's evolution; I agree 1974-5 sounds 
right so that SYS.11.14 is probably the "new user's manual" for the 
editor.   We had a steady stream of students, and MDL was a pretty good 
environment to do a project, with the help of a little documentation to 
get them started.

DM used to change its name as the interests of the government changed.   
For a while, the government was interested in reducing the cost of 
building software.   So DM became the "Automatic Programming" group.   
Mostly us worker bees didn't notice anything different.  But as AP, we 
did spend a lot of time creating what would now be called an IDE -- MDL 
had the best "integrated programming environment" I've seen over the 
last 50 years.

MDL followed the LISP philosophy that code is also data.   So code can 
be manipulated just like any other piece of data in MDL, with EVAL to 
"run" it.   The EDITor was a part of that IDE.   It also involved the 
MDL compiler, and associated tools for incrementally making the running 
code more efficient, at the cost of making it less debuggable.

RSUBRs made the code relocatable, so it could move around and be shared 
among different users' processes in memory. Functions/packages could 
even be "swapped out" while they were running.   E.g., if function X 
called function Y, the system could swap out X, and automatically swap 
it back in when Y tried to return to X.   That was useful for especially 
large packages (e.g., probably things like MIGS).

The compiler had various levels of optimization that you could enable.   
At the lowest level, MDL structures and run-time behavior (e.g., 
"LISTENING-AT-LEVEL ...") remained intact.   At the highest level, the 
code was optimized at the machine-language level, so bugs would cause 
ILLOPs (ILLegal OPerations) or MPVs (Memory Protect Violation).   These 
were really hard to debug, and often you couldn't even figure out what 
function was running at the crash time, or find any of the data 
variables to see what's in them.

So the programming process was to start with a "blank sheet" in the MDL 
Editor, write your algorithm, get it doing what you want, then start 
optimizing.   You'd add declarations to specify constraints on the data 
being passed around.  As interpreted code, MDL would check those 
constraints, which helped find bugs.   As compiled/optimized code, MDL 
would assume you told it the truth, and if not, ILLOPs or MPVs were the 
common result.

Somebody created a package for debugging that helped with catching 
sneaky bugs.   Again, I can't recall the name of the code or programmer 
(may have been Dave Cressey (login DC or maybe DGC).

With the debugger, you could "swap" functions between interpreted and 
compiled/optimized versions.   On the fly.   There was some ability even 
to "run backwards" and use DDT-style BPTs (BreakPoinTs) to home in on a 

So in some long-running stable code (in my case, probably the COMSYS 
mail demon), suddenly it might start crashing with MPVs.   I could then 
swap out the compiled/optimized functions that were suspicious, enable 
full type-checking, put conditional breakpoints into appropriate places, 
and catch the next crash before it happened. Then fix the problem, 
reverse the process, and go back to whatever else I had been doing.

I think you'll have a lot of fun if you can find/recreate this ancient 
stuff.   It's really too bad that DM was never very big on writing 
papers et al.   Mostly we wrote code...

/Jack Haverty
MIT-DM 1970-1977

On 6/9/21 12:49 AM, Lars Brinkhoff wrote:
> Jack Haverty wrote:
>> Although EMACS had a Muddle mode, I remember the most common way of
>> creating Muddle code circa 1975+ was to use the "editor" package
>> inside Muddle itself.
> Thanks, that's great information and clues for further digging.
>> Does this sound familiar?  Has that "editor" been revived?
> It has not, and I haven't seen anything like it so far.  Do you think it
> would be based on TECO, or something else entirely?  Do you have any
> guess as to when this was in use?
> There's the 1974 DMCG memo SYS.11.14 "EDIT: The MDL Editor" by Neal
> Ryan.  I don't have a copy, but Lebling said he had a printout.
> I see a file MUDBUG; EDIT NHELP which seems to describe a "structure
> editor" command set.  There is also a binary NBIN file, and a few
> versions of EDIT source files that seem promising:
>          EDIT
>          FREDIT
>          Z^HN^HZ^HN
>          |
>          E-OVERPRINT
>          E-VERBOSE
>          E-PKG
>          E-?FILE
>          E-??FILE
>          EDIT-TABLE
>          MACSET
>          MAC
>          BREAK
>          SHORT-PRINT>
> <USE "PP" "FR&">

More information about the its-hackers mailing list