List of Lisp-family programming languages

Last updated

The programming language Lisp is the second-oldest high-level programming language with direct descendants and closely related dialects still in widespread use today. The language Fortran is older by one year. [1] [2] Lisp, like Fortran, has changed a lot since its early days, and many dialects have existed over its history. Today, the most widely known general-purpose Lisp dialects are Common Lisp and Scheme.

LanguageYear begunCreated by (at)CommentsReferences
Chialisp2019 Bram Cohen Powerful, secure LISP-like language for Chia blockchain to encumber and release funds with smart-contract abilities [3] [4] [5]
ACL2 1990 Robert Boyer,
J Moore,
Matt Kaufmann 		A Computational Logic for Applicative Common Lisp consists of a programming language, an extensible theory in a first-order logic, and a mechanical theorem prover [6]
Arc 2008 Paul Graham Dialect of Lisp developed by Paul Graham and Robert Morris [7]
AutoLISP 1986David BetzBuilt to include and use with the full version of AutoCAD and its derivatives [8]
BBN LISP 1966 BBN Based on L. Peter Deutsch's implementation of Lisp for PDP-1, which was developed from 1960 to 1964; in time language was expanded until it became its own separate dialect in 1966; later renamed Interlisp [9]
Chez Scheme 1985 R. Kent Dybvig Scheme dialect
Chicken 2000Felix WinkelmannScheme dialect
Clojure 2007 Rich Hickey Lisp dialect, emphasizes functional programming; runs on Java virtual machine, Common Language Runtime, and JavaScript engines; like other Lisps, treats code as data (homoiconicity) and has a macro system [10]
ANSI Common Lisp 1994ANSI X3J13 committeeCommon Lisp enhanced and standardized, published in ANSI standard document ANSI INCITS 226-1994; to the features of Common Lisp, it adds the loop macro, and the Common Lisp Object System (CLOS) to provide object-oriented programming paradigm with multiple dispatch (multimethods), and method combinations; runs on many platforms: Unix, Linux, macOS, Windows, JVM, JavaScript, Unix/C, LLVM/C++, Android, iOS [11]
Common Lisp1984Lisp dialect first standardized in a book, "Common Lisp the Language", by Guy L. Steele, [12] developed as a standardized and improved successor of Maclisp; statically and dynamically scoped; strongly-typed, allows (optional) type declarations; [13] separate namespaces for functions versus data variables, a trait often named Lisp-2; object-oriented programming is possible via libraries such as Flavors, CommonLOOPS, and later CLOS; treats code as data (homoiconicity) and has a macro system; The reader is extensible via reader macros [13] [11]
Dylan 1992 Apple Computer Mostly based on Scheme and Common Lisp, was designed as system and application programming language by Apple; first used to write an operating system and applications for internal prototypes of the later released Apple Newton computer; first official version of Apple Dylan also had s-expression based syntax; Apple collaborated with partners to develop this language
Emacs Lisp 1976 Richard Stallman Also termed Elisp, used by GNU Emacs and XEmacs text editors to implement most editing functions built into Emacs [14]
EuLisp 1990Statically and dynamically scoped Lisp dialect developed by a loose formation of industrial and academic Lisp users and developers across Europe; the standardizers intended to create a new Lisp "less encumbered by the past" (compared to Common Lisp), and not so minimalist as Scheme, and to integrate the object-oriented programming paradigm well [15]
Franz Lisp 1980 Richard Fateman Written at UC Berkeley by the students of Professor Richard J. Fateman, based largely on Maclisp and distributed with the Berkeley Software Distribution (BSD) for the Digital Equipment Corp (DEC) VAX [16]
Game Oriented Assembly Lisp (GOAL)2000s Andy Gavin Video game programming language developed by Andy Gavin and the Jak and Daxter team at Naughty Dog; written using Allegro Common Lisp; used in developing the full game series [17]
Hy 2013Paul TagliamonteA lisp with tight integration with Python
Ikarus 2007Abdulaziz GhuloumScheme dialect
Interlisp 1967 BBN Programming environment built around a version of Lisp language; development began in 1967 at Bolt, Beranek and Newman in Cambridge, Massachusetts as BBN LISP, which ran on PDP-10 machines running the TENEX operating system; when Danny Bobrow, Warren Teitelman, and Ronald Kaplan moved from BBN to Xerox PARC, it was renamed Interlisp [18]
ISLISP 1997WG16Small core language to help bridge the gap between differing Lisp dialects [19]
Le Lisp 1981 INRIA Designed by Jérôme Chailloux, Emmanuel St. James, INRIA [20] [21] [22]
Lisp Flavored Erlang (LFE)2008Robert VirdingLisp dialect built on Core Erlang and the Erlang virtual machine BEAM
Lisp Machine Lisp 1984Sometimes named Zetalisp, is a direct descendant of Maclisp; was developed in the mid to late 1970s as the systems programming language for the MIT Lisp machines [23]
Lispkit Lisp 1980Peter HendersonA lexically scoped, purely functional subset of Lisp ("Pure Lisp") developed as a testbed for functional programming concepts. [24]
Maclisp 1966 Project MAC Originated at MIT's Project MAC in late 1960s; based on Lisp 1.5; Richard Greenblatt was main developer of original codebase for the PDP-6; [25] Jon L. White was responsible for later maintenance and development [25]
MultiLisp 1980sRobert H. Halstead Scheme dialect, extended with constructs for parallel computing, executing, and shared memory; also had some unusual garbage collection and task scheduling algorithms [26]
NIL 1970s MIT 32-bit Lisp implementation developed at MIT; intended to be the successor to Maclisp; NIL stood for "New Implementation of LISP", and was in part a response to DECs VAX computer [27] [28]
OpenLisp 1988Christian Jullien ISLISP compatible language with many Common Lisp extensions; runs on most modern operating systems [29]
Owl Lisp2012Aki HelinPure functional Scheme dialect; based on applicable subset of the R7RS standard; has been extended mainly with threads and the data structures needed for purely functional operation [30]
PicoLisp 1988Alexander Burger Open-source Lisp dialect; runs on Linux and other POSIX-compliant systems; most prominent features are simplicity and minimalism [31]
Portable Standard Lisp 1980 University of Utah Tail-recursive dynamically bound Lisp dialect inspired by its predecessor, Standard Lisp and the Portable Lisp Compiler; it implements the Reduce computer algebra system
Racket 1994PLT Inc. General purpose, multi-paradigm programming language in the Lisp-Scheme family; one of its design goals is to serve as a platform for language creation, design, and implementation; it is used in many contexts such as scripting, general-purpose programming, computer science education, and research [32] [33]
Scheme 1970 Guy L. Steele,
Gerald Sussman 		Functional programming language with a minimalist design philosophy specifying a small standard core with powerful tools for language extension [12]
Scheme In One Defun (SIOD)1988George J. CarretteSmall Scheme implementation, written in C, made to embed in C programs
SKILL 1990 Cadence Design Systems Used as a scripting language and PCell description language used in many EDA software suites by Cadence [34]
T 1984Jonathan A. Rees,
Norman I. Adams		 Scheme dialect developed in the early 1980s by Jonathan A. Rees, Kent M. Pitman, and Norman I. Adams of Yale University as an experiment in language design and implementation [35]
TXR 2009Kaz KylhekuConsists of a Lisp dialect (TXR Lisp) and a pattern language for processing text (TXR Pattern Language) [36]

Timeline

Timeline of Lisp dialects
19581960196519701975198019851990199520002005201020152020
 LISP 1, 1.5, LISP 2(abandoned)
  Maclisp
  Interlisp
  MDL
  Lisp Machine Lisp
  Scheme  R5RS R6RS R7RS small
  NIL
  ZIL (Zork Implementation Language)
  Franz Lisp
  Common Lisp  ANSI standard
  Le Lisp
  MIT Scheme
  XLISP
  T
  Chez Scheme
  Emacs Lisp
  AutoLISP
  PicoLisp
  Gambit
  EuLisp
  ISLISP
  OpenLisp
  PLT Scheme   Racket
  newLISP
  GNU Guile
  Visual LISP
  Clojure
  Arc
  LFE
  Hy
  Chialisp

Related Research Articles

<span class="mw-page-title-main">Lisp (programming language)</span> Programming language family

Lisp is a family of programming languages with a long history and a distinctive, fully parenthesized prefix notation. Originally specified in 1960, Lisp is the third-oldest high-level programming language still in common use, after Fortran and COBOL. Lisp has changed since its early days, and many dialects have existed over its history. Today, the best-known general-purpose Lisp dialects are Common Lisp, Scheme, Racket, and Clojure.

<span class="mw-page-title-main">Scheme (programming language)</span> Dialect of Lisp

Scheme is a dialect of the Lisp family of programming languages. Scheme was created during the 1970s at the MIT Computer Science and Artificial Intelligence Laboratory and released by its developers, Guy L. Steele and Gerald Jay Sussman, via a series of memos now known as the Lambda Papers. It was the first dialect of Lisp to choose lexical scope and the first to require implementations to perform tail-call optimization, giving stronger support for functional programming and associated techniques such as recursive algorithms. It was also one of the first programming languages to support first-class continuations. It had a significant influence on the effort that led to the development of Common Lisp.

Maclisp is a programming language, a dialect of the language Lisp. It originated at the Massachusetts Institute of Technology's (MIT) Project MAC in the late 1960s and was based on Lisp 1.5. Richard Greenblatt was the main developer of the original codebase for the PDP-6; Jon L. White was responsible for its later maintenance and development. The name Maclisp began being used in the early 1970s to distinguish it from other forks of PDP-6 Lisp, notably BBN Lisp.

This is a "genealogy" of programming languages. Languages are categorized under the ancestor language with the strongest influence. Those ancestor languages are listed in alphabetic order. Any such categorization has a large arbitrary element, since programming languages often incorporate major ideas from multiple sources.

<span class="mw-page-title-main">Common Lisp Object System</span>

The Common Lisp Object System (CLOS) is the facility for object-oriented programming in ANSI Common Lisp. CLOS is a powerful dynamic object system which differs radically from the OOP facilities found in more static languages such as C++ or Java. CLOS was inspired by earlier Lisp object systems such as MIT Flavors and CommonLoops, although it is more general than either. Originally proposed as an add-on, CLOS was adopted as part of the ANSI standard for Common Lisp and has been adapted into other Lisp dialects such as EuLisp or Emacs Lisp.

In computer programming, M-expressions were an early proposed syntax for the Lisp programming language, inspired by contemporary languages such as Fortran and ALGOL. The notation was never implemented into the language and, as such, it was never finalized.

Le Lisp is a programming language, a dialect of the language Lisp.

<span class="mw-page-title-main">Franz Lisp</span> Lisp programming language system

In computer programming, Franz Lisp is a discontinued Lisp programming language system written at the University of California, Berkeley by Professor Richard Fateman and several students, based largely on Maclisp and distributed with the Berkeley Software Distribution (BSD) for the Digital Equipment Corporation (DEC) VAX minicomputer. Piggybacking on the popularity of the BSD package, Franz Lisp was probably the most widely distributed and used Lisp system of the 1970s and 1980s.

<span class="mw-page-title-main">Racket (programming language)</span> Lisp dialect

Racket is a general-purpose, multi-paradigm programming language and a multi-platform distribution that includes the Racket language, compiler, large standard library, IDE, development tools, and a set of additional languages including Typed Racket, Swindle, FrTime, Lazy Racket, R5RS & R6RS Scheme, Scribble, Datalog, Racklog, Algol 60 and several teaching languages.

Portable Standard Lisp (PSL) is a programming language, a dialect of the language Lisp. PSL was inspired by its predecessor, Standard Lisp and the Portable Lisp Compiler. It is tail-recursive, late binding, and was developed by researchers at the University of Utah in 1980, which released PSL 3.1; development was handed over to developers at Hewlett-Packard in 1982 who released PSL 3.3 and up. Portable Standard Lisp was available as a kit containing a screen editor, a compiler, and an interpreter for several hardware and operating system computing platforms, including Motorola 68000 series, DECSYSTEM-20s, Cray-1s, VAX, and many others. Today, PSL is mainly developed by and available from Konrad-Zuse-Zentrum für Informationstechnik Berlin (ZIB). Its main modern use is as the underlying language for implementations of Reduce.

Bigloo is a programming language, a dialect of the language Lisp, an implementation of the language Scheme. It is developed at the French IT research institute French Institute for Research in Computer Science and Automation (INRIA). It is oriented toward providing tools for effective and diverse code generation that can match the performance of hand-written C or C++. The Bigloo system contains a Scheme compiler that can generate C code and Java virtual machine (JVM) or .NET Framework (.NET) bytecode. As with other Lisp dialects, it contains an interpreter, also termed a read-eval-print loop (REPL). It is free and open-source software. The run-time system and libraries are released under a GNU Lesser General Public License (LGPL). The compiler and programming tools are released under a GNU General Public License (GPL).

ISLISP is a programming language in the Lisp family standardized by the International Organization for Standardization (ISO) and International Electrotechnical Commission (IEC) joint working group ISO/IEC JTC 1/SC 22/WG 16. The primary output of this working group was an international standard, published by ISO. The standard was updated in 2007 and republished as ISO/IEC 13816:2007(E). Although official publication was through ISO, versions of the ISLISP language specification are available that are believed to be in the public domain.

New Implementation of LISP (NIL) is a programming language, a dialect of the language Lisp, developed at the Massachusetts Institute of Technology (MIT) during the 1970s, and intended to be the successor to the language Maclisp. It is a 32-bit implementation, and was in part a response to Digital Equipment Corporation's (DEC) VAX computer. The project was headed by Jon L White, with a stated goal of maintaining compatibility with MacLisp while fixing many of its problems.

libffi is a foreign function interface library. It provides a C programming language interface for calling natively compiled functions given information about the target function at run time instead of compile time. It also implements the opposite functionality: libffi can produce a pointer to a function that can accept and decode any combination of arguments defined at run time.

The table shows a comparison of functional programming languages which compares various features and designs of different functional programming languages.

<span class="mw-page-title-main">Rosetta Code</span> Wiki-based programming chrestomathy

Rosetta Code is a wiki-based programming website with implementations of common algorithms and solutions to various programming problems in many different programming languages. It is named for the Rosetta Stone, which has the same text inscribed on it in three languages, and thus allowed Egyptian hieroglyphs to be deciphered for the first time.

In computer programming, self-hosting is the use of a program as part of the toolchain or operating system that produces new versions of that same program—for example, a compiler that can compile its own source code. Self-hosting software is commonplace on personal computers and larger systems. Other programs that are typically self-hosting include kernels, assemblers, command-line interpreters and revision control software.

References

  1. ↑ "SICP: Foreword". Archived from the original on 2001-07-27. Lisp is a survivor, having been in use for about a quarter of a century. Among the active programming languages only Fortran has had a longer life.
  2. ↑ "Conclusions". Archived from the original on 2014-04-03. Retrieved 2016-03-18.
  3. ↑ Cohen, Bram. "Chialisp". Chialisp.com.
  4. ↑ Cohen, Bram. "Bram Cohen". Twitter.
  5. ↑ Cohen, Bram (2019-11-27). "Introducing Chialisp". Chia Network. Retrieved 2022-04-08.
  6. ↑ "ACL2 Annotated Bibliography".
  7. ↑ Graham, Paul. "Arc FAQ" . Retrieved 2016-03-18.
  8. ↑ "AutoLISP" . Retrieved 14 April 2014.
  9. ↑ "BBN-LISP". Interlisp family. Software Preservation Group. Retrieved 17 March 2016.
  10. ↑ "Clojure". Clojure.org. Retrieved 2015-09-15.
  11. 1 2 "CLHS: About the Common Lisp HyperSpec: Authorship Information". LispWorks. Retrieved 2019-05-01.
  12. 1 2 Steele, Guy L. Jr. (1981). Common Lisp the Language, 2nd Ed. Digital Press. ISBN   978-1-55558-041-4. Common Lisp is a new dialect of Lisp, a successor to MacLisp, influenced strongly by ZetaLisp and to some extent by Scheme and InterLisp.
  13. 1 2 "Common Lisp the Language: Type declarations".
  14. ↑ "My Lisp Experiences and the Development of GNU Emacs". GNU. Retrieved 18 March 2016.
  15. ↑ "An Overview of EuLisp" (PDF). www.softwarepreservation.org. Retrieved 18 March 2016.
  16. ↑ Gabriel, Richard P (May 1985). Performance and evaluation of Lisp systems (PDF). MIT Press; Computer Systems Series. ISBN   0-262-07093-6. LCCN   85-15161.
  17. ↑ "[Sweng-gamedev] Higher Level Languages (Was: Next Gen Multiplatform Load Balancing)". Archived from the original on 12 April 2007.
  18. ↑ Teitelman, Warren (April 1972), "Do What I Mean", Computers and Automation: 8–11.
  19. ↑ "Programming Language ISLISP". Archived from the original on 22 January 2016. Retrieved 18 March 2016.
  20. ↑ Chailloux, Jérôme (1983). "LE LISP 80 version 12" (PDF). INRIA . Retrieved 16 March 2012.
  21. ↑ Chailloux, J.; Devin, M.; Hullot, J.M. (1984). "Le_Lisp, a portable and efficient Lisp system" (PDF). INRIA . Retrieved 16 March 2012.
  22. ↑ Chailloux, Jérôme (November 2001). Le_Lisp de l'INRIA: Le Manuel de référence. Version 14. Rocquencourt France: INRIA. p. 190.
  23. ↑ "Lisp Machine Manual" (PDF). MIT. Retrieved 18 March 2016.
  24. ↑ "The LispKit Manual (Volume 1)" (PDF). Oxford University. Retrieved 12 September 2022.
  25. 1 2 Levy, Steven (1984). Hackers: Heroes of the Computer Revolution . Doubleday. ISBN   0-385-19195-2.
  26. ↑ Halstead, R. H. "A Language for Concurrent Symbolic Computation" . Retrieved 2006-10-12.
  27. ↑ Gabriel, Richard P (May 1985). Performance and evaluation of Lisp systems (PDF). MIT Press; Computer Systems Series. ISBN   978-0-262-07093-5. LCCN   85015161.
  28. ↑ Steele, Guy L. Jr.; Gabriel, Richard P. "The evolution of Lisp" (PDF). Retrieved 2006-10-12.
  29. ↑ "Eligis: OpenLisp, ISLISP, ISO Lisp" . Retrieved 7 April 2018.
  30. ↑ "Owl Lisp" . Retrieved 2020-02-04.
  31. ↑ Burger, Alexander. "Internal structures". software-lab.de. Retrieved 18 March 2016.
  32. ↑ "Welcome to Racket" . Retrieved 2011-08-15.
  33. ↑ "Dialects of Racket and Scheme" . Retrieved 2011-08-15.
  34. ↑ Barnes, T.J. (1990). "SKILL: a CAD system extension language". Design Automation Conference, 1990. Proceedings., 27th ACM/IEEE. DAC'90. doi:10.1109/DAC.1990.114865.
  35. ↑ "The T Project". Jonathan Rees. Retrieved 18 March 2016.
  36. ↑ "TXR Language". Kaz Kylheku. Retrieved 31 August 2017.
This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.