30 years Common Lisp: The Language. Guy L. Steele Jr., Digital Press, 1984. 465 pages. ISBN 0-932376-41-X.

The defining publication of the first version of Common Lisp is the book Common Lisp the Language by Guy L. Steele Jr. in 1984. It was called the Aluminum Book. Today we refer to this book as CLtL1. A few years later, in 1990, an updated version was published, CLtL2. It was followed by the publication of an ANSI Standard for Common Lisp in 1994.







Lisp itself is quite a bit older. It started 1958 as an effort to define a symbolic programming language based on recursive functions. John McCarthy needed a language to support the research on Artificial Intelligence.

An Algebraic Language for the Manipulation of Symbolic Expressions, by John McCarthy - Published 1958 as AI Memo 1.

After a few years there were dialects: Maclisp at MIT, Interlisp at Xerox and BBN, Standard Lisp. Plus a few minor variants. Also a new Lisp dialect was developed to support new developments in functional programming: Scheme. At the end of the 70s Lisp applications started to get the attention of ARPA, the (Defense) Advanced Reseach Projects Agency. Lisp was already known, but now actual applications of Lisp were of interest. But these applications were defined in different Lisp dialects. A few successor dialects of Maclisp were already in use or under development.

1981

ARPA wanted the Lisp users to focus on one standard Lisp language for application development. Bob Engelmore from ARPA invited to a Lisp meeting in 1981 to discuss this.

As a result the Maclisp successor projects decided to work together to develop such a Lisp standard. Communities of the other Lisp dialects were mostly sceptical. ARPA supported the Common Lisp project with money and a few companies, like DEC, supported it by funding implementations. At CMU the Spice Lisp manual was reworked as the first version of the upcoming Common Lisp standard - the 1981 Swiss Cheese edition of the Spice Lisp manual.

Common Lisp mailing list - A mailing for development of the Common Lisp standard was set up in 1981. Many language issues were discussed. It was one of the first uses of a mailing list to collaboratively develop a new programming language.

1982

In 1982 work on Common Lisp implementations was funded.

1984

Guy L. Steele finished the book Common Lisp the Language. Its final version had 465 pages and was sent to the typesetter in march 1984. In June 1984 the first printed editions were delivered.

Common Lisp was mostly derived from Lisp Machine Lisp (or ZetaLisp, which was the marketing name from Symbolics for its version), NIL (New Implementation of Lisp) and Spice Lisp.

ZetaLisp was a larger Lisp dialect also used for the implementation of an operating system. It also provided a object-oriented extension called Flavors. Flavors started to be used to implement fundamental language elements like I/O streams and also facilities like networking or the graphical user interface. ZetaLisp provided dynamic binding by default and closures via a special construct. It had macros and parameter list with positional and named arguments. The language provided low-level constructs, but the compiler was relatively simple - it didn't provide much optimization capabilities and compiled to machine code of a Lisp processor with a stack machine.

Common Lisp should be slightly simpler than ZetaLisp, newer language features (like object-oriented programming) should be added later and it should be efficiently executable on normal processors which were not optimized for Lisp. It should be able to be implemented to run on personal computers (like IBM PCs), Unix workstations (like SUNs), Lisp Machines, minicomputers (like the VAX 11), mainframes (like IBM's mainframes) and supercomputers (like the Cray computers).

Common Lisp the Language

Common Lisp was developed by a group of people working on several implementations for different architectures and systems. It provided lexical binding by default - a controversial issue at that time. The language was also defined to have compatible semantics using an interpreter and a compiler - new at the time. In earlier Lisp implementations the language implemented by the compiler often had different semantics - for example lexical binding by the default in the compiler and dynamic binding in the interpreter. Not so in Common Lisp. The language also provides rich numerics: integers, floats, ratios and complex numbers - another controversial issue. These extensive numeric data types and operations should support applications like MIT's Macsyma and IBM's Scratchpad. A facility for type declaration should support optimizing compilers - early examples are Lucid Common Lisp and CMU Common Lisp. Packages were provided as namespaces for symbols. Sequences are an abstraction to unify the usage of lists, vectors and strings.

The big things missing: an object-system and better error handling. Both were added later. Unfortunately this means that much of the early Common Lisp was not defined in an object-oriented way with classes and methods. Instead it was functions and structures. A step back from Lisp Machine Lisp and its Flavors extension. Later Lisp dialects were based on Common Lisp and its later defined Common Lisp Object System - Dylan, EuLisp and ISLisp included such an object system from the start.

Common Lisp as a language was criticized early. Still today, topics like the naming of the built-in facilities are controversial. If one checks the discussions on the Common Lisp mailing list, a lot of that was discussed and one was aware of many problems. Even people involved in defining the language criticized it - for not being able to be implemented efficiently on stock hardware - and implementing an optimizing compiler for it a few years later to falsify many of their claims, themselves.

The Book

The book is a piece of art. Guy L. Steele Jr. was its main editor/author with support from many others. But his style is visible on every page. It's clearly written, but with many jokes and funny Lisp examples hidden in the text.

1985

In 1985 the first implementations were mostly feature complete. CMU Common Lisp had most of the language implemented. CMU CL is today still available as a Public Domain implementation. At that time several other implementations used its source code as a starting point.

More information about the history of Common Lisp