World inTimelines

Timeline of Lisp

The Lisp family from John McCarthy's work in 1958 to modern Common Lisp, Scheme, Racket, and Clojure through 2024: symbolic computation, Lisp machines, interactive tools, and language design.

Category
Engineering & Technology
Tag
computing
Events
18 events 1958 – 2024
Generated
by gpt-6

  1. McCarthy begins developing Lisp

    John McCarthy began developing Lisp at the Massachusetts Institute of Technology for symbolic computation and artificial intelligence. Steve Russell subsequently wrote its first interpreter. Lists represented both programs and data, giving the language a direct way to manipulate its own code.

    https://en.wikipedia.org/wiki/Lisp_(programming_language)

  2. McCarthy publishes Lisp's mathematical foundation

    John McCarthy published "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I." The paper described computation with symbolic expressions and an evaluator written in the language it evaluated, connecting practical programming with a compact mathematical model.

    https://en.wikipedia.org/wiki/John_McCarthy_(computer_scientist)

  3. Lisp 1.5 receives a programmer's manual

    The "LISP 1.5 Programmer's Manual" documented an implementation used for research and teaching. Its account of symbolic expressions, recursion, interpretation, and compilation helped make Lisp reproducible beyond its original laboratory.

    https://en.wikipedia.org/wiki/Lisp_(programming_language)

  4. Maclisp develops at Project MAC

    Researchers at the Massachusetts Institute of Technology developed Maclisp for their PDP-6 computer. The dialect later supported symbolic algebra and artificial intelligence research, and its conventions influenced Lisp-machine software and Common Lisp.

    https://en.wikipedia.org/wiki/Maclisp

  5. Interlisp unites language and development tools

    BBN Lisp became Interlisp as researchers at Bolt, Beranek and Newman and Xerox collaborated on its development. The system combined Lisp with debugging, editing, and program-maintenance tools, treating the programming environment as part of the language's practical design.

    https://en.wikipedia.org/wiki/Interlisp

  6. Sussman and Steele introduce Scheme

    Gerald Jay Sussman and Guy Steele introduced Scheme at the Massachusetts Institute of Technology. The small Lisp dialect used lexical scope and first-class procedures to investigate computation, helping clarify the relationship between function calls, continuations, and control flow.

    https://en.wikipedia.org/wiki/Scheme_(programming_language)

  7. The CADR Lisp machine enters service

    Researchers at the Massachusetts Institute of Technology introduced the CADR, a second-generation Lisp machine. Dedicated hardware supported an interactive Lisp environment with tagged data, automatic memory management, and graphical tools, avoiding competition for a shared mainframe.

    https://en.wikipedia.org/wiki/Lisp_machine

  8. Symbolics forms to commercialize Lisp machines

    Symbolics was founded to sell computers descended from the Massachusetts Institute of Technology's Lisp machines. The company developed hardware and an integrated software environment for applications including artificial intelligence, engineering, and computer graphics.

    https://en.wikipedia.org/wiki/Symbolics

  9. Steele documents a shared Common Lisp

    Guy Steele published "Common Lisp the Language," describing a common successor to several incompatible Lisp dialects. The specification brought together established language features so programs could move more readily between different implementations.

    https://en.wikipedia.org/wiki/Common_Lisp_the_Language

  10. GNU Emacs brings Lisp to everyday editing

    Richard Stallman publicly released GNU Emacs, whose editing commands and extensions were largely written in Emacs Lisp. Users could inspect and change the editor while it ran, giving Lisp a durable role in everyday software development.

    https://en.wikipedia.org/wiki/GNU_Emacs

  11. Abelson and Sussman teach through Scheme

    Harold Abelson and Gerald Jay Sussman, with Julie Sussman, published "Structure and Interpretation of Computer Programs." Scheme examples connected abstraction, interpreters, and programming styles, making a Lisp dialect central to an influential approach to computer science education.

    https://en.wikipedia.org/wiki/Structure_and_Interpretation_of_Computer_Programs

  12. Common Lisp gains a formal standard

    The American National Standards Institute standardized Common Lisp. The specification included the Common Lisp Object System, generic functions, conditions, and a substantial library, establishing a stable language contract across competing implementations.

    https://en.wikipedia.org/wiki/Common_Lisp

  13. Steel Bank Common Lisp branches from CMUCL

    Steel Bank Common Lisp began as a fork of Carnegie Mellon University Common Lisp. The new implementation reworked how the system was built and maintained while retaining an optimizing native-code compiler, extending Common Lisp's open-source implementation lineage.

    https://en.wikipedia.org/wiki/Steel_Bank_Common_Lisp

  14. Hickey releases Clojure for the Java platform

    Rich Hickey publicly released Clojure, a Lisp designed around immutable data and practical concurrency. Running on the Java virtual machine let Clojure programs use existing Java libraries while offering a different model for managing state.

    https://en.wikipedia.org/wiki/Clojure

  15. PLT Scheme becomes Racket

    The PLT Scheme project adopted the name Racket. The change reflected a system that had grown beyond implementing Scheme into a platform for building languages, with extensible syntax, teaching tools, and an integrated development environment.

    https://en.wikipedia.org/wiki/Racket_(programming_language)

  16. Scheme ratifies a new small-language standard

    The Scheme community ratified the small-language edition of its seventh revised report. The standard added libraries and other practical facilities while preserving a compact language, with a separate effort addressing a larger collection of libraries.

    https://en.wikipedia.org/wiki/Scheme_(programming_language)

  17. Racket adopts Chez Scheme by default

    Racket 8.0 made its Chez Scheme-based implementation the default. The switch replaced much of the earlier runtime and compiler with code written in Scheme and Racket, while maintaining compatibility with existing Racket programs.

    https://en.wikipedia.org/wiki/Racket_(programming_language)

  18. Clojure broadens its Java interoperability

    Clojure 1.12 added facilities including Java methods as values and easier use of Java functional interfaces. The release also improved interactive dependency loading, continuing the language's combination of Lisp development practices with the Java ecosystem.

    https://en.wikipedia.org/wiki/Clojure