Editing Lisp (programming language) (section)

==History==
{{Multiple image |direction=vertical |image1=John McCarthy Stanford.jpg |image2=Steve Russell.jpg |footer=[[John McCarthy (computer scientist)|John McCarthy]] (top) and [[Steve Russell (computer scientist)|Steve Russell]]}}

[[John McCarthy (computer scientist)|John McCarthy]] began developing Lisp in 1958 while he was at the [[Massachusetts Institute of Technology]] (MIT). He was motivated by a desire to create an AI programming language that would work on the IBM 704, as he believed that "IBM looked like a good bet to pursue Artificial Intelligence research vigorously."<ref name="wexelblat-history-programming-languages">{{cite book |title=History of programming languages |last1=McCarthy |first1=John |last2=Wexelblat |first2=Richard L. |year=1978 |isbn=0127450408 |publisher=Association for Computing Machinery |pages=173–183}}</ref> He was inspired by [[Information Processing Language]], which was also based on list processing, but did not use it because it was designed for different hardware and he found an algebraic language more appealing.<ref name="wexelblat-history-programming-languages" /> Due to these factors, he consulted on the design of the [[Fortran]] List Processing Language, which was implemented as a Fortran library. However, he was dissatisfied with it because it did not support [[Recursion (computer science)|recursion]] or a modern [[Conditional (computer programming)#If–then(–else)|if-then-else]] statement (which was a new concept when lisp was first introduced) {{NoteTag|At the time, Fortran had an if-then-else construct that accepted line numbers as jump targets, in the manner of a [[Goto]] statement, rather than accepting arbitrary expression in "then" and "else" blocks}}.<ref name="wexelblat-history-programming-languages" />

McCarthy's original notation used bracketed "[[M-expression]]s" that would be translated into [[S-expression]]s. As an example, the M-expression {{Lisp2|car[cons[A,B]]}} is equivalent to the S-expression {{Lisp2|(car (cons A B))}}. Once Lisp was implemented, programmers rapidly chose to use S-expressions, and M-expressions were abandoned.<ref name="wexelblat-history-programming-languages"/> M-expressions surfaced again with short-lived attempts of [[MLisp]]<ref name="Smith">{{cite book |last=Smith |first=David Canfield |title=MLISP Users Manual |url=http://www.softwarepreservation.org/projects/LISP/stanford/Smith-MLISP-AIM-84.pdf |access-date=2006-10-13}}</ref> by Horace Enea and [[CGOL]] by [[Vaughan Pratt]].

Lisp was first implemented by [[Steve Russell (computer scientist)|Steve Russell]] on an [[IBM 704]] computer using [[punched card]]s.<ref name="4VwQq">{{Cite web |url=http://jmc.stanford.edu/articles/lisp/lisp.pdf |title=History of Lisp: Artificial Intelligence Laboratory |last=McCarthy |first=John |date=12 February 1979}}</ref> Russell was working for McCarthy at the time and realized (to McCarthy's surprise) that the Lisp ''[[eval]]'' function could be implemented in [[machine code]].

According to McCarthy<ref name="k4CmX">{{cite conference |title=Early LISP history (1956–1959) |last1=Stoyan |first1=Herbert |date=1984-08-06 |page=307 |publisher=[[Association for Computing Machinery]] |book-title= |pages= |location= |conference=LFP '84: Proceedings of the 1984 ACM Symposium on LISP and functional programming |doi=10.1145/800055.802047|doi-access=free}}</ref>
{{Blockquote |text=Steve Russell said, look, why don't I program this ''eval''&nbsp;... and I said to him, ho, ho, you're confusing theory with practice, this ''eval'' is intended for reading, not for computing. But he went ahead and did it. That is, he [[Compiler|compiled]] the ''eval'' in my paper into [[IBM 704]] machine code, fixing [[Software bug|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&nbsp;...}}

The result was a working Lisp [[Interpreter (computing)|interpreter]] which could be used to run Lisp programs, or more properly, "evaluate Lisp expressions".

Two [[assembly language macros]] for the [[IBM 704]] became the primitive operations for decomposing lists: [[car and cdr|car]] (''Contents of the Address part of Register'' number) and [[car and cdr|cdr]] (''Contents of the Decrement part of Register'' number),<ref name="PREHISTORY">{{cite web |title=LISP prehistory - Summer 1956 through Summer 1958 |last=McCarthy |first=John |url=http://www-formal.stanford.edu/jmc/history/lisp/node2.html |access-date=2010-03-14}}</ref> where "register" refers to [[Processor register|registers]] of the computer's [[central processing unit]] (CPU). Lisp dialects still use {{Lisp2|car}} and {{Lisp2|cdr}} ({{IPAc-en|k|ɑːr}} and {{IPAc-en|ˈ|k|ʊ|d|ər}}) for the operations that return the first item in a list and the rest of the list, respectively.

McCarthy published Lisp's design in a paper in ''[[Communications of the ACM]]'' on April 1, 1960, entitled "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I"<ref>{{cite journal |last1=McCarthy |first1=John |title=Recursive functions of symbolic expressions and their computation by machine, Part I |url=https://dl.acm.org/doi/10.1145/367177.367199 |journal=Communications of the ACM |date=1960 |volume=3 |issue=4 |pages=184–195 |publisher=Association for computer machinery |doi=10.1145/367177.367199 |access-date=28 February 2025}}</ref>.<ref name="McCarthy">{{cite web |title=Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I |last=McCarthy |first=John |url=http://www-formal.stanford.edu/jmc/recursive.html |access-date=2006-10-13 |archive-url=https://web.archive.org/web/20131004215327/http://www-formal.stanford.edu/jmc/recursive.html |archive-date=2013-10-04}}</ref> He showed that with a few simple operators and a notation for anonymous functions borrowed from Church, one can build a [[Turing completeness|Turing-complete]] language for algorithms.

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.<ref name="Levin">{{cite web |title=AI Memo 39-The new compiler |last1=Hart |first1=Tim |last2=Levin |first2=Mike |url=ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-039.pdf |archive-url=https://web.archive.org/web/20170706114742/ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-039.pdf |archive-date=2017-07-06 |url-status=dead |access-date=2019-03-18}}</ref> This compiler introduced the Lisp model of [[incremental compiler|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 (computer science)|Garbage collection]] routines were developed by MIT graduate student [[Daniel Edwards (programmer)|Daniel Edwards]], prior to 1962.<ref>{{cite book |title=LISP 1.5 Programmer's Manual |url=http://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf |page=Preface |orig-date=1962 |year=1985 |version=15th printing |last1=McCarthy |first1=John |last2=Abrahams |first2=Paul W. |last3=Edwards |first3=Daniel J. |last4=Hart |first4=Timothy P. |last5=Levin |first5=Michael I. |edition=2nd}}</ref>

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 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".

=== Timeline ===
{{Lisp}}

===Connection to artificial intelligence===
Since inception, Lisp was closely connected with the [[artificial intelligence]] research community, especially on [[PDP-10]]<ref name="PYuEL">The 36-bit word size of the [[PDP-6]]/[[PDP-10]] was influenced by the usefulness of having two Lisp 18-bit pointers in a single word. {{cite newsgroup |quote=The PDP-6 project started in early 1963, as a 24-bit machine. It grew to 36 bits for LISP, a design goal. |url=http://groups.google.com/group/alt.folklore.computers/browse_thread/thread/6e5602ce733d0ec/17597705ae289112 |title=The History of TOPS or Life in the Fast ACs |newsgroup=alt.folklore.computers |message-id=84950@tut.cis.ohio-state.edu |date=18 October 1990 |author=Peter J. Hurley}}</ref> systems. Lisp was used as the implementation of the language [[Planner (programming 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.<ref>{{Citation |last1=Steele |first1=Guy L. |title=The evolution of Lisp |date=January 1996 |url=http://dl.acm.org/doi/10.1145/234286.1057818 |work=History of programming languages---II |pages=233–330 |editor-last=Bergin |editor-first=Thomas J. |place=New York, NY, US |publisher=ACM |language=en |doi=10.1145/234286.1057818 |isbn=978-0-201-89502-5 |access-date=2022-07-25 |last2=Gabriel |first2=Richard P. |editor2-last=Gibson |editor2-first=Richard G.|url-access=subscription }}</ref>

===Genealogy and variants===
Over its sixty-year history, Lisp has spawned many variations on the core theme of an S-expression language. Some of these variations have been standardized and implemented by different groups with different priorities (for example, both [[Common Lisp]] and [[Scheme (programming language)|Scheme]] have multiple implementations). However, in other cases a software project defines a Lisp without a standard and there is no clear distinction between the dialect and the implementation (for example, [[Clojure]] and [[Emacs Lisp]] fall into this category).

Differences between dialects (and/or implementations) may be quite visible—for instance, Common Lisp uses the keyword <code>defun</code> to name a function, but Scheme uses <code>define</code>.<ref name="jbyrI">Common Lisp: <code>(defun f (x) x)</code><br />Scheme: <code>(define f (lambda (x) x))</code> or <code>(define (f x) x)</code></ref> Within a dialect that is standardized conforming implementations support the same core language, but with different extensions and libraries. This sometimes also creates quite visible changes from the base language - for instance, [[GNU Guile|Guile]] (an implementation of Scheme) uses <code>define*</code> to create functions which can have [[default argument]]s and/or [[Named parameter|keyword arguments]], neither of which are standardized.

====Historically significant dialects====
[[File:LISP machine.jpg|thumb|right|A [[Lisp machine]] in the [[MIT Museum]]]]
[[File:4.3 BSD UWisc VAX Emulation Lisp Manual.png|thumb|[[4.3BSD]] from the [[University of Wisconsin]], displaying the [[man page]] for [[Franz Lisp]]]]
* LISP 1<ref name="Fs6VP">{{Cite book |last1=McCarthy |first1=J. |author-link=John McCarthy (computer scientist) |last2=Brayton |first2=R. |last3=Edwards |first3=D. |last4=Fox |first4=P. |author4-link=Phyllis Fox |last5=Hodes |first5=L. |author5-link=Louis Hodes |last6=Luckham |first6=D. |author6-link=David Luckham |last7=Maling |first7=K. |last8=Park |first8=D. |author8-link=David Park (computer scientist) |last9=Russell |first9=S. |author9-link=Steve Russell (computer scientist) |title=LISP I Programmers Manual |location=Boston |publisher=Artificial Intelligence Group, [[M.I.T. Computation Center]] and Research Laboratory |date=March 1960 |url=http://history.siam.org/sup/Fox_1960_LISP.pdf |archive-url=https://web.archive.org/web/20100717111134/http://history.siam.org/sup/Fox_1960_LISP.pdf |archive-date=2010-07-17}} Accessed May 11, 2010.</ref> – First implementation.
* LISP 1.5<ref name="1.5 manual">{{Cite book |url =http://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf |title=LISP 1.5 Programmer's Manual |publisher=[[MIT Press]] |first1=John |last1=McCarthy |first2=Paul W. |last2=Abrahams |first3=Daniel J. |last3=Edwards |first4=Timothy P. |last4=Hart |first5=Michael I. |last5=Levin |isbn=0-262-13011-4 |orig-date=1962 |edition=2nd |year=1985}}</ref> – First widely distributed version, developed by McCarthy and others at MIT. So named because it contained several improvements on the original "LISP 1" interpreter, but was not a major restructuring as the planned [[LISP 2]] would be.
* Stanford LISP 1.6<ref name="7q5x9">{{Cite book |last1=Quam |first1=Lynn H. |last2=Diffle |first2=Whitfield |url=http://www.softwarepreservation.org/projects/LISP/stanford/SAILON-28.6.pdf |title=Stanford LISP 1.6 Manual}}</ref> – A successor to LISP 1.5 developed at the [[Stanford AI Lab]], and widely distributed to [[PDP-10]] systems running the [[TOPS-10]] operating system. It was rendered obsolete by Maclisp and InterLisp.
* [[Maclisp]]<ref name="UNDMs">{{cite web |url=http://zane.brouhaha.com/~healyzh/doc/lisp.doc.txt |title=Maclisp Reference Manual |date=March 3, 1979 |archive-url=https://web.archive.org/web/20071214064433/http://zane.brouhaha.com/~healyzh/doc/lisp.doc.txt |archive-date=2007-12-14}}</ref> – developed for MIT's [[Project MAC]], MACLISP is a direct descendant of LISP 1.5. It ran on the PDP-10 and [[Multics]] systems. MACLISP would later come to be called Maclisp, and is often referred to as MacLisp. The "MAC" in MACLISP is unrelated to Apple's [[Macintosh]] or [[John McCarthy (computer scientist)|McCarthy]].
* [[Interlisp]]<ref name="5CtB3">{{Cite book |url=http://www.bitsavers.org/pdf/xerox/interlisp/1974_InterlispRefMan.pdf |title=InterLisp Reference Manual |first=Warren |last=Teitelman |year=1974 |access-date=2006-08-19 |archive-url=https://web.archive.org/web/20060602134835/http://www.bitsavers.org/pdf/xerox/interlisp/1974_InterlispRefMan.pdf |archive-date=2006-06-02}}</ref> – developed at [[BBN Technologies]] for PDP-10 systems running the [[TENEX (operating system)|TENEX operating system]], later adopted as a "West coast" Lisp for the Xerox Lisp machines as [[InterLisp-D]]. A small version called "InterLISP 65" was published for the [[MOS Technology 6502]]-based [[Atari 8-bit computers]]. Maclisp and InterLisp were strong competitors.
* [[Franz Lisp]] – originally a [[University of California, Berkeley]] project; later developed by Franz Inc. The name is a humorous deformation of the name "[[Franz Liszt]]", and does not refer to [[Allegro Common Lisp]], the dialect of Common Lisp sold by Franz Inc., in more recent years.
* [[muLISP]] – initially developed by Albert D. Rich and David Stoutemeyer for small microcomputer systems. Commercially available in 1979, it was running on CP/M systems of only 64KB RAM and was later ported to MS-DOS. Development of the MS-DOS version ended in 1995. The mathematical Software "Derive" was written in muLISP for MS-DOS and later for Windows up to 2007.
* [[XLISP]], which [[AutoLISP]] was based on.
* [[Standard Lisp]] and [[Portable Standard Lisp]] were widely used and ported, especially with the Computer Algebra System REDUCE.
* [[ZetaLisp]], also termed Lisp Machine Lisp – used on the [[Lisp machine]]s, direct descendant of Maclisp. ZetaLisp had a big influence on Common Lisp.
* [[LeLisp]] is a French Lisp dialect. One of the first [[Graphical user interface builder|Interface Builders]] (called SOS Interface<ref name="pq98z">[https://hal.archives-ouvertes.fr/file/index/docid/70041/filename/RT-0126.pdf Outils de generation d'interfaces : etat de l'art et classification by H. El Mrabet]</ref>) was written in LeLisp.
* [[Scheme (programming language)|Scheme]] (1975).<ref name="dp6Mp">{{cite web |author1=Gerald Jay Sussman |author2=Guy Lewis Steele Jr. |name-list-style=amp |title=Scheme: An Interpreter for Extended Lambda Calculus |website=[[MIT Computer Science and Artificial Intelligence Laboratory|MIT AI Lab]] |id=AIM-349 |date=December 1975 |url=https://dspace.mit.edu/bitstream/handle/1721.1/5794/AIM-349.pdf|access-date=23 December 2021}}</ref>
* [[Common Lisp]] (1984), as described by ''[[Common Lisp the Language]]'' – a consolidation of several divergent attempts (ZetaLisp, [[Spice Lisp]], [[NIL (programming language)|NIL]], and [[S-1 Lisp]]) to create successor dialects<ref name="Rb5BT">{{Cite book |chapter-url=https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node6.html |title=Common Lisp the Language |edition=2nd |chapter=Purpose |first=Guy L. Jr. |last=Steele |year=1990 |publisher=Digital Press |isbn=0-13-152414-3}}</ref> to Maclisp, with substantive influences from the Scheme dialect as well. This version of Common Lisp was available for wide-ranging platforms and was accepted by many as a [[de facto standard]]<ref name="Xvsoj">{{cite web |url=https://www.cs.cmu.edu/Groups/AI/html/faqs/lang/lisp/part2/faq-doc-13.html |title=History: Where did Lisp come from? |work=FAQ: Lisp Frequently Asked Questions 2/7 |date=20 February 1996 |first1=Mark |last1=Kantrowitz |first2=Barry |last2=Margolin}}</ref> until the publication of ANSI Common Lisp (ANSI X3.226-1994). Among the most widespread sub-dialects of Common Lisp are [[Steel Bank Common Lisp]] (SBCL), CMU Common Lisp (CMU-CL), Clozure OpenMCL (not to be confused with Clojure!), GNU CLisp, and later versions of Franz Lisp; all of them adhere to the later ANSI CL standard (see below).
* [[Dylan (programming language)|Dylan]] was in its first version a mix of Scheme with the Common Lisp Object System.
* [[EuLisp]] – attempt to develop a new efficient and cleaned-up Lisp.
* [[ISLISP]] – attempt to develop a new efficient and cleaned-up Lisp. Standardized as ISO/IEC 13816:1997<ref name="E4h75">{{cite web|url=http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=22987 |title=ISO/IEC 13816:1997 |publisher=Iso.org |date=2007-10-01 |access-date=2013-11-15}}</ref> and later revised as ISO/IEC 13816:2007:<ref name="xECKU">{{cite web|url=http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=44338 |title=ISO/IEC 13816:2007 |publisher=Iso.org |date=2013-10-30 |access-date=2013-11-15}}</ref> ''Information technology – Programming languages, their environments and system software interfaces – Programming language ISLISP''.
* IEEE [[Scheme (programming language)|Scheme]] – IEEE standard, 1178–1990 (R1995).
* ANSI [[Common Lisp]] – an [[American National Standards Institute]] (ANSI) [[Standardization|standard]] for Common Lisp, created by subcommittee [[X3J13]], chartered<ref name="CAXAD">{{cite web |url=http://www.nhplace.com/kent/CL/x3j13-86-020.html |title=X3J13 Charter}}</ref> to begin with ''Common Lisp: The Language'' as a base document and to work through a public [[Consensus decision-making|consensus]] process to find solutions to shared issues of [[Portability (software)|portability]] of programs and [[Computer compatibility|compatibility]] of Common Lisp implementations. Although formally an ANSI standard, the implementation, sale, use, and influence of ANSI Common Lisp has been and continues to be seen worldwide.
* [[ACL2]] or "A Computational Logic for Applicative Common Lisp", an applicative (side-effect free) variant of Common LISP. ACL2 is both a programming language which can model computer systems, and a tool to help proving properties of those models.
* [[Clojure]], a recent dialect of Lisp which compiles to the [[Java virtual machine]] and has a particular focus on [[Concurrency (computer science)|concurrency]].
* [[Game Oriented Assembly Lisp]] (or GOAL) is a video game programming language developed by [[Andy Gavin]] at [[Naughty Dog]]. It was written using Allegro Common Lisp and used in the development of the entire [[Jak and Daxter|Jak and Daxter series of games]] developed by Naughty Dog.

===2000 to present===
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 (programming language)|Scheme]], [[Emacs Lisp]], [[Clojure]], and [[Racket (programming language)|Racket]], and includes development of new portable libraries and applications.

Many new Lisp programmers were inspired by writers such as [[Paul Graham (computer programmer)|Paul Graham]] and [[Eric S. Raymond]] to pursue 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.<ref name="sKh98">{{cite web |title=The Road To Lisp Survey |url=http://wiki.alu.org/The_Road_To_Lisp_Survey |access-date=2006-10-13 |archive-url=https://web.archive.org/web/20061004031130/http://wiki.alu.org/The_Road_To_Lisp_Survey |archive-date=2006-10-04}}</ref> This increase in awareness may be contrasted to the "[[AI winter]]" and Lisp's brief gain in the mid-1990s.<ref name="nb7MB">{{cite web |url=http://www.faqs.org/docs/artu/ch14s05.html |title=Trends for the Future |publisher=Faqs.org |access-date=2013-11-15 |archive-date=2013-06-03 |archive-url=https://web.archive.org/web/20130603002452/http://www.faqs.org/docs/artu/ch14s05.html}}</ref>

{{As of|2010}}, there were eleven actively maintained Common Lisp implementations.<ref name="sWbGt">{{cite web|last=Weinreb|first=Daniel|title=Common Lisp Implementations: A Survey|url=http://common-lisp.net/~dlw/LispSurvey.html|access-date=4 April 2012|archive-url=https://web.archive.org/web/20120421181340/http://common-lisp.net/~dlw/LispSurvey.html|archive-date=2012-04-21}}</ref>

The [[open-source-software movement|open source]] community has created new supporting infrastructure: [[CLiki]] 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]]<ref>{{cite web|url=https://planet.lisp.org/|title=Planet Lisp|access-date=2023-10-12}}</ref> collects the contents of various Lisp-related blogs, on [[LispForum]]<ref>{{cite web|url=https://lispforum.com|title=LispForum|access-date=2023-10-12}}</ref> users discuss Lisp topics, [[Lispjobs]]<ref>{{cite web|url=https://lispjobs.wordpress.com/|title=Lispjobs|access-date=2023-10-12}}</ref> is a service for announcing job offers and there is a weekly news service, ''[[Weekly Lisp News]]''. ''Common-lisp.net'' is a hosting site for open source Common Lisp projects. [[Quicklisp]]<ref>{{cite web|url=https://www.quicklisp.org|title=Quicklisp|access-date=2023-10-12}}</ref> is a library manager for Common Lisp.

Fifty years of Lisp (1958–2008) was celebrated at LISP50@OOPSLA.<ref name="Q9GcA">{{cite web|url=http://www.lisp50.org/ |title=LISP50@OOPSLA |publisher=Lisp50.org |access-date=2013-11-15}}</ref> 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 [[Scheme (programming language)#Implementations|over twenty implementations]]. Several significant new implementations (Chicken, Gambit, Gauche, Ikarus, Larceny, Ypsilon) have been developed in the 2000s (decade). The Revised<sup>5</sup> Report on the Algorithmic Language Scheme<ref name="92GaL">[http://www.schemers.org/Documents/Standards/R5RS/ Documents: Standards: R5RS]. schemers.org (2012-01-11). Retrieved on 2013-07-17.</ref> 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 the R<sup>6</sup>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;<ref name="yVta1">{{cite news|url=http://cemerick.com/2009/03/24/why-mit-now-uses-python-instead-of-scheme-for-its-undergraduate-cs-program/|title=Why MIT now uses python instead of scheme for its undergraduate CS program|date=March 24, 2009|work=cemerick.com|access-date=November 10, 2013|archive-date=September 17, 2010|archive-url=https://web.archive.org/web/20100917102705/http://cemerick.com/2009/03/24/why-mit-now-uses-python-instead-of-scheme-for-its-undergraduate-cs-program/}}</ref><ref name="XOiAA">{{cite news|url=http://mitadmissions.org/blogs/entry/the_end_of_an_era_1|title=The End of an Era|first=Evan|last=Broder|date=January 8, 2008|work=mitadmissions.org|access-date=November 10, 2013}}</ref> MIT now uses [[Python (programming language)|Python]] instead of Scheme for its undergraduate [[computer science]] program and MITx massive open online course.<ref name="MITEECS-Python">{{cite web |title=MIT EECS Undergraduate Programs |url=https://www.eecs.mit.edu/academics-admissions/undergraduate-programs |website=www.eecs.mit.edu |publisher=MIT Electrical Engineering & Computer Science |access-date=31 December 2018}}</ref><ref name="MITx-Phyton">{{cite web |title=MITx introductory Python course hits 1.2 million enrollments |url=https://www.eecs.mit.edu/news-events/announcements/mitx-introductory-python-course-hits-12-million-enrollments |website=MIT EECS |publisher=MIT Electrical Engineering & Computer Science |access-date=31 December 2018}}</ref>

There are several new dialects of Lisp: [[Arc (programming language)|Arc]], [[Hy (programming language)|Hy]], [[Nu (programming language)|Nu]], [[Liskell]], and [[LFE (programming language)|LFE]] (Lisp Flavored Erlang). The parser for [[Julia (programming language)|Julia]] is implemented in Femtolisp, a dialect of [[Scheme (programming language)|Scheme]] (Julia is inspired by Scheme, which in turn is a Lisp dialect).

In October 2019, [[Paul Graham (programmer)|Paul Graham]] released [http://paulgraham.com/bel.html a specification for Bel], "a new dialect of Lisp."