History Section (1.1)

[Richard P. Gabriel <rpg@lucid.com>]

Here is my current rewrite of the history section (1.1).  It is a
little more, but slightly more complete while being quite terse (what
it lacks in verbosity it makes up for in terseness). This version is
the result of comments by Masinter and Bobrow, so some of it is
probably accurate. Jonl says he cannot review it for a few months, so
I'll leave it to Steele and Moon to review the Maclisp and Zetalisp
stuff.


%%Scope, Purpose, and History
\beginsubSection{Scope and Purpose}

The specification set forth in this document is designed to promote
the portability of @clisp\ programs among a variety of data-processing
systems. It is a language specification aimed at an audience of
implementors and knowledgeable programmers: It is neither a tutorial nor
an implementation guide.

\endsubSection%{Scope and Purpose}
\beginsubSection{History}

Lisp is a family of languages with a long history.  Early key ideas in
Lisp were developed by John McCarthy during the 1956 Dartmouth Summer
Research Project on Artificial Intelligence.  McCarthy's motivation
was to develop an algebraic list processing language for artificial
intelligence work.

In 1957, on McCarthy's advice, Herbert Gelernter and Carl Gerberich
implemented a list processing language within FORTRAN, called
FLPL---FORTRAN List Processing Language. This was a set of subroutines
that were added to FORTRAN on the IBM~704 computer.  Under the
direction of McCarthy, the first real Lisp---Lisp~1---was implemented
for the IBM~704 computer in 1958.  Lisp~1.5 was an extension of
Lisp~1. It was implemented on the IBM~7090 computer at MIT. A later
version of Lisp~1.5 on the PDP-6 was the ancestor of MacLisp.

MacLisp improved on the Lisp~1.5 notion of special variables and error
handling. MacLisp also introduced into Lisp functions that could take
a variable number of arguments, macros, arrays, non-local dynamic
exits, fast arithmetic, the first good Lisp compiler, and an emphasis
on execution speed.

In 1963 L. Peter Deutsch, then a high school student, implemented
Basic PDP-1 Lisp, a Lisp similar to Lisp~1.5, at MIT.  At Bolt,
Beranek, \& Newman, BBN Lisp was implemented on the PDP-10 by Daniel
Bobrow, D. L.  Murphy, and Alice Hartley. In 1972, the maintenance of
BBN~Lisp---its name changed to InterLisp---was shared by BBN and Xerox
Palo Alto Research Center.

InterLisp introduced many ideas into Lisp programming environments,
style, and methodology. One of them was an iteration construct
implemented by Warren Teitelman which inspired the LOOP construct used
both on the Lisp Machines and in MacLisp, and now in @clisp.

Although the first implementations of Lisp were on the IBM~704 and the
IBM~7090, later work focussed on the Digital Equipment Corporation
PDP-10 computer, which was the mainstay of Lisp and artificial
intelligence work at MIT, Stanford, BBN, and CMU from the mid-1960's
through much of the 1970's.

The PDP-10 computer and its predecessor the PDP-6 computer were, by
design, especially well-suited to Lisp because they had 36-bit words
and 18-bit addresses. This architecture allowed a CONS cell to be
stored in one word; single instructions extracted the CAR and CDR
parts.  The PDP-6 and PDP-10 had fast, powerful stack instructions
that enabled fast function calling.

But the limitations of the PDP-10 were evident by 1973: it supported a
small number of researchers using Lisp, and the small, 18-bit address
space ($2â??{18}$ $=$ 262,144 words) limited the size of a single
program.
 
One response to the address space problem was the Lisp machine, a
special-purpose computer designed to run Lisp programs.  The other
response was to use computers with address spaces larger than 18~bits,
such as the Digital Equipment Corporation Vax and the S-1~Mark~IIA.

The Lisp machine concept was developed in the late 1960's.  In the
early 1970's, Deutsch, working with Bobrow, implemented a Lisp on the
Alto, a single-user minicomputer, using microcode to interpret a
byte-code implementation language. At approximately the same time,
Richard Greenblatt began work on a different hardware and
instruction-set design at MIT.

Eventually, a dialect of Interlisp known as Interlisp-D became
available on the D-series machines manufactured by Xerox---the Dorado,
Dolphin, and later the Dandelion. An upward-compatible extension of
MacLisp called ZetaLisp became available on the early MIT Lisp
machines.  Commercial Lisp machines from Xerox, Lisp Machines, Inc.
(LMI), and Symbolics, Inc., were on the market by 1981.
 
During the mid-1970's, ZetaLisp began to expand towards a much fuller
language.  Sophisticated lambda-lists, SETF, multiple values,
packages, and structures like those in @clisp\ are the results of
early experimentation with programming styles by the Lisp machine
group; these styles found their way into MacLisp.

Around 1980, Scott Fahlman and others at CMU began work on a Lisp to
run on the SPICE (Scientific Personal Integrated Computing
Environment) workstation.  One of the goals of the project was to
design a simpler dialect than ZetaLisp.

The Macsyma group at MIT began a project during the late 1970's called
the New Implementation of Lisp (NIL) for the Vax.  One of the stated
goals of the NIL project was to fix many of the historic, but
annoying, problems with Lisp while retaining compatibility with
MacLisp.  About the same time, a research group at Stanford University
and Lawrence Livermore National Laboratory began the design of a Lisp
to run on the S-1~Mark~IIA supercomputer.  S-1~Lisp, never completely
functional, was the test bed for adapting advanced compiler techniques
to Lisp implementation.  Eventually the S-1 and NIL groups
collaborated.

The first efforts towards Lisp standardization were Standard Lisp and
Portable Standard Lisp (PSL).  In 1969, Anthony Hearn and Martin Griss
defined Standard Lisp as a subset of Lisp~1.5 and other dialects to
transport REDUCE, a symbolic algebra system.  Portable Standard Lisp
(PSL) was designed tp provide more control over the environment and
the compiler.

At the end of the 1970's, PSL ran on about a dozen different
computers.  PSL and Franz Lisp---a MacLisp-like dialect for Unix
machines---were the first examples of widely available Lisp dialects
on multiple hardware platforms.

One of the most important developments in Lisp occurred during the
second half of the 1970's: Scheme. Scheme, designed by Gerald J.
Sussman and Guy L. Steele Jr., is a simple dialect of Lisp whose
design brought to Lisp some of the ideas from programming language
semantics developed in the 1960's.  Sussman was one of the prime
innovators behind many other advances in Lisp technology from the late
1960's through the 1970's.

The major contributions of Scheme were lexical scoping, first-class
functions and continuations, and simplified syntax (no separation of
values and functions). Some of these contributions made a large impact
on the design of @clisp.

In the mid-1970's object-oriented programming concepts started to make
a strong impact on Lisp' At MIT, Flavors, an object-oriented
programming system with multiple inheritance patterned after
Smalltalk was developed and integrated into Lisp machines.  At Xerox,
the experience with Smalltalk and KRL led to the development of LOOPS.
These systems influenced the design of the Common Lisp Object System
(CLOS).

In 1980 Symbolics and LMI were developing ZetaLisp; stock-hardware
implementation groups were developing NIL, Franz Lisp, and PSL; Xerox
was developing InterLisp; and the SPICE project at CMU was developing
a MacLisp-like dialect of Lisp called SpiceLisp.

In April 1981, after a DARPA-sponsored meeting concerning the
splintered Lisp community, Symbolics, the SPICE project, the NIL
project, and the S-1~Lisp project joined together to define @clisp.
This effort was led by Scott Fahlman, Daniel Weinreb, David Moon, Guy
L. Steele Jr., and Richard Gabriel.  @clisp\ was designed as a
description of a family of languages.  The primary influences on
@clisp\ were ZetaLisp, MacLisp, NIL, S-1~Lisp, Spice Lisp, and Scheme.

{\it Common Lisp the Language\/} is a description of that design.  Its
semantics were intentionally underspecified in places where it was
felt that a tight specification would overly constrain @clisp\
research and use.  However, industrial use of @clisp\ mandates
stricter standardization for portability.  Left out of the original
@clisp\ were an object-oriented programming system, a condition
system, iteration facilities, and a way to handle large character
sets.  Therefore, a new language specification, this document, was
developed by the X3J13 committee.

\endsubSection%{History}