Common Lisp was defined in 1984, when Guy L. Steele Jr. published Common Lisp the Language, and became an ANSI standard in 1994. How Common Lisp unified the Maclisp dialects is a story about a fragmented community deciding, under pressure from its main funder, to agree on one language. The result is a large, industrial-strength Lisp that still runs production systems today.

How Common Lisp unified the Maclisp dialects

By the late 1970s Lisp had split into many dialects. Maclisp, developed at MIT, had several successors: ZetaLisp (Lisp Machine Lisp) on MIT-derived Lisp machines from Symbolics and LMI, NIL for the VAX, Spice Lisp at Carnegie Mellon, and S-1 Lisp for a supercomputer at Lawrence Livermore. Xerox's Interlisp was a separate family. Code written for one rarely ran on another.

In April 1981, at a meeting called by ARPA, the US defence research agency that paid for much of the work, researchers from the Maclisp camp agreed to design a common dialect. Key contributors included Scott Fahlman, Richard P. Gabriel, David Moon, Kent Pitman, Guy Steele and Daniel Weinreb. Much of the coordination happened by ARPANET email. Steele edited the result into Common Lisp the Language (CLtL1), published by Digital Press in 1984.

From CLtL to the ANSI standard

YearMilestone
1981ARPA meeting starts the Common Lisp effort
1984Common Lisp the Language (CLtL1)
1986ANSI X3J13 committee formed
1988CLOS specification adopted by X3J13
1990CLtL2 documents the committee's work in progress
1994ANSI X3.226-1994 published
1996Common Lisp HyperSpec put online by Kent Pitman

The standard has not been revised since 1994. Instead, the community extends the language through portable libraries, which the language's macro system makes unusually easy.

Design and key features

  • Macros: code is data (lists), so macros can transform programs before compilation, letting developers add new control structures and even domain-specific languages.
  • CLOS, the Common Lisp Object System, with multiple inheritance, multiple dispatch (generic functions that choose a method based on all arguments) and a metaobject protocol.
  • The condition system, designed largely by Kent Pitman, which separates signalling an error from deciding how to recover, using restarts.
  • Interactive development: you can redefine functions and classes in a running image, and existing objects are updated.
  • Native compilation with optional type declarations, so tight numeric code can approach C speed.
  • Lexical scope by default, influenced by Scheme, with dynamic (special) variables when needed.
(defun word-frequencies (words)
  (let ((table (make-hash-table :test #'equal)))
    (dolist (w words)
      (incf (gethash w table 0)))
    (loop for word being the hash-keys of table
            using (hash-value count)
          collect (cons word count))))

(word-frequencies '("lisp" "ml" "lisp"))
;; => (("lisp" . 2) ("ml" . 1))   ; order may vary

The loop macro is a small language of its own inside Common Lisp.

Implementations

Common Lisp has several mature implementations. SBCL (Steel Bank Common Lisp), forked from CMU Common Lisp in 1999, is the most popular open source choice and produces fast native code. Others include Clozure CL, ECL (which compiles via C), ABCL on the JVM, and the commercial LispWorks and Allegro CL from Franz Inc. Quicklisp, a library manager released in 2010, made installing libraries straightforward.

Where Common Lisp has been used

  • ITA Software built its QPX airfare search engine in Common Lisp; Google acquired ITA in 2011.
  • Viaweb, Paul Graham and Robert Morris's online store builder, became Yahoo! Store after a 1998 acquisition.
  • NASA's Remote Agent on the Deep Space 1 probe in 1999 included Lisp software, famously debugged in flight.
  • Grammarly has described using Common Lisp in its core grammar engine.
  • CAD, symbolic mathematics (Maxima) and theorem proving (ACL2) also rely on it.

Influence and legacy

Common Lisp's object system influenced Dylan and Julia's multiple dispatch, and its interactive, image-based development style shaped tools such as Emacs and SLIME. Clojure took many ideas from it while moving to the JVM and immutable data. ISLISP and EuLisp were partly reactions to its size.

Is Common Lisp still used today?

Yes, by a small but committed community and a number of companies that value its interactive development and runtime flexibility. SBCL releases arrive roughly monthly. The history of how Common Lisp unified the Maclisp dialects explains its character: a committee-built language meant to keep a whole research community's work portable, which is why it is big, stable and still running code written decades ago.

Frequently asked questions

Why was Common Lisp created?

By around 1980, Lisp had split into incompatible dialects, especially among the successors of MIT's Maclisp. ARPA and the research community wanted one portable language so programs and tools could move between machines. Common Lisp was the compromise they designed.

What is the difference between CLtL1, CLtL2 and ANSI Common Lisp?

CLtL1 is Guy Steele's 1984 book that first defined the language. CLtL2, from 1990, described the language as the X3J13 committee was changing it, including CLOS. The ANSI standard of 1994 is the official definition, and modern implementations follow it.

Is SBCL the best Common Lisp implementation for beginners?

SBCL is the most common choice because it is free, fast and well supported by libraries and editors. Beginners usually pair it with Emacs and SLIME or SLY, or with editor plugins for VS Code. LispWorks and Allegro CL offer free personal editions with graphical IDEs as alternatives.