Richard Greenblatt arrived at M.I.T. in the Fall of 1962. There was a
PDP-1 in Building 26 (next door to the TX-0), a gift from DEC: serial
number 3. It was available for student use, and was entirely hands on,
having no operating system not dependent on manipulating the console
keys. L. Peter Deutsch was a young high school student, the son of an
M.I.T. professor. He wrote a LISP which
ran entirely in the core memory of 4096 18-bit words. Later a drum was
installed, which had 22 4096-word "fields", or 88K words altogether.
Someone - Michael Wolfberg? - changed Deutsch's LISP to treat every
memory reference as a subroutine call to a cache/drum access routine.

In 1963, DEC began the PDP-6 project with Gordon Bell as the chief
engineer and Alan Kotok as the junior engineer. Kotok still spent time
at the Tech Model Railroad Club,
where members such as Dave Gross, Peter Samson, and Richard Greenblatt
were devising efficient implementations of the various LISP SUBRs. The
prototype PDP-6 took shape at the
Mill, DEC's
facility in Maynard, MA. The M.I.T. students would visit in the evening,
bringing paper tape with assembly language source code prepared on the
PDP-1 at M.I.T. They used a cross-assembler on a PDP-4. Bill Mann and
Richard Greenblatt studied Deutsch's EVAL and wrote a new one
for the PDP-6. Dave Gross and Greenblatt wrote PRINT. Gross and
Tom Eggers went to work for DEC full time, and did some work on PDP-6
LISP. DEC sold the first PDP-6 to M.I.T.'s Artificial Intelligence
Laboratory, accepting the Lab's existing 16K PDP-1 in trade as partial
payment. However, the AI Lab was allowed to keep both machines for a
short period.

Greenblatt returned to the AI Lab full time at that point (he had
earlier been a student employee). At this point, Greenblatt,
Stuart Nelson, Tom Knight and Jack Holloway resumed work on PDP-6 LISP.
Then Greenblatt and Nelson decided to do a more sophisticated compiler
that provided consistent variable access across the interpreter and
compiler; this became MacLisp. Several years later John White took over
the compiler, which became NCOMPLR. [Richard Greenblatt, as told to Paul
McJones, March 15, 2005; see also Greenblatt oral history]

"Ideas from several other implementations influenced the initial design,
notably the CTSS version on the IBM 7094, and the
very minimal version for
the PDP/1. However, the decision to dispense with the a-list in the
implementation, a major factor in the space economy and running speed of MACLISP, came some time later. An improved compiler was written as an
adjunct to the system – compilation is done 'off-line', and the resulting
LAP code loaded into the system when desired." [John
L. White 1970; see also Jon L. White 1977]

"In 1976 the MIT version of MacLisp was ported to the WAITS operating system by Richard Gabriel at the Stanford AI Laboratory (SAIL), which was directed at that time by John McCarthy." [Steele and Gabriel 1993]

Applications

"SHRDLU is a program for understanding natural language, written by Terry Winograd at the M.I.T. Artificial Intelligence Laboratory in 1968-70. SHRDLU carried on a simple dialog (via teletype) with a user, about a small world of objects (the BLOCKS world) shown on an early display screen (DEC-340 attached to a PDP-6 computer)."

"Abstract: A version of LISP 1.5 for the PDP-6 Computer has been
extended to include IO through the dataphone. This makes possible
communication between programs running in Project MAC time sharing and
LISP programs running on the PDP-6. The method of handling input-output
for the dataphone is similar to that for the typewriter, paper tape
punch, and paper tape reader. Three useful LISP functions are presented
as examples of dataphone programming.'

"Abstract: An intermediate level language for display programming has
been embedded in LISP 1.5. The language is intended as a basis for
higher level display languages and includes facilities for both
generation and analysis of display information. ..."

"This is a mosaic description of PDP-6 LISP, intended for readers
familiar with the LISP 1.5 Programmer's Manual or who have used LISP on
some other computer. Some of the newer features (e.g., the display) are
experimental and subject to change; in such respects this should not be
regarded as a final document."

"This is a mosaic description of PDP-6 LISP, intended for readers
familiar with the LISP 1.5 Programmer's Manual or who have used LISP on
some other computer. Many of the features, such as the display, are
subject to change. Thus, consult a PDP-6 systems programmer for any
differences which may exist between LISP of Oct. 14, 1966 and present
LISP on the system tape."

[Steele
and
Gabriel 1993] note: "The report does not bear the author's name,
but Jeffrey P. Golden [Golden 1970] attributes it to Jon L White."

"The substance of this memo is to initiate the naïve LISP user into
the intricacies of the system at the Project MAC A.I. Lab. ... At some
undetermined time in the future a comprehensive document will be issued,
consisting of an elementary introduction to LISP, a self-primer, the
core of this document, and numerous reference appendices. The
comprehensive guide will then replace A.I. memos numbers 116A, 152, 157,
the LISP Progress Report, this memo and all informal notes and
communications."

The Notation section says: "'MACLISP' refers to the PDP/6
implementation of the programming language LISP in use at the Artificial
Intelligence Group of Project MAC."

"In 1973 and 1974, David Moon led an effort to implement MacLisp on the Honeywell 6180 under Multics. As a part of this project he wrote the first truly comprehensive reference manual for Maclisp, which became familiarly known as the 'Moonual'." [Steele
and Gabriel 1993]

"Abstract [from
www.multicians.org bibliography]: MACLISP is a
dialect of Lisp developed at M.I.T.'s Project MAC (now the MIT
Laboratory for Computer Science) and the MIT Artificial Intelligence
Laboratory for use in artificial intelligence research and related
fields. Maclisp is descended from Lisp 1.5, and many recent important
dialects (for example Lisp Machine Lisp and NIL) have evolved from Maclisp. David Moon's original document on Maclisp, The Maclisp
Reference Manual (alias the Moonual ) provided in-depth coverage of a
number of areas of the Maclisp world. Some parts of that document,
however, were never completed (most notably a description of Maclisp's
I/O system); other parts are no longer accurate due to changes that
have occurred in the language over time. This manual includes some
introductory information about Lisp, but is not intended as tutorial.
It is intended primarily as a reference manual; particularly, it comes
in response to user's please for more up-to-date documentation. Much
text has been borrowed directly from the Moonual, but there has been a
shift in emphasis. While the Moonual went into greater depth on some
issues, this manual attempts to offer more in the way of examples and
style notes. Also, since Moon had worked on the Multics implementation,
the Moonual offered more detail about compatibility between ITS and
Multics Maclisp. While it is hoped that Multics users will still find
the information contained herein to be useful, this manual focuses more
on the ITS and TOPS-20 implementations since those were the
implementations most familiar to the author."

Papers

Joel Moses. The Function of FUNCTION in LISP or Why the FUNARG Problem
Should be Called the Environment Problem. AI-199, MAC-M-428, Project MAC,
Massachusetts Institute of Technology, June 1970, 15 pages. PDF at
MIT

"This reports the results of a test in which a compiled MacLisp
floating-point program was faster than equivalent Fortran code. The
numerical portion of the code was identical and McLisp used a faster
subroutine-call protocol." [Steele
and Gabriel 1993]

"This paper describes LLOGO, an implementation of the LOGO language written in MACLISP for the ITS, TEN50 and TENEX PDP-10 systems, and MULTICS. The relative merits of LOGO and LISP as educational languages are discussed. Design decisions in the LISP implementation of LOGO are contrasted with those of two other implementations: CLOGO for the PDP-10 and 11LOGO for the PDP-11, both written in assembler language. LLOGO's special facilities for character-oriented display terminals, graphic display 'turtles', and music generation are also described."

"Version II Lisp was known as 'Multics MacLisp' (From 'Project MAC'.) The need for it arose from the MIT Mathlab group's (part of project MAC, later Laboratory for Computer Science) 'Macsyma' program, which was written in Lisp, hitting against the address space constraints of the PDP-10 systems on which it was developed. The large virtual memory of Multics seemed to indicate the latter as a logical migration platform, so Multics MacLisp was developed to support Macsyma.

Multics MacLisp was designed to be compatible with the large, mature, and heavily used 'MACLISP' dialect in use on the PDP-10's throughout the AI Lab and MAC, and implemented between 1970 and 1973. Reed, then an undergraduate at MIT in the Multics group, started the project by modifying Version I Lisp, writing largely in PL/I. Ultimately, several of the most performance-critical sections, most notably the evaluator, were rewritten in a tour-de-force of ALM (Multics Assembler) by Dave Moon. Almost all of the implementation was done by Daves Moon and Reed and Alex Sunguroff; Moon was working in the MIT Undergraduate Research Opportunities program; Sunguroff, who worked on the I/O system, was a paid employee. Dan Bricklin, later of VisiCalc fame, worked on the BIGNUM (arbitrary-precision integer arithmetic) package.

The Multics MacLisp Compiler, initially designed and written by Reed alone, was a full-scale Lisp Compiler producing standard Multics object segments (which nonetheless had to be run from within the Lisp subsystem). Its two phases, semantics and code generation, both written in Lisp, were derived in conception and strategy from COMPLR/NCOMPLR, the renowned and powerful compiler on the PDP-10. While the code generator was written from scratch, the semantics phase was ported and adapted from PDP-10 MacLisp. Reed's code generator employed a subset of NCOMPLR's powerful data-flow techniques. [A 1977 paper on The Multics MacLisp Compiler by Bernard Greenberg is available at this web site.] A 'LAP' (intrinsic Lisp assembler program) was written a couple of years later by Moon.

Although Macsyma was ported to Multics, it was not a further impetus for much Multics Lisp development thereafter. The cause of Multics Lisp was taken up by Bernard Greenberg, who had just come to Honeywell (1974) after having been attracted to Lisp while sharing an office with Moon at MIT. Greenberg, who was involved with the development and continuation of the Multics Supervisor, implemented a Multics post-mortem crash-analysis program, ifd (interpret_fdump) in Multics Lisp, which in subsequent years achieved wide distribution and following in the Multics Community. While the 'official language' status of PL/I actively and openly discouraged experimentation with other languages, the interactive, extensible nature of ifd did much to attract attention to Lisp in the Multics development and site support communities.

From that time until his departure from Honeywell in 1980, Greenberg took over maintenance of Multics Lisp, adding features as he needed. Moon still contributed major features on occasion.

Largely as a consequence of the ifd experience, Greenberg chose Multics Lisp as the implementation and extension vehicles for Multics Emacs (1978), which drew attention to Lisp from all over the Multics community and to Multics from all over the Lisp community. Multics Emacs elevated Multics MacLisp to criticality in a highly visible and significant Multics offering. Multics Emacs' (see separate section) highly successful use of Lisp as (inter alia) an extension language inspired the use of Lisp as such by later generations of Emacs (e.g., GNU)." [Bernard Greenberg at multicians.org]

"This document describes a common subset of selected facilities available in Maclisp and its derivatives: PDP-10 and Multics Maclisp, Lisp Machine Lisp (Zetalisp), and NIL. The object of this document is to aid people in writing code which can run compatibly in more than one of these environments."

Source code

"After a long and interesting search I uncovered a set of 9-track
tapes which appear to be a snapshot of the MIT CADR Lisp machine source
code from around 1980. This is not the final source code and not the
last source release I will make. It is, however, the first source
release.

Tom Knight and others at MIT helped me secure permission from MIT's
Patent office to release the software. I am indebted to him and the
others for making this possible."

"The Texas Instruments Explorer is a family of Lisp Machine computers. These computers were sold by Texas Instruments in the 1980s. The Explorer is based on a design from Lisp Machines Incorporated, which is based on the MIT Lisp Machine. The Explorer was used for development and deployment of artificial-intelligence software.

Notable is also the early use of the NuBus as the system bus for the Explorer computer family."

Abstract: The CADR machine, a revised version of the CONS machine, is a
general-purpose, 32-bit microprogrammable processor which is the basis of
the Lisp-machine system, a new computer system being developed by the
Laboratory as a high-performance, economical implementation of Lisp. This
paper describes the CADR processor and some of the associated hardware and
low-level software.

Other links

"NIL, intended to be the successor to MacLisp, was designed by Jon L
White, Guy L. Steele Jr., and others at MIT, under the influence of
Lisp-Machine Lisp, also developed at MIT. Its name was a too-cute acronym
for 'New Implementation of Lisp' and caused a certain amount of confusion.
NIL was a large Lisp, and efficiency concerns were paramount in the minds of
its MacLisp-oriented implementors; soon its implementation was centered
around a large VAX assembly-language base.

In 1978, Gabriel and Guy Steele set out to implement NIL on the S-1 Mark
IIA, a supercomputer being designed and built by the Lawrence Livermore
National Laboratory. This Lisp was never completely functional, but served
as a testbed for adapting advanced compiler techniques to Lisp
implementation. In particular, the work generalized the numerical
computation techniques of the MacLisp compiler and unified them with
mainstream register allocation strategies. With the development of the S-1
Lisp compiler, it once again became feasible to implement Lisp in Lisp and
to expect similar performance to the best hand-tuned,
assembly-language-based Lisp systems." [Steele
and Gabriel 1993]

Franz Lisp

"Franz Lisp
was created as a tool to further research in symbolic and algebraic
manipulation, artificial intelligence, and programming languages at the
University of California at Berkeley. Its roots are in a PDP-11 Lisp system
which originally came from Harvard. As it grew it adopted features of
Maclisp and Lisp Machine Lisp. Substantial compatibility with other Lisp
dialects (Interlisp, UCILisp, CMULisp) is achieved by means of support
packages and compiler switches. The heart of Franz Lisp is written almost
entirely in the programming language C. Of course, it has been greatly
extended by additions written in Lisp. A small part is written in the
assembly language for the current host machines, VAXen and a couple of
flavors of 68000. Because Franz Lisp is written in C, it is
relatively portable and easy to comprehend." [Foderaro et al., The Franz Lisp Manual, June 1983]

"A chorus of students under the direction of Richard Fateman have
contributed to building FRANZ LISP from a mere melody into a full symphony .
The major contributors to the initial system were Mike Curry, John Breedlove
and Jeff Levinsky. Bill Rowan added the garbage collector and array package.
Tom London worked on an early compiler and helped in overall system design.
Keith Sklower has contributed much to FRANZ LISP, adding the bignum package
and rewriting most of the code to increase its efficiency and clarity. Kipp
Hickman and Charles Koester added hunks. Mitch Marcus added *rset, evalhook
and evalframe. Don Cohen and others at Carnegie-Mellon made some
improvements to evalframe and provided various features modelled after UCI/CMU
PDP-10 Lisp and Interlisp environments (editor, debugger, top-level). John
Foderaro wrote the compiler, added a few functions, and wrote much of this
manual. Of course, other authors have contributed specific chapters as
indicated. Kevin Layer modified the compiler to produce code for the
Motorola 68000, and helped make FRANZ LISP pass 'Lint'." [John K. Foderaro, The Franz Lisp Manual, June 1983]

"... a MacLisp-like Lisp that eventually ran on virtually all Unix-based
computers, thanks to the fact that Franz Lisp is written almost entirely in
C. Later Franz, Inc., was formed to further Franz Lisp ..." [Steele
and Gabriel 1993]

Documentation

"Spice Lisp provided two significant contributions to the Common Lisp
effort. One is the draft Common Lisp manual, which was derived from the
Spice Lisp manual (and also borrowed heavily from MIT Lisp Machine Manuals)
and the other is a reference implementation. For several years after the
appearance of CLtL I, Spice Lisp served as the source, literally, for a
number of Common Lisp implementations. Computer companies would take the
free source code and port it to their computers, providing a base level
Common Lisp." [Steele
and Gabriel 1993]