Ergonomics of the Symbolics Lisp Machine
lispm.de
lispm.de
If you're interested, here are some pointers to relevant resources (snap4.tar.gz image works as advertised):
http://www.advogato.org/person/johnw/diary/12.html
http://www.cliki.net/VLM_on_Linux
http://libarynth.org/vlm_on_linux
The opengenera tar-ball can be found in the intertubes.
Tip: Use Ubuntu 7.04 x86-64 to save you some trouble. I don't know what is the most recent distro that works but 10.10 doesn't. You get a blank window because recent X servers are missing something. Before proceeding with the installation, complete the Ubuntu image with relevant archive server URLs to be able to apt-get with ease.
I think multimedia computing, as introduced by Amiga did more for AI, speaking in terms of games, than the Lisp Machines. I do think the jack of all trades approach is useful for sharing data across computers and professions.
It's sad to see the demise of the professional multimedia computer to tablets and tablet-laptops.
To compare it to Apple ][ is a bit too stretched. Lisp machines were developer machines. Machines for professionals in computing technology. We don't have that today. For example, what is the equivalent package or distro that transforms your PC in a "developer machine". You don't have anything like that. All you can do is stitch together some emacs/vi/gdb whatever and search some blogs when you're stuck. And beyond that you are not able to go and fix some IDE bugs _live_.
Today we're missing a machine for professional programmer.
There are some enlightening comments from Kent Pitman on comp.lang.lisp, which give a sense of what kinds of features the Lisp machines provided to developers, and why they still haven't been matched by contemporary systems:
https://groups.google.com/d/msg/comp.lang.lisp/XpvUwF2xKbk/o...
https://groups.google.com/d/msg/comp.lang.lisp/XpvUwF2xKbk/X...
EDITED to add:
Oh, I guess David Schmidt owns all of it now [0]: Symbolics is currently a privately held company which acquired the assets and intellectual property of the old public company called Symbolics, Inc.
"The problem is that the Symbolics IP is now owned by John Mallery; he has stated he has plans for making it available but so far (several years) has not yet done so. Until he does so, only two groups (that I am aware of) have access through prior contracts with the previous owner of the IP, namely MIT (and anyone officially associated with it) and customers of the Symbolics maintenance business (and independent company) run by David K. Schmidt."
http://www.youtube.com/comment?lc=iMqNHkTp2Oy525xIKnQM_vOmFV...
Be warned, I'm still learning how to use Genera, so we'd be learning how to use the system together.
(The old, original Tom Knight AI Lab keyboards were even slightly more wonderful; the later Microswitch LispM keyboards never quite equalled the originals in terms of tactilely satisfying feel.)
(For a long while after leaving MIT (ran the MIT-EECS LispM and DEC-20 machines) I used one of the custom-made Lawrence Livermore run of Microswitch keyboards, driving a custom 68K board which turned the up/down events into standard RS-232 for use with standard CRT terminals. I think I still have that keyboard somewhere in the now-long-abandoned kids' play junk.)
cherry stopped in time.
alps lowered standards to fight off bad income.
...good switches help you feel the key and avoid bottom out. i personally like old complex alps, but everyone will like something different.
To deal with bottoming out, using Cherry Blue switches, I've found that these red dampeners work very nicely: http://www.amazon.com/gp/product/B00AZQ3966/ There are also thicker ones that have better stocking: http://www.amazon.com/Cherry-Rubber-O-Ring-Switch-Dampeners/... and the same company has a nice key puller: www.amazon.com/gp/product/B00AZCGF7K/
i bought the same orings (internal, external diameter. hardness) from a hardware store. paid $3.78.
...and you linked to the cheap ones :)
Those giant keyboards, with all their wide special purpose buttons topped with hieroglyphic keycap labels, in combination with the huge screen, three button mouse, and of course all the great software turning on and off the little dots on the screen that you could dive into, explore and modify at will, the printed and online documentation, the networked developer support community, all carefully designed to work together seamlessly regardless of cost, gave you the feeling of being in control of a very heavy, expensive, well built, solid, powerful, luxury automobile, with rich Corinthian leather seats, a high fidelity sound system, cruise and climate control, power steering, windows and seats, a full tank of gas and an empty ashtray, a glove compartment stuffed with AAA maps, about to embark on a long and adventurous journey exploring far away places you've never visited before.
It's hard to capture that kind of multi-sensory ergonometric computational Fahrvergnügen, just running it in an emulator on a MacBook Pro. (As luxurious and well designed as the MBP is, it can't hold a candle to a Lisp Machine.)
Sitting down in front of one of those monsters with a big mug of coffee, an interesting task to work on, a rack of my favorite music on cassette tapes, many hours of free time to hack in the privacy of an air conditioned lab in front of me, and a bean bag chair for naps when I pass out from exhaustion behind me, will always be one of my cherished memories.
Ricardo Montalban couldn't have expressed the luxurious feeling of power and control more eloquently: "I have much more in this small Chrysler than great comfort at a most pleasant price. I have great confidence, for which there can be no price. In Cordova, I have what I need." https://www.youtube.com/watch?v=Vsg97bxuJnc
This reminds me of Smalltalk environment like Pharo. I recently realised that there were so much things in common between Lisp and Smalltalk environments (by Lisp environments I mean what we have today like SLIME+Emacs or LightTable). I also think that LightTable has a huge potential for being a successor of Lisp machines and _really_ integrated development environments.
Genera on the Lisp Machine runs on the metal. It is the process scheduler, it does handle the bus interrupts, it receives the network packets, it writes the bytes to the disk controller, it sets the bits in the graphics card, it writes the sound bytes to audio interface, the network packets are Lisp arrays, ...
There was a proposal from Sun for a Java OS that seemed to me to copy the same split.
It is a pity that all the Ivory papers that were in journals still seem to be behind paywalls.
http://siliconsqueak.org/ seems to be related.
Neither archive.org nor Google Cache have this. Weird.
Video from article: http://vimeo.com/83886950
Image 1: http://i.imgur.com/r62FSfE.jpg
Image 2: http://i.imgur.com/xsxutc3.png
Image 3: http://i.imgur.com/zL9DFbr.png
The things that stood out to me were that a) boy, it was a slow system. Sure vi etc are more spartan, but even back then I'd imagine the were significantly faster than this Lisp machine. b) mouse was clearly the hot new thing, it is used lot more than what I think would be optimal.
It was a system for research of development of advanced software, often with complex GUIs. Symbolics sold for several years into the CAD and 3d-graphics markets.
I'll attempt to explain the deep implications of what the article said about "Everything on the screen is an object, mouse-sensitive and reusable":
There's a legendary story about Gyro hacking away on a Lisp Machine, when he accidentally trashed the function cell of an important primitive like AREF (or something like that -- I can't remember the details -- do you, Scott? Or does Devon just make this stuff up? ;), and that totally crashed the operating system.
It dumped him into a "cold load stream" where he could poke around at the memory image, so he clamored around the display list, a graph of live objects (currently in suspended animation) behind the windows on the screen, and found an instance where the original value of the function pointer had been printed out in hex (which of course was a numeric object that let you click up a menu to change its presentation, etc).
He grabbed the value of the function pointer out of that numeric object, poked it back into the function cell where it belonged, pressed the "Please proceed, Governor" button, and was immediately back up and running where he left off before the crash, like nothing had ever happened!
Here's another example of someone pulling themselves back up by their bootstraps without actually cold rebooting, thanks to the real time help of the networked Lisp Machine user community:
ftp://ftp.ai.sri.com/pub/mailing-lists/slug/900531/msg00339.html
What lisp machine articles often miss is contrast to other related projects.
Complete introspectable systems: How does the experience compare with using Pharo Smalltalk today? Sure, it doesn't provide a kernel, but it's a pretty complete* system that's very reflective and open to modification.
Running a lisp userland: There are Common Lisp replacements for Emacs, CL window managers, and one or two Lisp Machine style GUI libraries (CLIM). However, most Lispers seem to be happy using other WMs and Emacs. Do the CL applications miss something that the Lisp Machine environment provided, or were the alternatives more compelling somehow?
Other Lisp Machines: The MIT CADR is open source and available online[1]. Lisp Machine articles seem to focus on Symbolics software, what is that the CADR lacks? rms allegedly reimplemented many Symbolics features on MIT Lisp machines.
I'm often struck by how many Lisp Machine features have been implemented on other systems (e.g. CLIM, versioned file systems) yet haven't gained many users. There must be stories here.
1: http://www.unlambda.com/cadr/
*: Of the developers I've met, Emacs hackers seem to live in Emacs more than Smalltalkers in their image. For example, there are multiple Emacs twitter packages, but I've not seen any applications (only libraries) for tweeting from inside a Smalltalk image. I'm not sure what this says about the respective environments.
I still hope to be able to run the final version of the LMI software environment on the CADR emulator but haven't had much time to work on it recently.
Genera is a full operating system running directly on Lisp Machine hardware. A CPU which runs a stack machine. The network code goes down to the packets and the Ethernet card driver.
> There are Common Lisp replacements for Emacs, CL window managers, and one or two Lisp Machine style GUI libraries (CLIM).
A few thousand developer years is the difference. Sophistication. Polishing. Applications.
> rms allegedly reimplemented many Symbolics features on MIT Lisp machines.
He didn't. He tried to help LMI, but stopped soon. Symbolics, LMI and then TI developed a lot of more software. Much more.
> I'm often struck by how many Lisp Machine features have been implemented on other systems (e.g. CLIM, versioned file systems) yet haven't gained many users. There must be stories here.
Versioned file systems existed before and after Lisp Machines. For example DEC's VMS had a versioned file system. CLIM was the attempt to develop a portable standardized version of the GUI library of Symbolics. It failed to gain real traction: too different, not very polished, everybody had already a different GUI toolkit, ...
Here is an example of using a high-end Lisp machine application for 3d graphics:
Well, you're in luck! Peter Paine of Abstract Science has (as of 2010) a substantial inventory of Symbolics hardware in deepest, darkest Kent: http://www.asl.dsl.pipex.com/symbolics/
From the website: "Location: 50 miles E.S.E. London UK (1/2 hour from continental port Dover and Channel Tunnel train at Ashford). Served by mainline train (65 minutes from central London) and M2 motorway."
In the fullness of time, long after 1963, 18 bits of 36 bit words totaling 1 MiB of 9 bit bytes was crippling, but that much memory was at the time unimaginable. MIT's proposal some time later to have a full address space of memory built was a big thing, some said it couldn't be done.
Which gets into one big difference between Xerox PARC Altos and their software and UNIX(TM) for the first decade or so: they were seriously constrained by memory. Altos were 16 bit machines, also word addressed, so a total of 128 KiB, although they had a bank switching feature. The bigger PDP-11s had a split Instruction and Data (I&D) feature so that a program could have 64 KiB of code, and due to the MMU, 58 KiB of data and 8 KiB of stack, also for a total of 128 KiB, although you could get fancy with overlays as BSD 2.x did to support TCP/IP.
I believe this resulted in significant differences in software and system design, e.g. part of MIT's going for The Right Thing was using systems with large (for the time) address spaces. Whereas the smaller systems PARC and UNIX systems required more compromises, although occasionally that had good results, e.g. UNIX pipelines and the conventions that developed from them.
A more interesting alternate history for me would be if the folks doing system research had settled on a functional language like Haskell rather than a procedural one like C, what would our APIs look like today. I say that because I suspect that using C as a the language of choice was more influential than the OS of choice.
* Interlisp-D from Xerox were smaller machines, networkd with a server + printer. PARC developed networked collaborative software for them, the first remote GUI was written for Interlisp, the first IMAP client was written for Interlisp-D, ...
* the MIT Lisp Machines were developed with CHAOS, an Ethernet-based protocol. TCP/IP was available early. Many of the TCP/IP protocols were implemented for them (often client and server): chat, terminal, mail, RPC, NFS, X11, DNS, HTTP, remote printing, remote booting, ... They also ran DECNET and some IBM network protocol. Actually the networking code from Symbolics was quite sophisticated in some respects...
BBN (the Internet company at that time) also used a lot of Lisp Machines. They had some distributed remote object networking substrate, which also ran on Lisp Machines.
Lucent had developed an ATM network switch, which first versions were based on multiple embedded Lisp Machine boards for the switching code and another Lisp Machine for the control and administration. They ran all kind of fancy networking code on them in a zero downtime fashion with live software upgrades. They were for example thought as large network and telephony switches.
I preferred the MIT lispm environment better because I grew up with it. For a while I had a job where I had both a dandelion and a 3600 in my office; later I had two 36xx machines, one with a color display.
They were pretty fast for their time. The late, hyper-dynamic window system was probably too heavyweight for its time, especially when later translated over X, but I generally used the simpler base window system because it was faster.
It was the most productive (in terms of amount of useful code generated per unit time) system I have ever used and I still miss it. The Interlisp D, though quite different to use (and in some ways better), is a close second.
They were not used for networking research, AFAIK, but Lisp Machines were definitely very well networked, speaking many protocols which soon came to include IP and TCP (though they started out with MIT's CHAOSnet). I was using Lisp Machines (both Symbolics and TI) networked with Sun 3s in the mid-to-late 1980s, and they definitely interoperated.
But I think that was a few years later than the networking research you're referring to, that created the Internet protocols.
The tradeoffs may or may not have been worth it, but there seemed to be an obsession with doing it Right rather than doing it cheap and quick. Even today it would be financially beneficial to buy a $70k workstation over a $2k workstation for a developer if there was a significant boost to productivity; each developer costs you well over $70k per year, and you can't double your productivity by hiring twice as many developers.
What I wonder is why for 20+ years there was no successful free software project that would mimic the Lisp Machines.
And something like Gopher.
Or maybe another thing like UNIX would've replaced Lisp Machines quickly.
I would imagine that intelligent people would have worked at getting the same problems solved in a different form.
[edit] Instruction Sets from Intel, IBM, MIPS, Motorola would have been really different. Personally, I wanted the Forth machines to rule :)
Here is a video which shows it running on a TI Micro Explorer, a Nubus Board in a Mac II.
ftp://ftp.ai.sri.com/pub/mailing-lists/slug/930331/msg00117.html
$18,700 in 1992. The last hardware Lisp Machine type.
Many years later I got mine for free from a telco equipment manufacturer.
If you buy into the sales pitch, highly trained teams of developers would be properly outfitted with workstations well-suited to roll their own crypto, for development purposes, and then easily test against a wide array of complex scenarios.
(Although the C spec is carefully written to allow C-on-Lisp - e.g. by making it illegal to compare pointers not pointing to the same array, allowing a C-"object"-per-Lisp-object implementation - real C code tends to make assumptions.)
I've used TeX and the original MIT X11 server on a Lisp Machine.
One customer said they'd run millions of lines of code through it.
Good to hear that.
Actually, it turned out -- though I never managed to communicate this to potential users -- Zeta-C and Symbolics C served different use cases. Symbolics C was best for porting entire C programs; Zeta-C was best if you had a library written in C and wanted to call it from Lisp.
The only ones I can think of are languages like C++ or Rust. Perhaps emacs and vi...
Wow, what a quote. Now can we repeatedly beat that into management's head.
It is too complex for novices, with too many keys. And not optimal to the initiated, as key combinations are much more efficient.
anyone with the slightest ergonomic knowledge cringe just by glancing at those things.
2. i never said the ibm pc keyboard was any god either :)
The big issue is that the IBM layout is Ctrl-Alt, whereas the Lisp Machine was [too many other "bucky bits"]-Meta-Ctrl. Since I learned EMACS with the latter layout, for many years I just remapped those keys on other systems.