Misplaced Pages

#488511

67-468: The development of Scheme was heavily influenced by two predecessors that were quite different from one another: Lisp provided its general semantics and syntax, and ALGOL provided its lexical scope and block structure. Scheme is a dialect of Lisp but Lisp has evolved; the Lisp dialects from which Scheme evolved—although they were in the mainstream at the time—are quite different from any modern Lisp. Lisp

134-498: A Turing-complete language for algorithms. The use of s-expressions which characterize the syntax of Lisp was initially intended to be an interim measure pending the development of a language employing what McCarthy called " m-expressions ". As an example, the m-expression car[cons[A,B]] is equivalent to the s-expression (car (cons A B)) . S-expressions proved popular, however, and the many attempts to implement m-expressions failed to catch on. The first implementation of Lisp

201-530: A 15-bit register corresponding to segments of a 36-bit IBM 704 instruction word . The first complete Lisp compiler, written in Lisp, was implemented in 1962 by Tim Hart and Mike Levin at MIT. This compiler introduced the Lisp model of incremental compilation, in which compiled and interpreted functions can intermix freely. The two variants of Lisp most significant in the development of Scheme were both developed at MIT: LISP 1.5 developed by McCarthy and others, and Maclisp – developed for MIT's Project MAC ,

268-536: A decade earlier than Common Lisp, Scheme is a more minimalist design. It has a much smaller set of standard features but with certain implementation features (such as tail-call optimization and full continuations ) not specified in Common Lisp. A wide variety of programming paradigms, including imperative, functional, and message passing styles, find convenient expression in Scheme. Scheme continues to evolve with

335-533: A direct descendant of LISP 1.5. which ran on the PDP-10 and Multics systems. Since its inception, Lisp was closely connected with the artificial intelligence (AI) research community, especially on PDP-10 . The 36-bit word size of the PDP-6 and PDP-10 was influenced by the usefulness of having two Lisp 18-bit pointers in one word. ALGOL 58 , originally to be called IAL for "International Algorithmic Language",

402-407: A flexible and powerful form of dynamic dispatch . It has served as the template for many subsequent Lisp (including Scheme ) object systems, which are often implemented via a metaobject protocol , a reflective meta-circular design in which the object system is defined in terms of itself: Lisp was only the second language after Smalltalk (and is still one of the very few languages) to possess such

469-624: A great compliment because it transmits the full flavour of liberation: it has assisted a number of our most gifted fellow humans in thinking previously impossible thoughts. Largely because of its resource requirements with respect to early computing hardware (including early microprocessors), Lisp did not become as popular outside of the AI community as Fortran and the ALGOL -descended C language. Because of its suitability to complex and dynamic applications, Lisp enjoyed some resurgence of popular interest in

536-460: A language others considered antiquated. New Lisp programmers often describe the language as an eye-opening experience and claim to be substantially more productive than in other languages. This increase in awareness may be contrasted to the " AI winter " and Lisp's brief gain in the mid-1990s. As of 2010 , there were eleven actively maintained Common Lisp implementations. The open source community has created new supporting infrastructure: CLiki

603-554: A list, so the expression evaluates to the list ( 1 2 foo ) . The "quote" before the foo in the preceding example is a "special operator" which returns its argument without evaluating it. Any unquoted expressions are recursively evaluated before the enclosing expression is evaluated. For example, evaluates to the list ( 1 2 ( 3 4 )) . The third argument is a list; lists can be nested. Arithmetic operators are treated similarly. The expression Drew McDermott Drew McDermott (December 27, 1949 – May 26, 2022 )

670-445: A metaobject system. Many years later, Alan Kay suggested that as a result of the confluence of these features, only Smalltalk and Lisp could be regarded as properly conceived object-oriented programming systems. Lisp introduced the concept of automatic garbage collection , in which the system walks the heap looking for unused memory. Progress in modern sophisticated garbage collection algorithms such as generational garbage collection

737-507: A paper criticizing the logicist approach. The critique was based partly on a previous paper (with Steve Hanks ) pointing out a flaw with all known approaches to nonmonotonic temporal reasoning, embodied in what is now called the Yale shooting problem . Although new approaches have since been found, McDermott turned to other areas of AI, such as vision and robotics , and began working on automated planning again. His work on planning focused on

SECTION 10

#1732775769489

804-592: A paper in Communications of the ACM in April 1960, entitled "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I". He showed that with a few simple operators and a notation for anonymous functions borrowed from Church, one can build a Turing-complete language for algorithms. Information Processing Language was the first AI language, from 1955 or 1956, and already included many of

871-464: A series of AI Memos which have become collectively termed the Lambda Papers . Scheme was the first dialect of Lisp to choose lexical scope . It was also one of the first programming languages after Reynold's Definitional Language to support first-class continuations . It had a large impact on the effort that led to the development of its sister-language, Common Lisp , to which Guy Steele

938-764: A series of standards (Revised Report on the Algorithmic Language Scheme) and a series of Scheme Requests for Implementation . Clojure is a dialect of Lisp that targets mainly the Java virtual machine , and the Common Language Runtime (CLR), the Python VM, the Ruby VM YARV , and compiling to JavaScript . It is designed to be a pragmatic general-purpose language. Clojure draws considerable influences from Haskell and places

1005-515: A single language. The new language, Common Lisp , was somewhat compatible with the dialects it replaced (the book Common Lisp the Language notes the compatibility of various constructs). In 1994, ANSI published the Common Lisp standard, "ANSI X3.226-1994 Information Technology Programming Language Common Lisp". Since inception, Lisp was closely connected with the artificial intelligence research community, especially on PDP-10 systems. Lisp

1072-542: A solution to the problems with Planner. A partial implementation of Actors was developed called Planner-73 (later called PLASMA). Steele, then a graduate student at MIT, had been following these developments, and he and Sussman decided to implement a version of the Actor model in their own "tiny Lisp" developed on Maclisp , to understand the model better. Using this basis they then began to develop mechanisms for creating actors and sending messages. PLASMA's use of lexical scope

1139-437: A standard data structure—a quality much later dubbed " homoiconicity ". Thus, Lisp functions can be manipulated, altered or even created within a Lisp program without lower-level manipulations. This is generally considered one of the main advantages of the language with regard to its expressive power, and makes the language suitable for syntactic macros and meta-circular evaluation . A conditional using an if–then–else syntax

1206-565: A system called Micro-Planner which was a partial and somewhat unsatisfactory implementation of Carl Hewitt 's ambitious Planner project. Sussman and Hewitt worked together along with others on Muddle, later renamed MDL , an extended Lisp which formed a component of Hewitt's project. Drew McDermott, and Sussman in 1972 developed the Lisp-based language Conniver , which revised the use of automatic backtracking in Planner which they thought

1273-427: A very strong emphasis on immutability. Clojure provides access to Java frameworks and libraries, with optional type hints and type inference , so that calls to Java can avoid reflection and enable fast primitive operations. Clojure is not designed to be backwards compatible with other Lisp dialects. Further, Lisp dialects are used as scripting languages in many applications, with the best-known being Emacs Lisp in

1340-463: Is a family of programming languages with a long history and a distinctive, fully parenthesized prefix notation . Originally specified in the late 1950s, it is the second-oldest high-level programming language still in common use, after Fortran . 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 . Lisp

1407-413: Is a language so far ahead of its time that it was not only an improvement on its predecessors but also on nearly all its successors." ALGOL introduced the use of block structure and lexical scope. It was also notorious for its difficult call by name default parameter passing mechanism, which was defined so as to require textual substitution of the expression representing the working parameter in place of

SECTION 20

#1732775769489

1474-834: Is a weekly news service, Weekly Lisp News . Common-lisp.net is a hosting site for open source Common Lisp projects. Quicklisp is a library manager for Common Lisp. Fifty years of Lisp (1958–2008) was celebrated at LISP50@OOPSLA. There are regular local user meetings in Boston, Vancouver, and Hamburg. Other events include the European Common Lisp Meeting, the European Lisp Symposium and an International Lisp Conference. The Scheme community actively maintains over twenty implementations . Several significant new implementations (Chicken, Gambit, Gauche, Ikarus, Larceny, Ypsilon) have been developed in

1541-530: Is a wiki that collects Common Lisp related information, the Common Lisp directory lists resources, #lisp is a popular IRC channel and allows the sharing and commenting of code snippets (with support by lisppaste , an IRC bot written in Lisp), Planet Lisp collects the contents of various Lisp-related blogs, on LispForum users discuss Lisp topics, Lispjobs is a service for announcing job offers and there

1608-570: Is implemented in Femtolisp, a dialect of Scheme (Julia is inspired by Scheme, which in turn is a Lisp dialect). In October 2019, Paul Graham released a specification for Bel , "a new dialect of Lisp." Common Lisp and Scheme represent two major streams of Lisp development. These languages embody significantly different design choices. Common Lisp is a successor to Maclisp . The primary influences were Lisp Machine Lisp , Maclisp, NIL , S-1 Lisp , Spice Lisp , and Scheme. It has many of

1675-480: Is intended for reading, not for computing. But he went ahead and did it. That is, he compiled the eval in my paper into IBM 704 machine code, fixing bugs , and then advertised this as a Lisp interpreter, which it certainly was. So at that point Lisp had essentially the form that it has today ... The result was a working Lisp interpreter which could be used to run Lisp programs, or more properly, "evaluate Lisp expressions". Two assembly language macros for

1742-517: Is written as s-expressions , or parenthesized lists. A function call or syntactic form is written as a list with the function or operator's name first, and the arguments following; for instance, a function f that takes three arguments would be called as ( f arg1 arg2 arg3 ) . John McCarthy began developing Lisp in 1958 while he was at the Massachusetts Institute of Technology (MIT). McCarthy published its design in

1809-406: Is written with its elements separated by whitespace , and surrounded by parentheses. For example, ( 1 2 foo ) is a list whose elements are the three atoms 1 , 2 , and foo . These values are implicitly typed: they are respectively two integers and a Lisp-specific data type called a "symbol", and do not have to be declared as such. The empty list () is also represented as

1876-709: The Emacs editor, AutoLISP and later Visual Lisp in AutoCAD , Nyquist in Audacity , and Scheme in LilyPond . The potential small size of a useful Scheme interpreter makes it particularly popular for embedded scripting. Examples include SIOD and TinyScheme , both of which have been successfully embedded in the GIMP image processor under the generic name "Script-fu". LIBREP, a Lisp interpreter by John Harper originally based on

1943-547: The Emacs Lisp language, has been embedded in the Sawfish window manager . Lisp has officially standardized dialects: R6RS Scheme , R7RS Scheme , IEEE Scheme, ANSI Common Lisp and ISO ISLISP . Paul Graham identifies nine important aspects of Lisp that distinguished it from existing languages like Fortran : Lisp was the first language where the structure of program code is represented faithfully and directly in

2010-567: The IBM 704 became the primitive operations for decomposing lists: car ( Contents of the Address part of Register number) and cdr ( Contents of the Decrement part of Register number), where "register" refers to registers of the computer's central processing unit (CPU). Lisp dialects still use car and cdr ( / k ɑːr / and / ˈ k ʊ d ər / ) for the operations that return

2077-547: The LLVM , the Java virtual machine , x86-64, PowerPC, Alpha, ARM, Motorola 68000, and MIPS, and operating systems such as Windows, macOS, Linux, Solaris, FreeBSD, NetBSD, OpenBSD, Dragonfly BSD, and Heroku. Scheme is a statically scoped and properly tail-recursive dialect of the Lisp programming language invented by Guy L. Steele, Jr. and Gerald Jay Sussman . It was designed to have exceptionally clear and simple semantics and few different ways to form expressions. Designed about

History of the Scheme programming language - Misplaced Pages Continue

2144-516: The self-hosting compiler , and the read–eval–print loop . The name LISP derives from "LISt Processor". Linked lists are one of Lisp's major data structures , and Lisp source code is made of lists. Thus, Lisp programs can manipulate source code as a data structure, giving rise to the macro systems that allow programmers to create new syntax or new domain-specific languages embedded in Lisp. The interchangeability of code and data gives Lisp its instantly recognizable syntax. All program code

2211-583: The "classical" case rather than on hierarchical task network planning. In 1990 he was named a Fellow of the Association for the Advancement of Artificial Intelligence , one of the first group of Fellows. In 1996, McDermott (and Hector Geffner and Blai Bonet independently) discovered "estimated-regression planning," based on the idea of heuristic search with an estimator derived from a simplified domain model by reasoning backward ("regression") from

2278-484: The 2000s (decade). The Revised Report on the Algorithmic Language Scheme standard of Scheme was widely accepted in the Scheme community. The Scheme Requests for Implementation process has created a lot of quasi-standard libraries and extensions for Scheme. User communities of individual Scheme implementations continue to grow. A new language standardization process was started in 2003 and led to

2345-482: The 2010s. Lisp is an expression oriented language . Unlike most other languages, no distinction is made between "expressions" and "statements" ; all code and data are written as expressions. When an expression is evaluated , it produces a value (possibly multiple values), which can then be embedded into other expressions. Each value can be any data type. McCarthy's 1958 paper introduced two types of syntax: Symbolic expressions ( S-expressions , sexps), which mirror

2412-499: The Actor model. On the other hand, the Actor model is capable of expressing everything in the λ-calculus and more." He has also been critical of aspects of Scheme that derive from the lambda calculus such as reliance on continuation functions and the lack of exceptions. Between 1975 and 1980 Sussman and Steele worked on developing their ideas about using the lambda calculus, continuations and other advanced programming concepts such as optimization of tail recursion , and published them in

2479-729: The European Conference on Planning, became the annual International Conference on Automated Planning and Scheduling (ICAPS). He also helped start the International Planning Competition, which is held semiannually in conjunction with ICAPS. He led the group that molded the Planning Domain Definition Language from several predecessor notations in order to provide a standard notation for input to planning systems. A sideline of McDermott's work has been an interest in

2546-502: The Extensible Markup Language ( XML ). The reliance on expressions gives the language great flexibility. Because Lisp functions are written as lists, they can be processed exactly like data. This allows easy writing of programs which manipulate other programs ( metaprogramming ). Many Lisp dialects exploit this feature using macro systems, which enables extension of the language almost without limit. A Lisp list

2613-560: The Lisp model of incremental compilation , in which compiled and interpreted functions can intermix freely. The language used in Hart and Levin's memo is much closer to modern Lisp style than McCarthy's earlier code. Garbage collection routines were developed by MIT graduate student Daniel Edwards , prior to 1962. During the 1980s and 1990s, a great effort was made to unify the work on new Lisp dialects (mostly successors to Maclisp such as ZetaLisp and NIL (New Implementation of Lisp) into

2680-470: The R RS Scheme standard in 2007. Academic use of Scheme for teaching computer science seems to have declined somewhat. Some universities are no longer using Scheme in their computer science introductory courses; MIT now uses Python instead of Scheme for its undergraduate computer science program and MITx massive open online course. There are several new dialects of Lisp: Arc , Hy , Nu , Liskell , and LFE (Lisp Flavored Erlang). The parser for Julia

2747-462: The S-expression syntax is also responsible for much of Lisp's power: the syntax is simple and consistent, which facilitates manipulation by computer. However, the syntax of Lisp is not limited to traditional parentheses notation. It can be extended to include alternative notations. For example, XMLisp is a Common Lisp extension that employs the metaobject protocol to integrate S-expressions with

History of the Scheme programming language - Misplaced Pages Continue

2814-443: The Scheme implementation to be a backward step. 25 years later, in 1998, Sussman and Steele reflected that the minimalism of Scheme was not a conscious design goal, but rather the unintended outcome of the design process. "We were actually trying to build something complicated and discovered, serendipitously, that we had accidentally designed something that met all our goals but was much simpler than we had intended... we realized that

2881-554: The area of artificial intelligence , with side excursions into philosophy . His Ph.D. dissertation was in the area of automated planning . In that work, he coined the term "task network" to refer to hierarchies of abstract and concrete actions and policies. McDermott did seminal work in non-monotonic logic in the early 1980s and was an advocate for the "logicist" methodology in AI, defined as formalizing knowledge and reasoning in terms of deduction and quasideduction. In 1987, he published

2948-434: The closure and the Actor were, for the purposes of their investigation, essentially identical concepts. They eliminated what they regarded as redundant code and, at that point, discovered that they had written a very small and capable dialect of Lisp. Hewitt remained critical of the "hairy control structure" in Scheme and considered primitives (e.g., START!PROCESS , STOP!PROCESS , and EVALUATE!UNINTERRUPTIBLY ) used in

3015-602: The concepts, such as list-processing and recursion, which came to be used in Lisp. McCarthy's original notation used bracketed " M-expressions " that would be translated into S-expressions . As an example, the M-expression car[cons[A,B]] is equivalent to the S-expression ( car ( cons A B )) . Once Lisp was implemented, programmers rapidly chose to use S-expressions, and M-expressions were abandoned. M-expressions surfaced again with short-lived attempts of MLisp by Horace Enea and CGOL by Vaughan Pratt . Lisp

3082-418: The core theme of an S-expression language. Moreover, each given dialect may have several implementations—for instance, there are more than a dozen implementations of Common Lisp . Differences between dialects may be quite visible—for instance, Common Lisp uses the keyword defun to name a function, but Scheme uses define . Within a dialect that is standardized, however, conforming implementations support

3149-596: The features of Lisp Machine Lisp (a large Lisp dialect used to program Lisp Machines ), but was designed to be efficiently implementable on any personal computer or workstation. Common Lisp is a general-purpose programming language and thus has a large language standard including many built-in data types, functions, macros and other language elements, and an object system ( Common Lisp Object System ). Common Lisp also borrowed certain features from Scheme such as lexical scoping and lexical closures . Common Lisp implementations are available for targeting different platforms such as

3216-415: The first item in a list and the rest of the list, respectively. The first complete Lisp compiler, written in Lisp, was implemented in 1962 by Tim Hart and Mike Levin at MIT, and could be compiled by simply having an existing LISP interpreter interpret the compiler code, producing machine code output able to be executed at a 40-fold improvement in speed over that of the interpreter. This compiler introduced

3283-406: The formal parameter during execution of a procedure or function, causing it to be re-evaluated each time it is referenced during execution. ALGOL implementors developed a mechanism they called a thunk , which captured the context of the working parameter, enabling it to be evaluated during execution of the procedure or function. In 1971 Sussman, Drew McDermott , and Eugene Charniak had developed

3350-540: The goal. The simplified version is obtained automatically from a full domain model by ignoring propositions deleted by actions. In 2000, McDermott got interested in logic again because the development of the semantic web made it seem newly applicable. He did work on ontology translation and on semantic web services. McDermott was a prime mover, with James Hendler and others, behind the AI Planning Systems Conference, which, after merging with

3417-504: The internal representation of code and data; and Meta expressions ( M-expressions ), which express functions of S-expressions. M-expressions never found favor, and almost all Lisps today use S-expressions to manipulate both code and data. The use of parentheses is Lisp's most immediately obvious difference from other programming language families. As a result, students have long given Lisp nicknames such as Lost In Stupid Parentheses , or Lots of Irritating Superfluous Parentheses . However,

SECTION 50

#1732775769489

3484-407: The lambda calculus—a small, simple formalism—could serve as the core of a powerful and expressive programming language." On the other hand, Hewitt remained critical of the lambda calculus as a foundation for computation writing "The actual situation is that the λ-calculus is capable of expressing some kinds of sequential and parallel control structures but, in general, not the concurrency expressed in

3551-474: The same core language, but with different extensions and libraries. After having declined somewhat in the 1990s, Lisp has experienced a resurgence of interest after 2000. Most new activity has been focused around implementations of Common Lisp , Scheme , Emacs Lisp , Clojure , and Racket , and includes development of new portable libraries and applications. Many new Lisp programmers were inspired by writers such as Paul Graham and Eric S. Raymond to pursue

3618-406: The special atom nil . This is the only entity in Lisp which is both an atom and a list. Expressions are written as lists, using prefix notation . The first element in the list is the name of a function, the name of a macro, a lambda expression or the name of a "special operator" (see below). The remainder of the list are the arguments. For example, the function list returns its arguments as

3685-735: Was a contributor. The Scheme language is standardized in the official Institute of Electrical and Electronics Engineers (IEEE) standard, and a de facto standard called the Revised Report on the Algorithmic Language Scheme (R n RS). The most widely implemented standard is R5RS (1998), and a new standard, R6RS , was ratified in 2007. Besides the RnRS standards there are also Scheme Requests for Implementation documents, that contain additional libraries that may be added by Scheme implementations. Lisp (programming language) Lisp (historically LISP , an abbreviation of "list processing")

3752-491: Was a professor of Computer Science at Yale University . He was known for his contributions in artificial intelligence and automated planning . Drew McDermott earned B.S. , M.S. , and Ph.D. degrees from the Massachusetts Institute of Technology (MIT). He became a tenured full professor at Yale in 1983. He served as Chair of the Department from 1991 to 1995. He retired in 2018. McDermott's research has been in

3819-545: Was developed jointly by a committee of European and American computer scientists in a meeting in 1958 at ETH Zurich . ALGOL 60 , a later revision developed at the ALGOL 60 meeting in Paris and now commonly named ALGOL , became the standard for the publication of algorithms and had a profound effect on future language development, despite the language's lack of commercial success and its limitations. Tony Hoare has remarked: "Here

3886-404: Was first implemented by Steve Russell on an IBM 704 computer using punched cards . Russell had read McCarthy's paper and realized (to McCarthy's surprise) that the Lisp eval function could be implemented in machine code . According to McCarthy Steve Russell said, look, why don't I program this eval  ... and I said to him, ho, ho, you're confusing theory with practice, this eval

3953-420: Was influenced by Smalltalk, with later dialects adopting object-oriented programming features (inheritance classes, encapsulating instances, message passing, etc.) in the 1970s. The Flavors object system introduced the concept of multiple inheritance and the mixin . The Common Lisp Object System provides multiple inheritance, multimethods with multiple dispatch , and first-class generic functions , yielding

4020-403: Was invented by John McCarthy in 1958 while he was at the Massachusetts Institute of Technology (MIT). McCarthy published its design in a paper in Communications of the ACM in 1960, entitled "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I" (Part II was never published). He showed that with a few simple operators and a notation for functions, one can build

4087-511: Was invented by McCarthy for a chess program written in Fortran . He proposed its inclusion in ALGOL , but it was not made part of the Algol 58 specification. For Lisp, McCarthy used the more general cond -structure. Algol 60 took up if–then–else and popularized it. Lisp deeply influenced Alan Kay , the leader of the research team that developed Smalltalk at Xerox PARC ; and in turn Lisp

SECTION 60

#1732775769489

4154-410: Was on an IBM 704 by Steve Russell , who read McCarthy's paper and coded the eval function he described in machine code. The familiar (but puzzling to newcomers) names CAR and CDR used in Lisp to describe the head element of a list and its tail, evolved from two IBM 704 assembly language commands: Contents of Address Register and Contents of Decrement Register, each of which returned the contents of

4221-520: Was originally created as a practical mathematical notation for computer programs , influenced by (though not originally derived from) the notation of Alonzo Church 's lambda calculus . It quickly became a favored programming language for artificial intelligence (AI) research. As one of the earliest programming languages, Lisp pioneered many ideas in computer science , including tree data structures , automatic storage management , dynamic typing , conditionals , higher-order functions , recursion ,

4288-451: Was similar to the lambda calculus . Sussman and Steele decided to try to model Actors in the lambda calculus. They called their modeling system Schemer, eventually changing it to Scheme to fit the six-character limit on the ITS file system on their DEC PDP-10 . They soon concluded Actors were essentially closures that never return but instead invoke a continuation , and thus they decided that

4355-433: Was stimulated by its use in Lisp. Edsger W. Dijkstra in his 1972 Turing Award lecture said, With a few very basic principles at its foundation, it [LISP] has shown a remarkable stability. Besides that, LISP has been the carrier for a considerable number of in a sense our most sophisticated computer applications. LISP has jokingly been described as "the most intelligent way to misuse a computer". I think that description

4422-533: Was unproductive. Hewitt was dubious that the "hairy control structure" in Conniver was a solution to the problems with Planner. Pat Hayes remarked: "Their [Sussman and McDermott] solution, to give the user access to the implementation primitives of Planner, is however, something of a retrograde step (what are Conniver's semantics?)" In November 1972, Hewitt and his students invented the Actor model of computation as

4489-454: Was used as the implementation of the language Micro Planner , which was used in the famous AI system SHRDLU . In the 1970s, as AI research spawned commercial offshoots, the performance of existing Lisp systems became a growing issue, as programmers needed to be familiar with the performance ramifications of the various techniques and choices involved in the implementation of Lisp. Over its sixty-year history, Lisp has spawned many variations on

#488511