[its-hackers] ITSPKG WINAGE
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 --
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
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...
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:
> PACKAGE "EDIT">
> <RENTRY DEADIT
> <USE "PP" "FR&">
More information about the its-hackers