What Is LISP?

Analogy categoryAnalogies

LISP, short for LISt Processing, was created by John McCarthy in 1958 at MIT, making it the second-oldest high-level programming language still in active use, after Fortran. McCarthy designed LISP for symbolic computation and artificial intelligence research, building the entire language around a single elegant data structure: the linked list. Unlike most languages of its era, LISP represents both programs and data using the same nested-list notation, a property that let researchers write programs capable of reasoning about, generating, and modifying other programs.

🏏

Cricket analogy: Think of LISP's 1958 debut like Sir Garfield Sobers redefining what an all-rounder could do in the 1960s: it set a template (list processing, recursion, symbolic computation) that shaped how later languages like Python and JavaScript would be built, decades before anyone called it a paradigm.

A Language Built on Lists

Every piece of LISP code is written as an S-expression, either an atom or a parenthesized list such as (+ 1 2). Because LISP code and LISP data share this exact same list structure, a property called homoiconicity, a LISP program can treat another program's source code as ordinary data: inspecting it, transforming it, and even generating new code at runtime. This is the foundation of LISP's powerful macro system and its long history in AI research, where programs needed to reason about rules and knowledge represented as symbolic lists.

🏏

Cricket analogy: A LISP S-expression like (+ 1 2) is like a scorecard entry: the same notation represents both the raw data and the instructions for how a match is being read, just as LISP code and LISP data share the identical list structure.

Why LISP Still Matters

LISP pioneered features that are now considered standard across the industry: automatic garbage collection, recursion as a primary control structure, dynamic typing, and first-class functions. Its macro system lets programmers extend the language itself by writing code that generates code at compile time, something few mainstream languages offer as naturally even today. For decades LISP was the dominant language of AI research, powering expert systems, genetic programming, and symbolic reasoning projects, and the Emacs text editor remains a living example of LISP's extensibility, since Emacs itself is written in and customized through Emacs Lisp.

🏏

Cricket analogy: LISP macros, which let you generate and transform code before it runs, are like a commentator scripting a custom highlights reel from raw match footage: you are writing a tool that produces the final broadcast, not just watching it passively.

Dialects: Common Lisp, Scheme, and Clojure

LISP is not a single language today but a family of dialects. Common Lisp, standardized in the ANSI X3.226-1994 specification, is a large, feature-rich language with an object system (CLOS) and an extensive standard library. Scheme, by contrast, was designed at MIT in the 1970s to be minimal and elegant, favored for teaching and language research. Clojure, created in 2007, is a modern dialect that runs on the Java Virtual Machine, adds native support for immutable data structures, and was designed from the ground up for concurrent programming. This course focuses on Common Lisp using the SBCL implementation.

🏏

Cricket analogy: Choosing among Common Lisp, Scheme, and Clojure is like choosing between Test cricket, ODIs, and T20: all three are recognizably cricket, but Common Lisp is the full five-day format with every rule included, Scheme is the pared-down T20, and Clojure is the newer hybrid built for the JVM stadium.

lisp

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

(factorial 5) ; => 120

LISP is the second-oldest high-level programming language still in active use today, after Fortran (1957); LISP followed in 1958. Its core ideas, recursion, conditionals, garbage collection, and treating code as data, directly influenced Python, JavaScript, Java, and Ruby.

LISP stands for LISt Processing and was created by John McCarthy in 1958 at MIT.
LISP represents both code and data as S-expressions (nested lists), a property called homoiconicity.
LISP pioneered features now considered standard: garbage collection, recursion as a primary control structure, and dynamic typing.
Major dialects include Common Lisp (feature-rich, standardized as ANSI X3.226-1994), Scheme (minimalist, popular for teaching), and Clojure (modern, JVM-based, built for concurrency).
LISP macros allow programmers to extend the language itself by writing code that generates code.
LISP was the dominant language of early AI research, powering expert systems and symbolic reasoning projects for decades.
The Emacs text editor is itself written in and extensible via Emacs Lisp, a dialect of LISP.