Information about Lisp Machine

Lisp machines were general-purpose computers designed (usually through hardware support) to efficiently run Lisp as their main software language. In a sense, they were the first commercial single-user workstations. Despite being modest in number (perhaps 7000 units total as of 1988^[1]), many now-commonplace technologies (including effective garbage collection, laser printing, windowing systems, computer mice, high-resolution bit-mapped graphics, computer graphic rendering and a number of networking innovations) were commercially pioneered on Lisp machines.

History

Historical context

Artificial intelligence (AI) computer programs of the 1960s and 1970s intrinsically required what was then considered a huge amount of computer power, as measured in processor time and memory space. The power requirements of AI research were exacerbated by the Lisp symbolic programming language, when commercial hardware was designed and optimized for assembler- and Fortran-like programming languages. At first, the cost of such computer hardware meant that it had to be shared among many users. But as integrated circuit technology shrank the size and cost of computers in the 1960s and early 1970s, and the memory requirements of AI programs started to exceed the address space of the most common research computer, the DEC PDP-10, researchers considered a new approach: a computer designed specifically to develop and run large artificial intelligence programs, and tailored to the semantics of the Lisp programming language. To keep the operating system (relatively) simple, these machines would not be shared, but would be dedicated to a single user.

Initial development

In 1973, Richard Greenblatt and Thomas Knight, programmers at MIT's AI Lab, started what would become the MIT Lisp Machine Project when they first began building a computer hardwired to run certain basic Lisp operations, rather than run them in software, in a 24-bit tagged architecture. The machine also did incremental (or "Arena") garbage collecting. More specifically, since Lisp variables are typed at runtime rather than compile time, a simple addition of two variables could take 5 times as long on conventional hardware, due to test and branch instructions. Lisp Machines ran the tests in parallel with the more conventional single instruction additions. If the simultaneous tests failed, then the result was discarded and recomputed; this meant in many cases an increase by several factors. This simultaneous checking approach was used as well in testing the bounds of arrays when referenced, and other memory management necessities (not merely garbage collection or arrays). Type checking was further improved and automated when the conventional byte word of 32-bits was lengthened to 36-bits for Symbolics 3600-model Lisp machines^[2] and eventually to 40-bits or more (usually, the excess bits not accounted for by the following were used for error-correcting codes). The first group of extra bits were used to hold type data, and the remaining bits were used to implement CDR coding (wherein the usual linked list elements are compressed to occupy roughly half the space), aiding garbage collection by reportedly an order of magnitude. A further improvement was two microcode instructions which specifically supported Lisp functions, reducing the cost of calling a function to (in some Symbolics implementations) as little as 20 clock cycles.

The first machine was called the CONS machine (named after the list construction operator cons in Lisp. Often it was affectionately referred to as the "Knight machine", perhaps since Knight wrote his master's thesis on the subject); it was extremely well-received. It was subsequently improved into a version called CADR (a pun; in Lisp, the cadr function, which returns the second element of a list, is pronounced "kay'-der" or "kah'-der", as some pronounce the word "cadre") which was based on essentially the same architecture. About 25 of what were essentially prototype CADRs were sold within and outwith MIT for ~$50,000; it quickly became the favorite machine for hacking- many of the most favored software tools were quickly ported to it (e.g. Emacs was ported from ITS in 1975). It was so well received at an AI conference held at MIT in 1978 that DARPA began funding its development.

A fork

In 1979, Russell Noftsker, convinced that Lisp machines had a bright future commercially due to the strength of the Lisp language and the enabling factor of hardware acceleration, made Greenblatt a proposal: they would take the technology commercial. In a counter-intuitive move for an AI Lab hacker, Greenblatt acquiesced, hoping perhaps that he could recreate the informal and productive atmosphere of the Lab in a real business, a bit like Apple Computer. These ideas and hopes were considerably different from the ones Noftsker held. The two negotiated at length, but neither would compromise. As the proposed company could only be a success with the full and undivided assistance of the AI Lab hackers as a group, Noftsker and Greenblatt decided that the fate of the enterprise was up to them, and so the choice should be left to the hackers.

The ensuing discussions of the choice rent the lab into two factions. In February, 1979, matters came to a head. The hackers sided with Noftsker, believing that a commercial venture fund-backed company had a better chance of surviving and commercializing Lisp Machines than Greenblatt's proposed self-sustaining start-up. Greenblatt had lost the battle.

It was at this juncture, with Symbolics, Noftsker's enterprise, slowly coming together (while he was paying them a salary, he didn't actually have a building or any equipment for the hackers to work on, so he bargained with Patrick Winston that in exchange for allowing Symbolics' staff to keep working out of MIT, Symbolics would let MIT use internally and freely all the software Symbolics developed), and a disgruntled and inactive Greenblatt, that a consultant from CDC, who was trying to put together a natural language computer application with a group of West-coast hackers, came to Greenblatt, seeking a Lisp machine for his group to work with, about eight months after the disastrous conference with Noftsker. Greenblatt had decided to start his own rival Lisp machine company, but he had done nothing. The consultant, Alexander Jacobson, decided that the only way Greenblatt was going to actually start his company and build the Lisp machines that Jacobson desperately needed was if Jacobson pushed and otherwise helped Greenblatt launch his company. Jacobson pulled together business plans, a board, a partner for Greenblatt (one F. Stephen Wyle). The newfound company was named LISP Machine, Inc. (LMI), and was funded by CDC orders, via Jacobson.

Around this time Symbolics (Noftsker's company) began operations — it had been hindered by Noftsker's promise to give Greenblatt a year's head start, and by severe delays in procuring venture capital. Symbolics still had the major advantage that while 3 or 4 of the AI Lab hackers had gone to work for Greenblatt, a solid 14 other hackers had signed onto Symbolics. There were two AI Lab people who did not get hired by either: Richard Stallman and Marvin Minsky.



Regardless, after a series of internal battles, Symbolics did get off the ground in 1980/1981, selling the CADR as the LM-2, while Lisp Machines, Inc. sold it as the LMI-CADR. Symbolics did not intend to produce many LM-2s, since the 3600 family of Lisp machines was supposed to ship quickly, but the 3600s were repeatedly delayed, and Symbolics ended up producing ~100 LM-2s, each of which sold for $70,000. Both companies developed second-generation products based on the CADR: the Symbolics 3600 and the LMI-LAMBDA (of which LMI managed to sell ~200). The 3600, which shipped a year late, expanded on the CADR by widening the machine word to 36-bits, expanding the address space to 28-bits^[3], and adding hardware to accelerate certain common functions that were implemented in microcode on the CADR. The LMI-LAMBDA, which came out a year after the 3600, in 1983, was compatible with the CADR (it could run CADR microcode), but there were hardware differences. Texas Instruments (TI) joined the fray when it licensed the LMI-LAMBDA design and produced its own variant, the TI Explorer.

Symbolics continued to develop the 3600 family and its operating system, Genera, and produced the Ivory, a VLSI implementation of the Symbolics architecture. Starting in 1987, several machines based on the Ivory processor were developed: boards for Suns and Macs, stand-alone workstations and even embedded systems (I-Machine Custom LSI, 32 bit address, Symbolics XL-400, UX-400, MacIvory II; in 1989 available platforms were Symbolics XL-1200, MacIvory III, UX-1200, Zora, NXP1000 "pizza box"). Texas Instruments shrunk the Explorer into silicon as the MicroExplorer. LMI abandoned the CADR architecture and developed its own K-Machine [1], but LMI went bankrupt before the machine could be brought to market.

These machines had hardware support for various primitive Lisp operations (data type testing, CDR coding) and also hardware support for incremental garbage collection. They ran large Lisp programs very efficiently. The Symbolics machine was actually competitive against many commercial super mini computers, but it was never adapted for conventional purposes. Though the Symbolics Lisp Machines were also sold to some non-AI markets like computer graphics, modeling and animation.

The MIT-derived Lisp machines ran a Lisp dialect called ZetaLisp, descended from MIT's Maclisp. The operating systems were written from the ground up in Lisp, often using object-oriented extensions. Later these Lisp machines also supported various versions of Common Lisp (with Flavors, New Flavors and CLOS).

BBN developed its own Lisp Machine, called Jericho, which ran a version of Interlisp. It was never marketed; frustrated, the entire AI group resigned, and were hired primarily by Xerox. So, Xerox PARC had, simultaneous with Greenblatt's own development over at MIT, developed their own Lisp machines which were designed to run InterLisp (and later Common Lisp) as well as other languages such as Smalltalk, but they failed to enter the market, and found themselves a distant third behind LMI and Symbolics. These included the Xerox 1100, aka "Dolphin" (1979); the Xerox 1132, aka "Dorado"; the Xerox 1108, aka "Dandelion" (1981); and the Xerox 1109, aka "Dandetiger"; and the Xerox 1186/6085, aka "Daybreak". The Xerox machines were a commercial failure, but they did influence the creation of Apple Computer's Macintosh. The operating system of the Xerox Lisp Machines has also been ported to a virtual machine and is available for several platforms as a product called "Medley". The Xerox Lisp Machine was well known for its advanced development environment, for its early graphical user interface and for novel applications like NoteCards (one of the first Hypertext applications).

A UK company, Racal-Norsk, attempted to repurpose Norsk Data superminis as microcoded Lisp Machines, running Symbolics' ZetaLisp software.

There were several attempts by Japanese manufacturers to enter the Lisp Machine market, including the Fujitsu Facom-alpha mainframe co-processor (which was actually marketed as early as 1978), and several university research efforts that produced working prototypes as part of the Fifth Generation.

With the onset of the "AI Winter" and the early beginnings of the "PC revolution" (which would gather steam and sweep away the minicomputer and workstation manufacturers), cheaper desktop PCs soon were able to run Lisp programs even faster than Lisp machines, without the use of special purpose hardware. Their high profit margin hardware business eliminated, most Lisp Machine manufacturers went out of business by the early 90s, leaving only software based companies like Lucid Inc. or hardware manufacturers who switched to software and services to avoid the crash. Besides Xerox, Symbolics is the only Lisp Machine company still operating today, selling the Open Genera Lisp Machine software environment as well as the Macsyma computer algebra system.

In the late 90s, there were plans by Sun Microsystems and other companies to build language-specific computers for Java, similar in concept and execution to the Lisp machines.

See also

• ICAD - (Example of "Knowledge based engineering" software originally developed on a Lisp machine that was useful enough to be then ported via Common Lisp to Unix.)
• Orphaned Technology

References

1. "[https://dspace.mit.edu/handle/1721.1/5751 LISP Machine Progress Report]", Alan Bawden, Richard Greenblatt, Jack Holloway, Thomas Knight, David Moon, Daniel Weinreb, AI Lab memos, AI-444, 1977.
2. "CADR", Thomas Knight, David A. Moon, Jack Holloway, Guy L. Steele. AI Lab memos, AIM-528, 1979.
3. "Design of LISP-based Processors, or SCHEME: A Dielectric LISP, or Finite Memories Considered Harmful, or LAMBDA: The Ultimate Opcode", Guy Lewis Steele, Gerald Jay Sussman, AI Lab memo, AIM-514, 1979
4. David A. Moon. [https://dspace.mit.edu/handle/1721.1/6353 Chaosnet]. A.I. Memo 628, Massachusetts Institute of Technology Artificial Intelligence Laboratory, June 1981.
5. "Implementation of a List Processing Machine". Tom Knight, Master's thesis.
6. Lisp Machine manual, 6th ed. Richard Stallman, Daniel Weinreb, David Moon. 1984.
7. "Anatomy of a LISP Machine", Paul Graham, AI Expert, December 1988

External links

• Symbolics
• Medley
• Bitsavers, PDF documents
• LMI documentation
• MIT CONS documentation
• MIT CADR documentation
• Symbolics documentation
• TI MicroExplorer documentation
• TI Explorer documentation
• Xerox Interlisp documentation
• Lisp Machine Manual, Chinual
• "The Lisp Machine manual, 4th Edition, July 1981"
• "The Lisp Machine manual, 6th Edition, HTML/XSL version"
• "The Lisp Machine manual"
• "Lisp Machine Inc. K-machine: The Deffenbaugh, Marshall, Powell, Willison architecture as remembered by Joe Marshall"
• "My Lisp Experiences and the Development of GNU Emacs" - (a transcript of a speech Richard Stallman gave about Emacs, Lisp, and Lisp machines)
• "If It Works, It's Not AI: A Commercial Look at Artificial Intelligence startups"
• "Symbolics, Inc.: A failure of Heterogenous engineering" - (PDF)
• CADR simulation
• L-machine simulation
• CADR LISP Machine source code released by MIT (Oct 3 2005)
• The Explorer III Project - (A project to "develop a portable software emulator of the TI Explorer II Lisp machine.")
• Jaap Weel's Lisp Machine Webpage - (A collection of links and locally stored documents appertaining to all manner of Lisp machines)
• "A Few Things I Know About LISP Machines" - (Another collection of links, but mostly a discussion of purchasing Lisp machines)
• Ralf Möller's Symbolics Lisp Machine Museum
• A page of screenshots of Genera
• Rainer Joswig's web page with Lisp Machine videos and screen shots
• "Genera Concepts" - (Web copy of Symbolic's introduction to Genera)
• Vintage Computer Festival pictures of some Lisp Machines, one running Genera
• Picture of a partially disassembled Symbolics 3640
• LISPMACHINE.NET - Lisp Books and Information
• Lisp machines timeline -(a timeline of Symbolics' and others' Lisp machines)
• http://www.cliki.net/Zeta-C