en.wikipedia.org, 2022-09-24 | Main page
Saved from web.archive.org, with Lynx.
   #alternate Edit this page Wikipedia (en)

Lisp machine

   From Wikipedia, the free encyclopedia
   (Redirected from Lisp Machine)
   Jump to navigation Jump to search
   Computer specialized in running Lisp
   This article is about the type of computer. For the company, see Lisp

   A Knight machine preserved in the MIT Museum

   Lisp machines are general-purpose computers designed to efficiently run
   Lisp as their main software and programming language, usually via
   hardware support. They are an example of a high-level language computer
   architecture, and in a sense, they were the first commercial
   single-user workstations. Despite being modest in number (perhaps 7,000
   units total as of 1988^[1]) Lisp machines commercially pioneered many
   now-commonplace technologies, including effective garbage collection,
   laser printing, windowing systems, computer mice, high-resolution
   bit-mapped raster graphics, computer graphic rendering, and networking
   innovations such as Chaosnet.^[2] Several firms built and sold Lisp
   machines in the 1980s: Symbolics (3600, 3640, XL1200, MacIvory, and
   other models), Lisp Machines Incorporated (LMI Lambda), Texas
   Instruments (Explorer, MicroExplorer), and Xerox (Interlisp-D
   workstations). The operating systems were written in Lisp Machine Lisp,
   Interlisp (Xerox), and later partly in Common Lisp.
   Symbolics 3640 Lisp machine
   [ ]


     * 1 History
          + 1.1 Historical context
          + 1.2 Initial development
          + 1.3 Commercializing MIT Lisp machine technology
          + 1.4 Interlisp, BBN, and Xerox
          + 1.5 Integrated Inference Machines
          + 1.6 Developments of Lisp machines outside the United States
          + 1.7 End of the Lisp machines
          + 1.8 Legacy
          + 1.9 Applications
     * 2 Technical overview
     * 3 See also
     * 4 References
     * 5 External links


Historical context[edit]

   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 assembly- and Fortran-like programming languages. At
   first, the cost of such computer hardware meant that it had to be
   shared among many users. As integrated circuit technology shrank the
   size and cost of computers in the 1960s and early 1970s, and the memory
   needs of AI programs began to exceed the address space of the most
   common research computer, the Digital Equipment Corporation (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 language. To keep the
   operating system (relatively) simple, these machines would not be
   shared, but would be dedicated to single users.^[citation needed]

Initial development[edit]

   In 1973, Richard Greenblatt and Thomas Knight, programmers at
   Massachusetts Institute of Technology (MIT) Artificial Intelligence
   Laboratory (AI Lab), began 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 collection.^[citation needed] More specifically, since Lisp
   variables are typed at runtime rather than compile time, a simple
   addition of two variables could take five 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 a speed 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^[3] 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, making the machine a tagged architecture, 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 as
   little as 20 clock cycles, in some Symbolics implementations.

   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.^[citation needed] It was subsequently improved into a version
   called CADR (a pun; in Lisp, the cadr function, which returns the
   second item of a list, is pronounced /|keI.d@r/ or /|kA.d@r/, 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 without 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^[disputed - discuss]). It was so well received at an AI conference
   held at MIT in 1978 that Defense Advanced Research Projects Agency
   (DARPA) began funding its development.

Commercializing MIT Lisp machine technology[edit]

   This section possibly contains original research. Please improve it by
   verifying the claims made and adding inline citations. Statements
   consisting only of original research should be removed. (June 2021)
   (Learn how and when to remove this template message)
   Symbolics 3620 (left) and LMI Lambda Lisp machines

   In 1979, Russell Noftsker, being convinced that Lisp machines had a
   bright commercial future due to the strength of the Lisp language and
   the enabling factor of hardware acceleration, proposed to Greenblatt
   that they commercialize the technology.^[citation needed] 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. These ideas and goals were
   considerably different from those of Noftsker. The two negotiated at
   length, but neither would compromise. As the proposed firm could
   succeed only 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

   The ensuing discussions of the choice divided 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 firm had
   a better chance of surviving and commercializing Lisp machines than
   Greenblatt's proposed self-sustaining start-up. Greenblatt lost the

   It was at this juncture that Symbolics, Noftsker's enterprise, slowly
   came together. While Noftsker was paying his staff a salary, he had no
   building or any equipment for the hackers to work on. 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. A consultant from CDC, who was
   trying to put together a natural language computer application with a
   group of West-coast programmers, 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 firm, but he had done nothing. The
   consultant, Alexander Jacobson, decided that the only way Greenblatt
   was going to start the firm and build the Lisp machines that Jacobson
   desperately needed was if Jacobson pushed and otherwise helped
   Greenblatt launch the firm. Jacobson pulled together business plans, a
   board, a partner for Greenblatt (one F. Stephen Wyle). The newfound
   firm was named LISP Machine, Inc. (LMI), and was funded by CDC orders,
   via Jacobson.

   Around this time Symbolics (Noftsker's firm) began operating. 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. Two AI Lab people were not hired by either: Richard
   Stallman and Marvin Minsky. Stallman, however, blamed Symbolics for the
   decline of the hacker community that had centered around the AI lab.
   For two years, from 1982 to the end of 1983, Stallman worked by himself
   to clone the output of the Symbolics programmers, with the aim of
   preventing them from gaining a monopoly on the lab's computers.^[4]

   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
   firms 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,^[5] 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 hardware differences existed. Texas
   Instruments (TI) joined the fray when it licensed the LMI-LAMBDA design
   and produced its own variant, the TI Explorer. Some of the LMI-LAMBDAs
   and the TI Explorer were dual systems with both a Lisp and a Unix
   processor. TI also developed a 32-bit microprocessor version of its
   Lisp CPU for the TI Explorer. This Lisp chip also was used for the
   MicroExplorer - a NuBus board for the Apple Macintosh II (NuBus was
   initially developed at MIT for use in Lisp machines).

   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 shrank the Explorer into silicon as the
   MicroExplorer which was offered as a card for the Apple Mac II. LMI
   abandoned the CADR architecture and developed its own K-Machine,^[6]
   but LMI went bankrupt before the machine could be brought to market.
   Before its demise, LMI was working on a distributed system for the
   LAMBDA using Moby space.^[7]

   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 competitive against many
   commercial super minicomputers, but was never adapted for conventional
   purposes. 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 named Lisp Machine
   Lisp, 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 Common Lisp Object System (CLOS)).

Interlisp, BBN, and Xerox[edit]

   Bolt, Beranek and Newman (BBN) developed its own Lisp machine, named
   Jericho,^[8] which ran a version of Interlisp. It was never marketed.
   Frustrated, the whole AI group resigned, and were hired mostly by
   Xerox. So, Xerox Palo Alto Research Center had, simultaneously with
   Greenblatt's own development at MIT, developed their own Lisp machines
   which were designed to run InterLisp (and later Common Lisp). The same
   hardware was used with different software also as Smalltalk machines
   and as the Xerox Star office system. These included the Xerox 1100,
   Dolphin (1979); the Xerox 1132, Dorado; the Xerox 1108, Dandelion
   (1981); the Xerox 1109, Dandetiger; and the Xerox 1186/6085, Daybreak.
   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
   named Medley. The Xerox machine was well known for its advanced
   development environment (InterLisp-D), the ROOMS window manager, for
   its early graphical user interface and for novel applications like
   NoteCards (one of the first hypertext applications).

   Xerox also worked on a Lisp machine based on reduced instruction set
   computing (RISC), using the 'Xerox Common Lisp Processor' and planned
   to bring it to market by 1987,^[9] which did not occur.

Integrated Inference Machines[edit]

   In the mid-1980s, Integrated Inference Machines (IIM) built prototypes
   of Lisp machines named Inferstar.^[10]

Developments of Lisp machines outside the United States[edit]

   In 1984-85 a UK firm, Racal-Norsk, a joint subsidiary of Racal and
   Norsk Data, attempted to repurpose Norsk Data's ND-500 supermini as a
   microcoded Lisp machine, running CADR software: the Knowledge
   Processing System (KPS).^[11]

   There were several attempts by Japanese manufacturers to enter the Lisp
   machine market: the Fujitsu Facom-alpha^[12] mainframe co-processor,
   NTT's Elis,^[13]^[14] Toshiba's AI processor (AIP)^[15] and NEC's
   LIME.^[16] Several university research efforts produced working
   prototypes, among them are Kobe University's TAKITAC-7,^[17] RIKEN's
   FLATS,^[18] and Osaka University's EVLIS.^[19]

   In France, two Lisp Machine projects arose: M3L^[20] at Toulouse Paul
   Sabatier University and later MAIA.^[21]

   In Germany Siemens designed the RISC-based Lisp co-processor

End of the Lisp machines[edit]

   With the onset of the AI winter and the early beginnings of the
   microcomputer revolution, which would sweep away the minicomputer and
   workstation makers, cheaper desktop PCs soon could run Lisp programs
   even faster than Lisp machines, with no use of special purpose
   hardware. Their high profit margin hardware business eliminated, most
   Lisp machine makers had gone out of business by the early 90s, leaving
   only software based firms like Lucid Inc. or hardware makers who had
   switched to software and services to avoid the crash. As of
   January 2015^[update], besides Xerox and TI, Symbolics is the only Lisp
   machine firm still operating, selling the Open Genera Lisp machine
   software environment and the Macsyma computer algebra system.^[26]^[27]


   Several attempts to write open-source emulators for various Lisp
   Machines have been made: CADR Emulation,^[28] Symbolics L Lisp Machine
   Emulation,^[29] the E3 Project (TI Explorer II Emulation),^[30] Meroko
   (TI Explorer I),^[31] and Nevermore (TI Explorer I).^[32] On 3 October
   2005, the MIT released the CADR Lisp Machine source code as open

   In September 2014, Alexander Burger, developer of PicoLisp, announced
   PilMCU, an implementation of PicoLisp in hardware.^[34]

   The Bitsavers' PDF Document Archive^[35] has PDF versions of the
   extensive documentation for the Symbolics Lisp Machines,^[36] the TI
   Explorer^[37] and MicroExplorer^[38] Lisp Machines and the Xerox
   Interlisp-D Lisp Machines.^[39]


   Domains using the Lisp machines were mostly in the wide field of
   artificial intelligence applications, but also in computer graphics,
   medical image processing, and many others.

   The main commercial expert systems of the 80s were available:
   Intellicorp's Knowledge Engineering Environment (KEE), Knowledge Craft,
   from The Carnegie Group Inc., and ART (Automated Reasoning Tool) from
   Inference Corporation.^[40]

Technical overview[edit]

   Initially the Lisp machines were designed as personal workstations for
   software development in Lisp. They were used by one person and offered
   no multi-user mode. The machines provided a large, black and white,
   bitmap display, keyboard and mouse, network adapter, local hard disks,
   more than 1 MB RAM, serial interfaces, and a local bus for extension
   cards. Color graphics cards, tape drives, and laser printers were

   The processor did not run Lisp directly, but was a stack machine with
   instructions optimized for compiled Lisp. The early Lisp machines used
   microcode to provide the instruction set. For several operations, type
   checking and dispatching was done in hardware at runtime. For example,
   only one addition operation could be used with various numeric types
   (integer, float, rational, and complex numbers). The result was a very
   compact compiled representation of Lisp code.

   The following example uses a function that counts the number of
   elements of a list for which a predicate returns true.
(defun example-count (predicate list)
  (let ((count 0))
    (dolist (i list count)
      (when (funcall predicate i)
        (incf count)))))

   The disassembled machine code for above function (for the Ivory
   microprocessor from Symbolics):
Command: (disassemble (compile #'example-count))

  2  PUSH 0                             ;Creating COUNT
  3  PUSH FP|3                          ;LIST
  4  PUSH NIL                           ;Creating I
  5  BRANCH 15
 10  START-CALL FP|2                    ;PREDICATE
 11  PUSH FP|6                          ;I
 14  INCREMENT FP|4                     ;COUNT
 15  ENDP FP|5

   The operating system used virtual memory to provide a large address
   space. Memory management was done with garbage collection. All code
   shared a single address space. All data objects were stored with a tag
   in memory, so that the type could be determined at runtime. Multiple
   execution threads were supported and termed processes. All processes
   ran in the one address space.

   All operating system software was written in Lisp. Xerox used
   Interlisp. Symbolics, LMI, and TI used Lisp Machine Lisp (descendant of
   MacLisp). With the appearance of Common Lisp, Common Lisp was supported
   on the Lisp Machines and some system software was ported to Common Lisp
   or later written in Common Lisp.

   Some later Lisp machines (like the TI MicroExplorer, the Symbolics
   MacIvory or the Symbolics UX400/1200) were no longer complete
   workstations, but boards designed to be embedded in host computers:
   Apple Macintosh II and SUN 3 or 4.

   Some Lisp machines, such as the Symbolics XL1200, had extensive
   graphics abilities using special graphics boards. These machines were
   used in domains like medical image processing, 3D animation, and CAD.

See also[edit]

     * 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


    1. ^ Newquist, H.P. (1 March 1994). The Brain Makers. Sams Publishing.
       ISBN 978-0672304125.
    2. ^ Target, Sinclair (30 September 2018). "A Short History of
       Chaosnet". Two-Bit History. Retrieved 6 December 2021.
    3. ^ Moon, David A. (1985). "Architecture of the Symbolics 3600". ACM
       SIGARCH Computer Architecture News. Portal.acm.org. 13 (3): 76-83.
       doi:10.1145/327070.327133. S2CID 17431528.
    4. ^ Levy, S: Hackers. Penguin USA, 1984
    5. ^ Moon 1985
    6. ^ K-Machine
    7. ^ Moby space Archived 25 February 2012 at the Wayback Machine
       Patent application 4779191
    8. ^ "Computing Facilities for AI: A Survey of Present and Near-Future
       Options". AI Magazine. 2 (1). 1981.
    9. ^ "The AAAI-86 Conference Exhibits: New Directions for Commercial
       AI, VLSI Lisp Machine Implementations Are Coming". AI Magazine. 8
       (1). 1987.
   10. ^ "The AAAI-86 Conference Exhibits: New Directions for Commercial
       AI, A New Lisp Machine Vendor", AI Magazine, 8 (1), 1987, retrieved
       12 November 2011
   11. ^ "Computer Algebra in Norway, Racal-Norsk KPS-5 and KPS-10
       Multi-User Lisp Machines". Springer link.
       doi:10.1007/3-540-15984-3_297. {{cite journal}}: Cite journal
       requires |journal= (help)
   12. ^ "Facom Alpha". Computer Museum. IPSJ. Retrieved 12 November 2011.
   13. ^ "NTT ELIS". Computer Museum. IPSJ. 9 September 1983. Retrieved 12
       November 2011.
   14. ^ Yasushi, Hibino (25 August 1990). "A 32-bit LISP Processor for
       the Al Workstation ELIS with a Multiple Programming Paradigm
       Language, TAO". Journal of Information Processing. NII. 13 (2):
       156-164. Retrieved 12 November 2011.
   15. ^ Mitsuo, Saito (25 August 1990). "Architecture of an AI Processor
       Chip (IP1704)". Journal of Information Processing. NII. 13 (2):
       144-149. Retrieved 12 November 2011.
   16. ^ "NEC LIME Lisp Machine". Computer Museum. IPSJ. Retrieved 12
       November 2011.
   17. ^ "Kobe University Lisp Machine". Computer Museum. IPSJ. 10
       February 1979. Retrieved 12 November 2011.
   18. ^ "RIKEN FLATS Numerical Processing Computer". Computer Museum.
       IPSJ. Retrieved 12 November 2011.
   19. ^ "EVLIS Machine". Computer Museum. IPSJ. Retrieved 12 November
   20. ^ "M3L, A Lisp-machine". Limsi. Retrieved 12 November 2011.
   21. ^ "MAIA, Machine for Artificial Intelligence". Limsi. Retrieved 12
       November 2011.
   22. ^ Hafer, Christian; Plankl, Josef; Schmidt, Franz Josef (1991),
       "COLIBRI: A Coprocessor for LISP based on RISC", VLSI for
       Artificial Intelligence and Neural Networks, Boston, MA: Springer:
       47-56, doi:10.1007/978-1-4615-3752-6_5, ISBN 978-1-4613-6671-3
   23. ^ Mueller-Schloer (1988), "Bewertung der RISC-Methodik am Beispiel
       COLIBRI", in Bode, A (ed.), RISC-Architekturen [Risc architectures]
       (in German), BI
   24. ^ Hafer, Christian; Plankl, Josef; Schmitt, FJ (7-9 March 1990),
       "COLIBRI: Ein RISC-LISP-System" [Colibri: a RISC, Lisp system],
       Architektur von Rechensystemen, Tagungsband (in German), Muenchen,
       DE: 11. ITG/GI-Fachtagung
   25. ^ Legutko, Christian; Schaefer, Eberhard; Tappe, Juergen (9-11
       March 1988), "Die Befehlspipeline des Colibri-Systems" [The
       instruction pipeline of the Colibri system], Architektur und
       Betrieb von Rechensystemen, Tagungsband, Informatik-Fachberichte
       (in German), Paderborn, DE: 10. ITG/GI-Fachtagung, 168: 142-151,
       doi:10.1007/978-3-642-73451-9_12, ISBN 978-3-540-18994-7
   26. ^ "symbolics.txt".
   27. ^ "A few things I know about LISP Machines".
   28. ^ "CADR Emulation". Unlambda. Retrieved 12 November 2011.
   29. ^ "Symbolics L Lisp Machine Emulation". Unlambda. 28 May 2004.
       Retrieved 12 November 2011.
   30. ^ "The E3 Project, TI Explorer II emulation". Unlambda. Retrieved
       12 November 2011.
   31. ^ "Meroko Emulator (TI Explorer I)". Unlambda. Retrieved 12
       November 2011.
   32. ^ "Nevermore Emulator (TI Explorer I)". Unlambda. Retrieved 12
       November 2011.
   33. ^ "MIT CADR Lisp Machine Source code". Heeltoe. Retrieved 12
       November 2011.
   34. ^ "Announce: PicoLisp in Hardware (PilMCU)".
   35. ^ "Bitsavers' PDF Document Archive". Bitsavers. Retrieved 12
       November 2011.
   36. ^ "Symbolics documentation". Bitsavers. Retrieved 12 November 2011.
   37. ^ "TI Explorer documentation". Bitsavers. 15 May 2003. Retrieved 12
       November 2011.
   38. ^ "TI MicroExplorer documentation". Bitsavers. 9 September 2003.
       Retrieved 12 November 2011.
   39. ^ "Xerox Interlisp documentation". Bitsavers. 24 March 2004.
       Retrieved 12 November 2011.
   40. ^ Richter, Mark: AI Tools and Techniques. Ablex Publishing
       Corporation USA, 1988, Chapter 3, An Evaluation of Expert System
       Development Tools


     * "LISP Machine Progress Report", Alan Bawden, Richard Greenblatt,
       Jack Holloway, Thomas Knight, David A. Moon, Daniel Weinreb, AI Lab
       memos, AI-444, 1977.
     * "CADR", Thomas Knight, David A. Moon, Jack Holloway, Guy L. Steele.
       AI Lab memos, AIM-528, 1979.
     * "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
     * David A. Moon. Chaosnet. A.I. Memo 628, Massachusetts Institute of
       Technology Artificial Intelligence Laboratory, June 1981.
     * "Implementation of a List Processing Machine". Tom Knight, Master's
     * Lisp Machine manual, 6th ed. Richard Stallman, Daniel Weinreb,
       David A. Moon. 1984.
     * "Anatomy of a LISP Machine", Paul Graham, AI Expert, December 1988
     * Free as in Freedom: Richard Stallman's Crusade for Free Software

External links[edit]

     * Symbolics website
     * Medley
     * Bitsavers, PDF documents
          + LMI documentation
          + MIT CONS documentation
          + MIT CADR 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"
     * Information and code for LMI Lambda and LMI K-Machine
     * Jaap Weel's Lisp Machine Webpage at the Wayback Machine (archived
       23 June 2015) - A set of links and locally stored documents
       regarding all manner of Lisp machines
     * "A Few Things I Know About LISP Machines" - A set of links, mostly
       discussion of buying Lisp machines
     * Ralf Moeller's Symbolics Lisp Machine Museum
     * Vintage Computer Festival pictures of some Lisp machines, one
       running Genera
     * LISPMachine.net - Lisp Books and Information
     * Lisp machines timeline - a timeline of Symbolics' and others' Lisp
     * (in French) "Presentation Generale du projet M3L" - An account of
       French efforts in the same vein
     * Discussion
          + "If It Works, It's Not AI: A Commercial Look at Artificial
            Intelligence startups"
          + "Symbolics, Inc.: A failure of Heterogenous engineering" -
          + "My Lisp Experiences and the Development of GNU Emacs" -
            transcript of a speech Richard Stallman gave about Emacs,
            Lisp, and Lisp machines

     * v
     * t
     * e

   Lisp programming language
     * Automatic storage management
     * Conditionals
     * Dynamic typing
     * Higher-order functions
     * Linked lists
     * M-expressions (deprecated)
     * Read-eval-print loop
     * Recursion
     * S-expressions
     * Self-hosting compiler
     * Tree data structures

   Object systems
     * Common Lisp Object System (CLOS)
     * CommonLoops
     * Flavors

     * Allegro Common Lisp
     * Armed Bear Common Lisp (ABCL)
     * CLISP
     * Clozure CL
     * CMU Common Lisp (CMUCL)
     * Corman Common Lisp
     * Embeddable Common Lisp (ECL)
     * GNU Common Lisp (GCL)
     * LispWorks
     * Macintosh Common Lisp
     * Mocl
     * Movitz
     * Poplog
     * Steel Bank Common Lisp (SBCL)
     * Symbolics Common Lisp

     * History
     * Bigloo
     * Chez Scheme
     * Chicken
     * Gambit
     * Game Oriented Assembly Lisp (GOAL)
     * GNU Guile
     * Ikarus
     * JScheme
     * Kawa
     * Larceny
     * MIT/GNU Scheme
     * MultiLisp
     * Pocket Scheme
     * Racket
     * RScheme
     * Scheme 48
     * SCM
     * SIOD
     * T
     * TinyScheme

     * OpenLisp

     * MSWLogo
     * NetLogo
     * StarLogo
     * UCBLogo

     * Arc
     * AutoLISP
     * BBN LISP
     * Clojure
     * Dylan (Apple, history)
     * Emacs Lisp
     * EuLisp
     * Franz Lisp, PC-LISP
     * Hy
     * Interlisp
     * Knowledge Engineering Environment
     * *Lisp
     * LeLisp
     * LFE
     * Lisp Machine Lisp
     * Maclisp
     * MDL
     * MLisp
     * newLISP
     * NIL
     * PC-LISP
     * Picolisp
     * Portable Standard Lisp
     * RPL
     * S-1 Lisp
     * SKILL
     * Spice Lisp
     * Zetalisp

   Operating system


     Common Lisp Interface Manager, McCLIM


     * Lisp machine
          + TI Explorer
     * Space-cadet keyboard

   of practice

   Technical standards
     * Scheme Requests for Implementation
     * Common Lisp HyperSpec
     * X3J13

     * Common Lisp the Language
     * How to Design Programs (HTDP)
     * On Lisp
     * Practical Common Lisp
     * Structure and Interpretation of Computer Programs (SICP)

     * ProgramByDesign

     * Apple Computer
     * Bolt, Beranek and Newman
     * Harlequin
     * Lucid Inc.
     * Symbolics
     * Xanalys

     * Massachusetts Institute of Technology (MIT)
     * MIT Computer Science and Artificial Intelligence Laboratory (CSAIL)
     * Stanford Artificial Intelligence Laboratory
     * University of California, Berkeley

     * Edmund Berkeley
     * Daniel G. Bobrow
     * William Clinger
     * R. Kent Dybvig
     * Matthias Felleisen
     * Robert Bruce Findler
     * Matthew Flatt
     * Phyllis Fox
     * Paul Graham
     * Richard Greenblatt
     * Timothy P. Hart
     * Louis Hodes
     * Mike Levin
     * David Luckham
     * John McCarthy
     * Robert Tappan Morris
     * Joel Moses
     * David Park
     * Steve Russell
     * Richard Stallman

   Common Lisp
     * Scott Fahlman
     * Richard P. Gabriel
     * Philip Greenspun (10th rule)
     * David A. Moon
     * Kent Pitman
     * Guy L. Steele Jr.
     * Daniel Weinreb

     * Matthias Felleisen
     * Shriram Krishnamurthi
     * Guy L. Steele Jr.
     * Gerald Jay Sussman
     * Julie Sussman

     * Hal Abelson
     * Denison Bollay
     * Wally Feurzeig
     * Brian Harvey
     * Seymour Papert
     * Mitchel Resnick
     * Cynthia Solomon

     * List
     * Category
     * Category

   Retrieved from

     * Lisp (programming language)
     * Computer workstations
     * History of artificial intelligence
     * High-level language computer architecture

   Hidden categories:
     * Webarchive template wayback links
     * CS1 errors: missing periodical
     * CS1 German-language sources (de)
     * Articles with short description
     * Short description is different from Wikidata
     * Use dmy dates from July 2020
     * All articles with unsourced statements
     * Articles with unsourced statements from October 2009
     * Articles with unsourced statements from May 2013
     * Articles with unsourced statements from March 2007
     * All accuracy disputes
     * Articles with disputed statements from March 2019
     * Articles that may contain original research from June 2021
     * All articles that may contain original research
     * Articles containing potentially dated statements from January 2015
     * All articles containing potentially dated statements
     * Articles with French-language sources (fr)

Navigation menu

Personal tools

     * Not logged in
     * Talk
     * Contributions
     * Create account
     * Log in


     * Article
     * Talk

   [ ] English


     * Read
     * Edit
     * View history

   [ ] More


   ____________________ Search Go


     * Main page
     * Contents
     * Current events
     * Random article
     * About Wikipedia
     * Contact us
     * Donate


     * Help
     * Learn to edit
     * Community portal
     * Recent changes
     * Upload file


     * What links here
     * Related changes
     * Upload file
     * Special pages
     * Permanent link
     * Page information
     * Cite this page
     * Wikidata item


     * Download as PDF
     * Printable version

In other projects

     * Wikimedia Commons


     * a+l+e+r+b+y+tm
     * Deutsch
     * Espanol
     * Franc,ais
     * Norsk bokmaal
     * Polski
     * Portugues
     * Russkij
     * Srpski / srpski
     * Suomi
     * Ukrayins'ka

   Edit links

     * This page was last edited on 5 August 2022, at 23:58 (UTC).
     * Text is available under the Creative Commons Attribution-ShareAlike
       License 3.0; additional terms may apply. By using this site, you
       agree to the Terms of Use and Privacy Policy. Wikipedia(R) is a
       registered trademark of the Wikimedia Foundation, Inc., a
       non-profit organization.

     * Privacy policy
     * About Wikipedia
     * Disclaimers
     * Contact Wikipedia
     * Mobile view
     * Developers
     * Statistics
     * Cookie statement

     * Wikimedia Foundation
     * Powered by MediaWiki
Saved from web.archive.org, with Lynx.
Main page
© 2022 Matei. No cookies®