The Register published this fascinating article. It's a reread of the history of computing with a focus on Lisp, Lisp Machines, and early workstations:
@amoroso Liam can't help himself when it comes to fancy hardware.
"Now that is radical: Using the same, very high-level, language for both the OS and the apps. It was feasible because Dylan is built as a layer on top of one of the oldest programming languages that's still in active use, Lisp."
That's also been done with C# (Singularity), Oberon, and Java, and certainly some I've missed. So I don't think using Lisp means much.
"Smalltalk machines ran on relatively normal processors. Smalltalk is all about objects, and you can't really handle objects at hardware level."
Xerox interpreted Smalltalk bytecode in microcode, so you kinda can. The Alto also doesn't seem relatively normal, but this happens to be unnecessary for performance c.f. Smalltalk on a RISC. (Also see Intel iAPX 432, i960 and Rational R1000 for objects at the hardware level)
Interlisp ran on the same hardware, so great self-own too.
"But Lisp machines ran on dedicated chips, and this is where stuff gets real. As in, the stuff that hits the fan."
What does that matter? (Again Xerox machines were also lots of through hole components at the time, AIUI)
"They had a pervasive model of data, all the way down the stack. In Smalltalk, everything is objects. In Lisp, everything is lists. What the Unix model offers by comparison is weak stuff: Everything is a file."
Certainly not - atoms are not lists. More damning is that Unix is stratified too.
@amoroso lisp machines are so much fun to play with, and they’re absolute treasure troves of interesting computing archeology artifacts! I mostly fuck with MIT and LMI machines since symbolics stuff is in a bad place in terms of copyright, but check out https://youtu.be/V4HXPJtym2Q for some cool graphics demos done on a symbolics machine. see also https://tumbleweed.nu/lm-3/ for some ongoing work to emulate and preserve MIT lisp machines
@amoroso it’s hard to see from a video, but they’re also very cozy development environments. one thing I want to work on is making these machines more accessible — most of them are incomplete without a supporting network and a mainframe (to provide access to files, configure various site-specific UI things, etc), but it’s reasonably easy to make a reproducible one-shot package that fires up everything in one go. that way, more people can try lisp machines for themselves.
@amoroso It's a popular type of rose-tinted glasses, and the Unix-Haters definitely had some valid complaints about the rough edges and sharp corners of the Unix workstations of the era. But this misses two things:
Even back then, the Unix systems ran their LISP code something like thirty times faster than the purpose-built hardware.
Their complaints about stability sound a lot like Unix/Linux nerds mocking Windows in 1996. Both complaints were outdated, after time was put into stability.
Watch someone demo a running Symbolics machine from the 80s, sometime. It's a massive pile of fans blowing over boards covered in ULA/PLA glue, and the GUI draws at something like one frame every two seconds.
There's a talk I used to clip, by B🤬b M🤬rtin, before he let the mask slip and showed what he really was. He recounted a story where Ward Cunningham, one of the original Smalltalk bigwigs, was asked at a conference what made it fail. His answer was a summary of all of the problems with a live-editing environment without a model of source files, or the inability to reproduce or share software without sending over your whole environment, or the fast-and-loose attitude toward data types:
> "It was just too easy to make a mess."
This also holds true for Lisp Machines. They let you shoot yourself in the gun, and people did, and then you had a million-dollar paperweight until Genius could be applied to right the ship and raise it from the sea floor.
One thing the move to Unix brought was reproducibility and stability. And for all the hacky project that Unix itself was in the BSD era, the Lisp payload environments were like little containers that you could stab like a virtual machine. Yeah, people had to go from GUIs back to serial terminals, but they could edit code from a PC at home and they could afford for more than one or two people to use LISP at a time. And hey, your code actually finished before the heat death of the universe!
Add comment