Interlisp-D and MIT CADR Lisp Machine demos for IJCAI Conference (1981)

https://archive.org/details/xerox-parc_V-141_1

by _19qg • 2 years ago

67 35 2 years ago

lispm3• 2 years ago

Two different very early Lisp Machines (a Xerox Dolphin and a MIT CADR), which are personal workstations running a Lisp operating system with early graphical user interfaces, are being demonstrated, from Xerox PARC. Both machines are integrated into the early 3 Mhz Ethernet there. The Interlisp-D / Xerox Dolphin demo begins at 00:20 and the Lisp Machine Lisp / MIT CADR demo begins at 25:00.

Includes noises from Lisp Machine keyboards. The use of the Interlisp-D structure editor for source code is shown.

The demo was for the IJCAI (International Joint Conference on Artificial Intelligence) in Vancouver, 1981

I've watched the H.264 version.

shrubble5• 2 years ago

It's interesting to see the differences - the Interlisp machine is pretty much a "graphical workstation" which is recognizable today, though in monochrome; the CADR is more spartan on the GUI side.

I am slowly learning Lisp and have the Interlisp VM running on my system, and it executes very quickly on even 10 year old hardware; which of course is 1000 or more times faster than what it originally ran on.

_19qg• 2 years ago

One of the differences is that Interlisp-D used smaller windows. For example the structure editor we see in the video edits one function. The MIT CADR uses often full-screen windows and EINE/ZWEI/Zmacs usually edit files with several definitions. The MIT CADR demo showed how to split the screen into several windows, like several editors and listeners (REPLs). Thus splitting the screen into windows or panes was normal, but you don't have to. You can place windows with the mouse (and reposition/resize them) as well.

I was a bit surprised to see that they could demo an early MIT CADR at Xerox PARC. These were large, fragile and rare machines at that time. The MIT CADR was about to be commercialized by LMI, Inc. and Symbolics, Inc..

One other thing to note is that a lot of research went into the Interlisp-D IDE (not just the graphical version): interactive help, source code management, programming by example, window manager, programmer's assistants, ... The video for example shows how refactor Lisp programs using the source code management tools.

gumby3• 2 years ago

I was a bit surprised to see that they could demo an early MIT CADR at Xerox PARC. These were large, fragile and rare machines at that time.

They weren't extraordinarily fragile; robot wirewrapping is pretty robust. The next year we shipped a couple of them to Paris and I used them just fine, along with a KL-20 that also made the trip OK.

kragen6• 2 years ago

the relative speed might depend somewhat on what you're doing. following a random pointer into ram that isn't in your cache still takes something like 80 nanoseconds, while in 01981 it might have taken 500 nanoseconds. but in 01981 executing an instruction also took 500 nanoseconds, and now in 500 nanoseconds this laptop typically executes over 9000 instructions when it's not idle. lisps tend to involve higher proportions of random pointer following than things like golang or numpy

JonChesterfield2• 2 years ago

That's an interesting point. When arithmetic and memory accesses cost about the same, pointer chasing through graphs works great. The currently popular struct-of-arrays and cache oblivious datastructure patterns only really make sense when arithmetic is essentially free relative to memory.

DonHopkins3• 2 years ago

https://news.ycombinator.com/item?id=35663742

DonHopkins 10 months ago | parent | context | favorite | on: PHP Popularity: Is it decreasing and what to do ab...

That's exactly Jeff Atwood's point, which I quoted above (and will repeat here): "From my perspective, the point of all these "PHP is broken" rants is not just to complain, but to help educate and potentially warn off new coders starting new codebases. Some fine, even historic work has been done in PHP despite the madness, unquestionably. But now we need to work together to fix what is broken. The best way to fix the PHP problem at this point is to make the alternatives so outstanding that the choice of the better hammer becomes obvious." -Jeff Atwood

https://blog.codinghorror.com/the-php-singularity/

Leaning hard into the IDE (or ChatGPT these days) because your language design is flawed is a hella/totally stereotypical "West Coast" thing to do, as described in "Evolution of Lisp", "Worse is Better", and "History of T", and exemplified by Interlisp and Warren Teitelman's "pervasive philosophy of user interface design" and implementation of "DWIM".

https://en.wikipedia.org/wiki/DWIM

https://www.techfak.uni-bielefeld.de/~joern/jargon/DWIM.HTML

https://escholarship.org/uc/item/6492j904

If your language isn't terribly designed, then your IDE doesn't have to be such a complex non-deterministic Rube Goldberg machine, papering over the languages flaws, haphazardly guessing about your intent, "yelling at you" all the time about potential foot-guns and misunderstandings.

As you might guess, I'm firmly in the "East Coast" MacLisp / Emacs camp, because that's what I learned to program in the 80's. I can't stand most IDEs (except for the original Lisp Machines, and Emacs of course), especially when they keep popping up hyperactive completion menus that steal the keyboard input focus and spew paragraphs of unexpected boilerplate diarrhea into my buffer whenever I dare to type ahead quickly and hit return.

But my point is that you can have and should demand the best of both coasts, unless you start off with a Shitty West Coast Programming Language or a Shitty East Coast IDE.

(Of course those philosophies are no longer bound to the geographical coasts they're named after, that's just how those papers describe their origin.)

Jeff Atwood's point an my point is that we should demand both well designed programming languages AND well designed IDEs, not make excuses for and paper over the flaws of shitty ones.

There are historic existence proofs, like Lisp Machines and Smalltalk, and we should be able to do much better now, instead of getting stuck in the past with Lisp or PHP.

I mentioned the East/West Coast dichotomy in the discussion about the conversation between Guido, James, Anders and Larry:

https://news.ycombinator.com/item?id=19568860

DonHopkins on April 4, 2019 | parent | context | favorite | on: A Conversation with Language Creators: Guido, Jame...
Anders Hejlsberg also made the point that types are documentation. Programming language design is user interface design because programmers are programming language users.
"East Coast" MacLisp tended to solve problems at a linguistic level that you could hack with text editors like Emacs, while "West Cost" Interlisp-D tended to solve the same problems with tooling like WYSIWYG DWIM IDEs.
But if you start with a well designed linguistically sound language (Perl, PHP and C++ need not apply), then your IDE doesn't need to waste so much of its energy and complexity and coherence on papering over problems and making up for the deficiencies of the programming language design. (Like debugging mish-mashes of C++ templates and macros in header files!)

More discussion of West Coast -vs- East Coast language design:

Evolution of Lisp:

https://redirect.cs.umbc.edu/courses/331/papers/Evolution-of...

Worse is Better:

https://dreamsongs.com/WorseIsBetter.html

History of T:

http://www.paulgraham.com/thist.html?viewfullsite=1

The Interlisp Programming Environment

http://www.ics.uci.edu/~andre/ics228s2006/teitelmanmasinter....

https://news.ycombinator.com/item?id=5966328

https://news.ycombinator.com/item?id=5966399

gruseom on June 30, 2013 | parent | context | favorite | on: The Interlisp Programming Environment (1981) [pdf]
Interlisp was the so-called "west coast" Lisp that emphasized an interactive programming environment and in retrospect looks more like a hybrid between Smalltalk and Lisp than modern Lisp implementations. It was developed at PARC for a while. I don't know if there was cross-pollination between Interlisp and Smalltalk or if the similarity was a zeitgeist thing.
This article talks about the design values of the system and communicates the flavour of what a Smalltalkish Lisp would have been like.
As someone who's only read about this, I'd be interested in hearing from people who actually used it.

shrubble5• 2 years ago

Don, have you played around with the Interlisp.org "try Medley in your browser" or the downloadable version? And if so, what did you think of it?

DonHopkins3• 2 years ago

No, I have't had a chance to check that out. Thanks for the tip!

anonzzzies• 2 years ago

These are really nice, I have been playing with them lately. They work really well.

anthk3• 2 years ago

On programming, I like awk (more gawk because of sockets and nice I/O), and editing with just ed/vis (vis is like vi but with syntax highlighting and Sam's Structural Regexen) and entr to monitor the files at read/write so it spawns a make subprocess.

Make, not gmake. Proper guide to simple makefiles

      git://bitreich.org/english_knight

I know awk it's kinda the opposite to MIT/GNU/Emacs/Lisp, but with awka I can compile it nicely into C to do lots of prototypes on math calculations and plots with Gnuplot. This is the Unix philosophy done right, albeit 9front/plan9 takes it further with Acme and I/O to any device as a file and from any language.

Emacs and Elisp (and Common Lisp as the 'biggie' language) would be nice if Emacs didn't hang on I/O (hello gnus, back in the day I did tweak a config file so it read slrnpull's Usnet spool so it lasted 5 minutes on parsing and not 45), I'd truly use it, as it has lots of nice modules inline help and discoverability.

But with the Unix philosophy first I write down schematics with paper and pen, I protoype stuff with awk (awk does far more than reading lines, with the BEGIN clause you can even write a Tetris without touching a file), and then, awka -> C. People doesn't know, but you can do a lot with just tcc, a full busybox set, gnuplot (no wx, no qt, just X11), and netcat if you don't want to use GNU awk for sockets.

Also, call me weird/odd, but a lot could be done with gopher, simple CGI with awk and an sqlite database. I know some -not small at all- book store in Spain using just AS400/DOS terminals to search between a networked array of machines with books ISBN's, availabilty and so on and the bookstore people looked up for books at light speeds. Imagine that today with the ubiquitous Java EE stack, or worse, Electron and bloated VS Code IDE's to generate a very subpar tool.

pfdietz• 2 years ago

"Interlisp is a very large software system and large software systems are not easy to construct. Interlisp-D has on the order of 17,000 lines of Lisp code, 6,000 lines of Bcpl, and 4,000 lines of microcode."

from Interlisp-D: Overview and Status

https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&d...

Ah, the days when a "very large software system" had 27K lines of code. :)

lispm3• 2 years ago

They also had "relatively large main memories" ;-) "(~1 megabyte) and virtual address spaces (4-16M 16 bit words)". I would guess the CPU speed would be rated less than 1 MIPS.

crest• 2 years ago

Even today 17,000 lines of Lisp can be dauntingly complex ;-).

anthk3• 2 years ago

And 100 if you use QuickLisp and some modules.

kragen6• 2 years ago

this is really enjoyable. i'd never seen a d-machine in video before, and i had no idea masterscope could do automated refactoring on interlisp code in 01981

there's something very hollywood-like about 01960s/01970s ai natural language parsing interfaces

unsurprisingly the cadr looks very similar to the symbolics genera environment i've seen more of

zilti• 2 years ago

You missed a leading "1" in your year numbers

kragen6• 2 years ago

it's kind of surprising that the cadr took 10 seconds (at 43'56") to compile

    (defun fact (n)
      (cond ((< n 2) 1)
            (t (* n (fact (- n 1))))))

does anyone know why it's so slow? maybe it had to do a full garbage collection?

amszmidt4• 2 years ago

A full GC took several tens of minutes… it was considered a coffee break type of thing.

It is hard to say why it took that long to compile from the video, I’m guessing some network access to something …

lispm3• 2 years ago

Paging would be another option. Virtual memory was slow and the GC integration with virtual memory wasn't very sophisticated at that time. Also main memory was probably tiny.

kragen6• 2 years ago

thanks for the explanation! i'm sorry i upset you previously by saying that stallman had often been unkind to others

Interlisp-D and MIT CADR Lisp Machine demos for IJCAI Conference (1981)

Related Stories