Lisp

Lisp (historically LISP, an acronym for "LISt Processor") is a family of programming languages, specified in 1958 by John McCarthy at the Massachusetts Institute of Technology, that became the dominant language of artificial intelligence research from the early 1960s through the late 1980s. Distinguished by a parenthesized prefix-notation syntax based on s-expressions, Lisp is the second-oldest high-level programming language still in widespread use, after Fortran, which preceded it by about a year.^[1][2]

Lisp pioneered or popularized many ideas that later became standard: conditional expressions, recursion as a primary control structure, dynamic typing, automatic garbage collection, higher-order functions, tree data structures, and the read-eval-print loop. For roughly three decades it was the near-universal tool of symbolic AI: from natural language understanding to theorem proving to expert systems, the code was almost always written in some Lisp dialect.^[3][4]

Lisp is a family. The two most influential modern dialects are Common Lisp, the large multi-paradigm dialect codified by ANSI in 1994, and Scheme, the minimalist lexically-scoped dialect designed at MIT in 1975. The most widely used 21st century descendant is Clojure, a JVM-targeting dialect first released in 2007. Other living dialects include Emacs Lisp, AutoLISP, Racket, and ClojureScript.^[5]

History

When was Lisp invented? (1956 to 1962)

Lisp's roots reach into 1950s work on symbolic computation and the lambda calculus of Alonzo Church. John McCarthy, then an assistant professor of mathematics at MIT, attended the 1956 Dartmouth Conference at which the phrase "artificial intelligence" was coined. He came away convinced that AI research would need a programming language for non-numerical, list-structured data, rather than the numeric arrays of Fortran.^[1][6]

McCarthy's memo "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I," in the April 1960 Communications of the ACM, gave the language its theoretical core. The paper described eval, a universal evaluator, in terms of a tiny set of primitive operators: atom, eq, car, cdr, cons, cond, quote, and lambda.^[2]

McCarthy intended eval only as mathematics. The breakthrough came from his student Steve Russell, who realized in late 1958 that eval could itself be hand-translated into machine code for the IBM 704 and used as an interpreter. Russell's hand-compiled eval was the first Lisp implementation.^[1][6]

The IBM 704 left a permanent mark on Lisp vocabulary. The 704's address word was divided into halves called the address part and the decrement part, and two machine instructions extracted these fields: "Contents of Address Register" and "Contents of Decrement Register." Lisp's primitive operators for taking the head and tail of a pair were named after these instructions, giving programmers car and cdr for the next sixty years.^[1]

Lisp 1.5, the first widely distributed Lisp, was released in 1962 along with the Lisp 1.5 Programmer's Manual by McCarthy, Abrahams, Edwards, Hart, and Levin. The manual contained the first published description of a complete Lisp implementation, including a metacircular evaluator.^[7]

Major dialects emerge (1960s to 1980s)

Lisp 1.5 was followed by a proliferation of dialects. The two early lines that mattered most were MacLisp, developed at the MIT AI Laboratory starting in 1966 for the Project MAC PDP-6 and PDP-10 systems, and Interlisp, which emerged from BBN-Lisp around 1967 and was later developed at Xerox PARC into Interlisp-D.^[3][5]

Through the 1970s the dialect tree branched further. Stanford and Carnegie Mellon used variants of MacLisp. Lisp Machine Lisp, and its successor Zetalisp, grew up around the dedicated Lisp computers built at MIT and at the spinoff companies Symbolics and Lisp Machines, Inc. Scheme, invented in 1975 by Gerald Sussman and Guy Steele at MIT, took a different path: a small, lexically-scoped dialect.^[8][9]

Beginning in 1981 a working group led by Steele began the multi-year effort that produced Common Lisp, a union dialect that absorbed features of MacLisp, Lisp Machine Lisp, and the academic dialects. Common Lisp the Language (CLtL1) appeared in 1984, the second edition (CLtL2) in 1990, and the ANSI standard X3.226-1994 in 1994.^[5][10][11]

A parallel cultural fork happened around editors. Richard Stallman, at the MIT AI Lab in the 1970s, ported the original TECO-based Emacs to Lisp Machine Lisp and then, in 1985, released GNU Emacs, embedding Emacs Lisp as the editor's extension language.^[12]

What core ideas did Lisp pioneer?

Many features that programmers now take for granted appeared first in Lisp. Lisp 1.5 in 1962 already had most of them.^[2][7]

S-expressions and homoiconicity. Lisp programs and Lisp data are represented by the same recursive tree structure, the s-expression. A list like (+ 1 2) is simultaneously code that adds two numbers and a three-element list whose first element is the symbol +. This property, called homoiconicity, is the foundation of Lisp's macro system.^[1][13]

Conditional expressions. McCarthy introduced cond in his 1960 paper. Earlier languages such as Fortran had only IF statements that jumped to a label. Lisp's cond was an expression whose value was the value of the first branch whose test succeeded. The modern if expression descends from this construct.^[2]

Recursion. Lisp was the first widely used language to treat recursion as the natural way to express computation.^[2]

Garbage collection. McCarthy's group implemented automatic garbage collection in Lisp 1.5 to manage the cons cells that proliferate during list processing, the first widely-used automatic memory management in a programming language.^[1][14]

First-class and higher-order functions. Functions can be passed as arguments, returned from other functions, and stored in data structures. The lambda expression, borrowed from Church's lambda calculus, gave programmers anonymous functions. Higher-order functions such as mapcar were standard idioms by the early 1960s.^[1][2]

Macros. Because programs are data, programs can be written that take programs as input and return new programs. Lisp macros are run at compile time and produce code, an unusually powerful form of metaprogramming.^[5][13]

Read-eval-print loop. The interactive REPL, in which the user types an expression and the system reads, evaluates, and prints it, was a defining feature of Lisp from Lisp 1.5 onward.^[1][6]

Dynamic typing. Lisp values carry their type at runtime, so the same variable can hold a number, a string, or a function. Dynamic typing was unusual in compiled languages of the 1960s and is now standard in scripting languages.^[1]

Symbolic computing. Numbers, strings, and lists in Lisp share the runtime with first-class symbols, atomic objects identified by name. Symbols make it natural to write programs that reason about formulas and rules, which is why Lisp was attractive for early symbolic AI work.^[2][7]

What does Lisp syntax look like?

Lisp's syntax is austere. Every program is built from atoms (symbols and literals) and lists, written as a sequence of elements between parentheses. A function call is a list whose first element is the operator and whose remaining elements are the arguments. There are no infix operators, no precedence rules, and no statement separators.^[1][2]

A recursive factorial in Common Lisp:

(defun factorial (n)
  (if (= n 0)
      1
      (* n (factorial (- n 1)))))

The defun form binds the symbol factorial to a function of one parameter n. The body is a single if expression: when n is zero the value is 1, otherwise the function multiplies n by (factorial (- n 1)). The same program in Scheme replaces defun with define.^[10][8]

"Hello, World" in Common Lisp:

(format t "Hello, World!~%")

The sea of parentheses is the most-commented feature of the syntax. Critics joked that LISP stood for "Lots of Irritating Spurious Parentheses." Practitioners argue the uniform structure pays back the visual cost: editors can manipulate code at the level of expressions, and the same parser that reads data also reads programs, which is what makes macros practical.^[13]

What are the major Lisp dialects?

Scroll sideways for more →

The table lists only landmarks. The combined Lisp family includes hundreds of named dialects, especially before the Common Lisp consolidation.^[5][11]

Common Lisp

Common Lisp is the largest member of the Lisp family among professional programmers outside Clojure and Scheme. It was designed by a committee in the early 1980s to unify the MacLisp-descended dialects of MIT, Carnegie Mellon, and the Lisp machine vendors. Common Lisp the Language (CLtL1) by Guy Steele was published in 1984, the second edition (CLtL2) in 1990, and the ANSI standard X3.226-1994 (now INCITS 226-1994) in 1994.^[10][11][15]

Common Lisp is multi-paradigm, with first-class support for functional, imperative, and object-oriented styles. It includes a full numeric tower of integers, ratios, floats, and complex numbers, with arbitrary-precision integer arithmetic in the standard. It defines a condition system more flexible than ordinary exception handling, letting the handler choose among several restarts that the signaling code provides.^[10]

The object system CLOS (Common Lisp Object System) supports multiple inheritance, multimethods that dispatch on the runtime type of every argument, before-after-around method combination, and a metaobject protocol. CLOS was incorporated into the standard during the CLtL2 work and influenced object systems in Dylan and Julia.^[10][11]

Major implementations include:

Scroll sideways for more →

SBCL is the de facto reference implementation in 2020s open-source work, producing native machine code with performance on numeric kernels competitive with C compiled by GCC.^[15]

Scheme

Scheme was created in 1975 by Gerald Sussman and Guy Steele at MIT, originally as part of an exploration of actor model ideas. The first description appeared in MIT AI Memo 349, Scheme: An Interpreter for Extended Lambda Calculus. The lasting innovation was lexical scope. Earlier Lisps were dynamically scoped; Scheme used the static, lexical binding rules familiar from Algol, which made closures and higher-order functions much easier to reason about.^[8][16]

Scheme is small. The language standard for many years could be printed in fewer than fifty pages, in deliberate contrast to the thousand-plus pages of Common Lisp the Language. The standard mandates tail-call optimization: a tail call must not consume additional stack, which lets programmers express loops as recursion without losing efficiency.^[8][17]

The Scheme community has standardized the language through a series of "Reports on the Algorithmic Language Scheme." R3RS (1986) defined the basic language; R4RS (1991) refined macros and numeric tower; R5RS (1998) became the long-running de facto standard at about 50 pages; R6RS (2007) was larger and more prescriptive but was partially rejected by the community; R7RS-small (2013) returned to minimalism and is widely supported.

Major implementations include MIT/GNU Scheme, Chez Scheme (now open source), Chicken, Gambit, Guile, and Racket, which began as PLT Scheme in 1995 and is the most mature Scheme-influenced platform with its own language tower and module system.^[18]

Scheme's most visible cultural artifact is the textbook Structure and Interpretation of Computer Programs by Hal Abelson and Gerald Sussman with Julie Sussman, published in 1985. SICP was the introductory programming textbook used in MIT's 6.001 course for two decades.^[19]

Clojure

Clojure is a Lisp dialect created by Rich Hickey and first released in October 2007. Hickey's goal was to bring Lisp to the Java Virtual Machine and the broader ecosystem of mainstream programmers, while updating the language for concurrent, multi-core hardware.^[20]

The central design decision is the embrace of immutable, persistent data structures. Clojure's lists, vectors, maps, and sets are implemented as variants of Bagwell's hash array mapped tries (HAMTs). Updating one of these structures returns a new structure that shares almost all of its memory with the old one. Identity is modeled separately from value through reference types (atoms, refs, agents, and vars), each with its own concurrency semantics. Refs participate in software transactional memory.^[20]

Clojure runs primarily on the JVM. A CLR port exists as ClojureCLR, and the most successful sibling project is ClojureScript, which compiles Clojure to JavaScript using Google's Closure compiler. ClojureScript has been visible in front-end web work using libraries such as Reagent and Re-frame.^[21]

Clojure has seen meaningful industrial adoption. Public users include Walmart Labs (Clojure powers their order management system), Nubank (one of the largest banks in Brazil migrated its core banking platform to Clojure), CircleCI, Funding Circle, and Cisco.^[22][23] The language also provides core.async, a library implementing Communicating Sequential Processes (CSP) style channels on top of macros, similar in spirit to Go's concurrency primitives.^[20]

Why was Lisp the language of AI?

Lisp's identification with artificial intelligence is no accident. McCarthy invented the language for AI research, and the major AI laboratories at MIT, Stanford, and Carnegie Mellon adopted it. From roughly 1962 through the late 1980s, if a graduate student was writing a thesis on natural language understanding, theorem proving, or expert systems, the code was almost certainly Lisp.^[3][4] The fit was structural: symbolic AI represents knowledge as symbols, rules, and trees, exactly the data Lisp manipulates natively, and the read-eval-print loop let researchers grow a program interactively rather than recompiling a batch job.^[2][3]

A partial roll call of classic AI systems written in Lisp:

Scroll sideways for more →

SHRDLU by Terry Winograd was an early demonstration that a program could understand English commands operating on a simulated world of blocks. It was written in MacLisp and MicroPlanner, and remains a milestone in natural language processing despite being limited to its closed domain.^[24]

MYCIN, developed at Stanford in the early 1970s by Edward Shortliffe, diagnosed bacterial infections and recommended antibiotics. It was never used clinically because of liability concerns, but it established the rule-base / inference-engine / explanation-facility architecture that defined a decade of expert system work. MYCIN was implemented in Interlisp.^[25]

XCON (originally R1) was an expert system written in OPS5 that configured VAX systems for Digital Equipment Corporation. By the mid-1980s DEC reported XCON was saving on the order of $25 million a year, the most-cited example of expert systems paying for themselves in industry.^[26]

Cyc, launched by Doug Lenat in 1984 at MCC, set out to encode hand-curated common-sense knowledge in formal logic. Cyc continues at Cycorp; its core inference language SubL is a Lisp dialect.^[27]

Prolog, the other major symbolic AI language, competed with Lisp through the 1970s and 1980s, especially in Europe and Japan, where the Fifth Generation Computer project bet on Prolog. In North America, Lisp stayed dominant.^[4]

How did the AI winter end Lisp's dominance?

The end of Lisp's reign came suddenly. By the late 1980s commercial expert systems were failing to live up to their hype, and the specialized Lisp machine industry collapsed when general-purpose RISC workstations running C-based code overtook them on price and performance. By 1987 a Sun workstation could run Lisp nearly as fast as a dedicated Lisp machine, and by 1990 it ran faster, erasing the specialized hardware's reason for being.^[31][38] The AI Winter of the late 1980s and early 1990s, together with the cost advantage of Unix workstations, pushed AI work in the 1990s toward C, C++, and MATLAB. By the time deep learning emerged in the 2010s, the dominant AI language had become Python.^[28][29]

Lisp machines

A Lisp machine was a workstation whose hardware was designed to execute Lisp efficiently. The architecture typically included tagged words for runtime type checking, microcoded instructions for fast cons, car, and cdr, and incremental garbage collection. The editor, compiler, debugger, window system, and operating system were all written in Lisp and could be inspected and modified at any time.^[30]

The MIT Lisp Machine Project began in 1973, led by Tom Knight. It produced the CADR machine in 1977, which became the basis for the commercial machines of the 1980s. The MIT lab spun off two competing companies:

• Symbolics, founded 1980 by MIT alumni including Russell Noftsker. Its 3600 series and later Ivory-based machines were the high-end Lisp workstations of the decade.
• Lisp Machines, Inc. (LMI), founded 1979 by Richard Greenblatt. LMI built the Lambda series.
• Texas Instruments Explorer, introduced 1984. TI licensed the LMI design, eventually shipping the microExplorer on a NuBus board for the Macintosh II.
• Xerox 1100 series (Dolphin, Dorado, Dandelion, Daybreak), the InterLisp-D Lisp machines from Xerox PARC.

Lisp machines were expensive. A Symbolics 3600-class system cost on the order of $100,000, while competing Sun, Apollo, and Silicon Graphics Unix workstations sold for roughly $20,000 to $40,000.^[31][38] The Lisp machine industry was small (perhaps a few thousand units shipped per year at peak) and depended on AI research funding. By 1987 to 1990 the AI Winter and the rise of cheaper Unix workstations from Sun, MIPS, and DEC made dedicated Lisp hardware uncompetitive. Lisp Machines, Inc. went bankrupt in 1987, and Symbolics filed for Chapter 11 bankruptcy in early 1993. Emulators of Symbolics Open Genera continued to run on Alpha and later x86 machines for niche customers.^[30][31]

Notable users and advocates

John McCarthy (1927 to 2011) invented Lisp and shared the 1971 Turing Award for his contributions to AI.^[1]

Marvin Minsky co-founded the MIT AI Laboratory with McCarthy in 1959 and used Lisp for work on knowledge representation, frames, and the Society of Mind theory.^[3]

Gerald Sussman and Guy Steele created Scheme and co-authored, with Hal Abelson, the SICP textbook that defined how computer science was taught at MIT for two decades.^[19]

Richard Stallman implemented Emacs Lisp and made it the extension language of GNU Emacs, ensuring that millions of programmers since 1985 have encountered Lisp through their text editor.^[12]

Paul Graham co-founded Viaweb in 1995, implemented primarily in Common Lisp and sold to Yahoo in 1998 for about $49 million in stock, becoming Yahoo Store. In his essay "Beating the Averages" (2001), Graham argued that Lisp gave the startup a quiet edge over rivals: "In fact we did have a secret weapon, but it was simpler than they realized. No one knew this, but the reason we were so far ahead was that we were using Lisp."^[32] His essays "Beating the Averages" and "Roots of Lisp" (2002) became canonical arguments for the productivity of Lisp in startups.^[13][32]

Rich Hickey created Clojure and ClojureScript and gave conference talks ("Simple Made Easy," "The Value of Values") that influenced software design beyond Lisp.^[20]

Peter Norvig wrote Paradigms of AI Programming: Case Studies in Common Lisp (1991), which presented Lisp implementations of unification, pattern matching, planners, and logic programming. He later directed research at Google and co-authored Artificial Intelligence: A Modern Approach with Stuart Russell.^[33]

Doug Lenat led Cyc from 1984 until his death in 2023; Cyc remained Lisp-based throughout.^[27]

Is Lisp still used today?

Lisp is no longer the dominant AI language and has not been since the early 1990s. It is still in active use in several niches.

Emacs and the Emacs Lisp ecosystem may be the largest single Lisp deployment in the world. Every Emacs user runs a Lisp interpreter that loads, byte-compiles, and executes Lisp packages as part of normal editor operation. The MELPA archive holds several thousand packages.^[12]

Clojure is the most commercially significant living Lisp. Stack Overflow developer surveys through the 2010s and 2020s have shown Clojure among the highest-paid programming languages, reflecting industrial use at Walmart, Nubank, Apple, Cisco, and many smaller fintech and analytics shops.^[22][23]

Common Lisp survives in computer algebra (Maxima, the open-source descendant of MACSYMA, is written in Common Lisp), in robotics, in commercial scheduling and constraint software (ITA Software's QPX airline fare search engine, acquired by Google in 2011, was a famously large Common Lisp system), and in the SBCL community.^[15][34]

AutoLISP, Autodesk's embedded dialect, has shipped in AutoCAD since 1986 and is used by tens of thousands of CAD users.^[5]

Newer dialects keep arriving: Hy (Lisp on the Python AST), Fennel (Lisp transpiling to Lua), and Janet (a small embeddable Lisp written in C). In machine learning, Lisp is largely absent from production code, which is dominated by Python wrapping C++ kernels.^[29]

Cultural and aesthetic notes

Greenspun's tenth rule. Articulated by Philip Greenspun: "Any sufficiently complicated C or Fortran program contains an ad-hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp." The rule is a joke about feature creep, but Lisp programmers cite it earnestly when defending the size of Common Lisp.^[35]

The parentheses jokes. The backronym "Lots of Irritating Spurious Parentheses" predates the Common Lisp era. The number of opening parens at the start of a line, sometimes ten or more in deeply nested code, has been a target for critics. Lisp users tend to point out that proper editor support makes the parentheses invisible in practice.^[13]

Reputation as elite or academic. Lisp's association with MIT and the lambda calculus gave it a reputation as a difficult, ivory-tower language. Paul Graham's contrarian framing was that this reputation came from the unfamiliarity of metaprogramming to programmers raised on lower-level languages.^[13]

Influence on later languages. Python's decorators, list comprehensions, and first-class functions descend from Lisp's higher-order programming. JavaScript's closures and dynamic typing were borrowed from Scheme by Brendan Eich, who said publicly that Netscape originally hired him to embed Scheme in the browser before he was redirected to design a new language with a more familiar syntax. Ruby, Julia, and lambda expressions in C++11 also trace back to Lisp.^[36][37]

See also

• John McCarthy, Common Lisp, Scheme, Clojure, Racket, Emacs Lisp
• Lisp machine, Symbolics, SICP, Paradigms of AI Programming
• S-expression, Lambda calculus, Garbage collection, REPL
• Macro (Lisp), Higher-order function, Tail call optimization
• Symbolic AI, Expert system, AI Winter, Cyc, Prolog, Fortran

References

1. McCarthy, J. (1979). "History of Lisp." https://www-formal.stanford.edu/jmc/history/lisp/lisp.html ↩
2. McCarthy, J. (1960). "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I." *CACM* 3(4). https://www-formal.stanford.edu/jmc/recursive.pdf ↩
3. Stoyan, H. (1984). "Early LISP History (1956 to 1959)." https://dl.acm.org/doi/10.1145/800055.802047 ↩
4. Russell, S., and Norvig, P. (2020). *Artificial Intelligence: A Modern Approach* (4th ed.). Pearson. ↩
5. Wikipedia. "Lisp (programming language)." https://en.wikipedia.org/wiki/Lisp_(programming_language) ↩
6. McCarthy, J. (1981). "History of Lisp." *History of Programming Languages* (Wexelblat, ed.), Academic Press. ↩
7. McCarthy, J., et al. (1962). *LISP 1.5 Programmer's Manual*. MIT Press. https://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf ↩
8. Sussman, G. J., and Steele, G. L. (1975). "Scheme: An Interpreter for Extended Lambda Calculus." MIT AI Memo 349. https://dspace.mit.edu/handle/1721.1/5794 ↩
9. Wikipedia. "Scheme (programming language)." https://en.wikipedia.org/wiki/Scheme_(programming_language) ↩
10. Steele, G. L. (1990). *Common Lisp the Language* (2nd ed.). https://www.cs.cmu.edu/Groups/AI/html/cltl/cltl2.html ↩
11. ANSI INCITS 226-1994. "Programming Language, Common Lisp." https://webstore.ansi.org/standards/incits/ansiincits2261994r2004 ↩
12. Stallman, R. (1981). "EMACS." MIT AI Memo 519a. https://www.gnu.org/software/emacs/emacs-paper.html ↩
13. Graham, P. (2002). "Roots of Lisp." https://paulgraham.com/rootsoflisp.html ↩
14. Wikipedia. "Garbage collection (computer science)." https://en.wikipedia.org/wiki/Garbage_collection_(computer_science) ↩
15. SBCL. "SBCL User Manual." http://www.sbcl.org/manual/ ↩
16. Wikipedia. "History of the Scheme programming language." https://en.wikipedia.org/wiki/History_of_the_Scheme_programming_language ↩
17. Sperber, M., et al. (2007). "Revised^6 Report on the Algorithmic Language Scheme." http://www.r6rs.org/ ↩
18. Felleisen, M., et al. (2018). "A Programmable Programming Language." https://cacm.acm.org/research/a-programmable-programming-language/ ↩
19. Abelson, H., and Sussman, G. J. (1985). *Structure and Interpretation of Computer Programs*. https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book.html ↩
20. Hickey, R. "Clojure rationale." https://clojure.org/about/rationale ↩
21. Wikipedia. "Clojure." https://en.wikipedia.org/wiki/Clojure ↩
22. Marcar, A. (2015). "Clojure at Scale: Walmart." https://www.youtube.com/watch?v=av9Xi6CNqq4 ↩
23. Pereira, A. (2019). "How Nubank Uses Clojure." https://www.infoq.com/news/2019/05/nubank-cognitect-clojure/ ↩
24. Winograd, T. (1971). "Procedures as a Representation for Data in a Computer Program for Understanding Natural Language." MIT AI TR 235. https://dspace.mit.edu/handle/1721.1/7095 ↩
25. Shortliffe, E. H. (1976). *Computer-Based Medical Consultations: MYCIN*. Elsevier. ↩
26. McDermott, J. (1982). "R1: A Rule-Based Configurer of Computer Systems." *AI* 19(1). https://doi.org/10.1016/0004-3702(82)90021-2 ↩
27. Lenat, D., and Guha, R. V. (1990). *Building Large Knowledge-Based Systems*. Addison-Wesley. ↩
28. Crevier, D. (1993). *AI: The Tumultuous History of the Search for Artificial Intelligence*. Basic Books. ↩
29. Hendler, J. (2008). "Avoiding Another AI Winter." https://ieeexplore.ieee.org/document/4475849 ↩
30. Newquist, H. (1994). *The Brain Makers*. Sams. ↩
31. Wikipedia. "Lisp machine." https://en.wikipedia.org/wiki/Lisp_machine ↩
32. Graham, P. (2001). "Beating the Averages." https://paulgraham.com/avg.html ↩
33. Norvig, P. (1991). *Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp*. Morgan Kaufmann. https://github.com/norvig/paip-lisp ↩
34. Wegrzanowski, T. (2010). "ITA Software, Common Lisp, and Google's Acquisition." https://www.infoq.com/news/2010/07/Google-ITA/ ↩
35. Wikipedia. "Greenspun's Tenth Rule." https://en.wikipedia.org/wiki/Greenspun%27s_tenth_rule ↩
36. Eich, B. (2008). "Popularity." https://brendaneich.com/2008/04/popularity/ ↩
37. Wikipedia. "History of Lisp." https://en.wikipedia.org/wiki/History_of_Lisp ↩
38. Symbolics. "Symbolics, Inc." https://en.wikipedia.org/wiki/Symbolics ↩