Talk:Lisp (programming language)

Random "citations needed" are not
There are several places where someone has put the [citation needed] annotation, but it's just a language feature being described. For example, that symbols may appear in more than one place, but refer to the same object. I assert that example, for instance, needs no citation. Any of the language references will back that up (as will anyone who knows Lisp). I'd remove the silly ones myself, but I am not a Wikipedian and don't know how or what the protocol is. —Preceding unsigned comment added by 75.198.239.200 (talk) 08:24, 21 January 2009 (UTC)


 * Hi, the protocol is to be WP:BOLD and just do it. --MarSch (talk) 17:13, 22 January 2009 (UTC)

License
Proprietary or not --Melab-1 21:12, 4 September 2008 (UTC)


 * Some implementations of some Lisps are, some are not. --MarSch (talk) 17:17, 22 January 2009 (UTC)

Qi manual
The Qi manual pages 18-31 has a good discussion of the history of Lisp in terms of creating an RS for discussing the why various things happened. jbolden1517Talk 15:40, 12 April 2009 (UTC)


 * I took a look at this. Though I suppose it is an OK potted history for an introductory computer science book, it is not very good as history.  Besides ignoring all work in early programming languages other than Lisp, it also makes the completely incorrect claim that it was Lisp machines which introduced windowing, computer mice, and personal computing. And simply on technical grounds -- it is self-published by someone who is not a published expert in the history of computer languages -- it doesn't meet WP:RS criteria. --macrakis (talk) 20:39, 12 April 2009 (UTC)


 * OK thanks for taking the time to consider it. I found the windowing claims odd as well, but wasn't sure since smalltalk did have those (several years later) and those two communities were friendly....  But if that claim is wrong then no reason to endorse the history of LISP aspects.  jbolden1517Talk  21:15, 12 April 2009 (UTC)

Influenced
The "influenced" list is getting rather long and vague. Some of these are not confirmed either in the article on the language referenced or in the timeline of programming languages. I think the list should be restricted to languages whose primary influence was Lisp where Lisp was specifically mentioned as a primary influence by the language designer(s). Otherwise, we may end up with a list containing nearly every post-Lisp language, which is hardly useful. Yworo (talk) 15:27, 2 August 2009 (UTC)

Well, there are a lot of languages that are influenced by Lisp - no wonder, since Lisp is 50 years old and has lots of dialects. ML was first implemented in Lisp, Perl mentions Lisp as an influence, Python mentions Lisp, Smalltalk mentions Lisp, Ruby mentions Lisp, Dylan mentions Lisp,Mathematica does not mention Lisp but is influenced by it (Wolfram implemented an earlier version, SMP, in Lisp), Rebol mentions Lisp, Qi is implemented in Lisp, Lua mentions Lisp, Javascript mentions Scheme, Forth mentions Lisp, Nu mentions Lisp, ...

There are lots of languages that are not or very little influenced by Lisp: C, C++, Ada, Oberon, Modula 2, Pascal, Visual Basic, C#, PHP, D, and so on...

Joswig (talk) 23:34, 6 December 2009 (UTC)

Symbolic expressions, form a Recursive Functions system
The main influence is the use of lists in Functional Languages. Other influential work in modern languages (mainly functional) is APL that influenced John Backus seminal FP and FFP, and P.Landing work. Milner also influenced with ML. Prolog also uses lists, but is based in predicate logic.

I think it is enough to say that Lisp is one of the more influential programming languages.

However we may say the same of Fortran, all programming languages with assignment an control structures.

Is this genealogy the main subject about programming languages? It is not.

Procedural languages have a bottle-neck, the assignment. See John Backus, Can Programming Be Liberated From Von Neuman Style?, CACM, 1978.

I think it is more important to mention how Lisp evolved to a language based on Lambda-calculus, due to the work on denotational semantics (in the beginning of lisp it was not based on lambda-calculus). Scheme is a good example of that, and how it can be used to implement many programming languages, knowing it's denotational semantics. It could be included an example implementation of the while language from its denotational semantics.

This is to me a more influential role of this language, than a simple genealogy. — Preceding unsigned comment added by Elias (talk • contribs) 04:58, 9 March 2011 (UTC)

Who uses Lisp?
I think it would be nice to see a section on industrial uses of lisp. I.e., companies, etc which use Lisp in internal or for-sale software. Scheme (programming language) has such a section. 174.99.120.127 (talk) 20:30, 22 August 2009 (UTC)

Object-Oriented Language?
The term "object-oriented" has been morphed over the years. Lisp did pioneer it. It used to be more about the issue of objects being data structures referred to by pointers and having identity (not just being value copied all over the place), like the C# ref types, and less about how they were programmed. In the old meaning of "object-oriented", even things like symbols were thought to be "object-oriented" things, I claim. It wasn't until later that programming style and encapsulation came to use that term (and inappropriately, I think, but that's something we can debate elsewhere--for here all that matters is that there was an older usage and that it changed). I object to the recent change by Macrakis (22 Aug 2009 22:07) removing this reference, but didn't want to get into an edit war by changing it back, so am just noting my concern here: Just because someone has repurposed the name doesn't mean Lisp should claim no credit here, at least not without highlighting the shift in terminology. Articles that use "object-oriented" in the original way are not making up a false reality. See my essay [http://www.nhplace.com/kent/PS/Name.html What's in a Name? -- Uses and Abuses of Lispy Terminology] from Lisp Pointers, Volume VI, Number 1, January-March 1993, where I discussed the terminological shift as it was starting to gain a foothold. --Netsettler (talk) 16:58, 24 August 2009 (UTC)

Lisp based on lambda calculus?
In the second intro paragraph this article states that lisp was based on lambda calculus. I just read a transcript of a lecture McCarthy gave in which he said that he didn't understand lambda calc at the time and that lisp was not based on it.

1. http://www.computerhistory.org/search/?q=interview+John+McCarthy&site=chm_collection&client=chm_collection&output=xml_no_dtd

2. Click on the link that says "LOVE"  (Don't ask me why it says that)

3. Page 29

If the fact that it is a common misconception that lisp is based on lambda calc is not noted in the article, I think at the very least the statement that it WAS should be removed. — Preceding unsigned comment added by 198.29.2.254 (talk) 06:32, 18 September 2009 (UTC)

I think it is fair to say that Lisp is influenced by Lambda Calculus, but not based on Lambda Calculus.

Joswig (talk) 23:33, 6 December 2009 (UTC)


 * Yes, I thought I had edited this article to make this plain, but looking again I think the edit I made was on Scheme (programming language), where I wrote:
 * ''Alonzo Church's mathematical notation, the lambda calculus, has inspired Lisp's use of "lambda" as a keyword for introducing a procedure, as well as influencing the development of functional programming techniques involving the use of higher-order functions in Lisp. But early Lisps were not suitable expressions of the lambda calculus because of their treatment of free variables.


 * The introduction of lexical scope resolved the problem by making an equivalence between some forms of lambda notation and their practical expression in a working programming language. Sussman and Steele showed that the new language could be used to elegantly derive all the imperative and declarative semantics of other programming languages including ALGOL and Fortran, and the dynamic scope of other Lisps, by using lambda expressions not as simple procedure instantiations but as "control structures and environment modifiers."  They introduced continuation-passing style along with their first description of Scheme in the first of the Lambda Papers, and in subsequent papers they proceeded to demonstrate the raw power of this practical use of lambda calculus.


 * Of course that's a very Scheme-oriented way of looking at things, and obviously there's more to modern Lisp than Scheme. However it does show that lambda calculus inspired or influenced Lisp, but that at least originally lisp was not based on it.  Scheme can lay fair claim to being a dialect of Lisp that does implement a full-blooded form of lambda calculus, but that's another story. --TS 05:27, 7 December 2009 (UTC)


 * I think this is not quite true: "But early Lisps were not suitable expressions of the lambda calculus because of their treatment of free variables." The earliest, a-list-based Lisps (e.g. Lisp 1.5) did support lexical scope, but at the cost of expensive variable lookup.  Later lisps used implementation shortcuts that did not support full lexical scope (in the terminology of the time, they supported downwards but not upwards funargs).  See Joel Moses, "The Function of FUNCTION in LISP, or Why the FUNARG Problem Should be Called the Environment Problem", M.I.T. Project MAC Memo AI-199/MAC-M-428 (June 1970) full text. --macrakis (talk) 15:30, 7 December 2009 (UTC)
 * Thanks. I think you're right, and have for some time been vaguely aware that lexical scope was supported to a certain extent by Lisp 1.5 and even MACLisp.  I'm pondering how to express that in the Scheme article. Ultimately this concern will be part of the article on the history of Scheme and (if we ever get around to writing one) an article on the broader history of Lisp.  I think the key may be the level of consistency with which lexical scope is enforced in Scheme, in contrast to earlier Lisps. --TS 08:54, 8 December 2009 (UTC)

I also though that I have written this part :)
I came here because the entry McCarthy Formalism has many mistakes and I propose to remove that article. It is about the relation between Recursive functions and symbolic expressions.

As I told there, since McCarthy wrote "Recursive Functions of Symbolic Expressions ...", he presented a system equivalent o recursive functions. There is a correspondence between Zero an Nil, Succ and Cons, U and Car,Cdr, etc. McCarthy said in an article about Lisp circa 1980 in the CACM that he did not understood lambda-calculus at that time. Otherwise he did not had the error of dynamic binding the only thing that he would change if he could make time back.

This mistake should be fixed in this article (Lisp (programming language)). Besides that choice of Lambda expressions by McCarthy. There is another reason that makes many people (I was one of those) who think Lisp is based in lambda calculus. Newer dialects, maybe Scheme is the more elegant in this aspect, are used to teach programing languages by implementing it's Denotational semantics. Friedman et-al Esentials of programming languages, is a very good book with that approach. They show how to implement fixed point combinators in that strict language. You can teach how to write the factorial function using fixed point combinators, as it is done in the lambda-calculus. But that is another thing. I just say that such approach reinforces the myth that lisp was based in lambda calculus.

Anyway, I think both of you agree with me to correct this. In general I think this article is fine. Although it is more biased to a practical programmer point of view. That may introduce some resistance to make this correction. — Preceding unsigned comment added by Elias (talk • contribs) 05:17, 14 February 2011 (UTC)

BEE Lisp, possible spamming
Beware that anon users (194.154.66.35, 212.5.80.7, 212.5.80.7 again, others?) are adding BEE Lisp to various places in the article, including "Dialects" and "External links".

BEE Lisp is a commercial Lisp compiler, hence my worry that it's spam. If it is indeed a notable dialect - my apologies. 75.45.97.117 (talk) 12:04, 27 January 2010 (UTC)

BEE Lisp is indeed a totally new commercial product (likely based upon a free GPL implementation) and does not relate to any relevant dialect. I believe it is spam and should be removed. —Preceding unsigned comment added by 76.238.143.15 (talk) 21:11, 24 June 2010 (UTC)

"somehow compatible" ?
At the bottom of the History section, where Common Lisp is first mentioned, shouldn't "somehow compatible" be changed to "somewhat compatible"? Peter Delmonte (talk) 06:24, 20 February 2010 (UTC)

Lisp dialects
Why is there no information about muLisp? Why is it ommitted? —Preceding unsigned comment added by 84.193.134.35 (talk) 10:59, 11 July 2010 (UTC)
 * Probably just an oversight. I agree mulisp is historically interesting.  muLisp is mentioned in three entries but not as a hyperlink.  It deserves its own page if someone has information on it.  Portable Standard Lisp (PSL) is not mentioned either, and should be.  --Netsettler (talk) 16:28, 12 July 2010 (UTC)

History -> "at"?
The first line of the History section:
 * "Lisp was invented by John McCarthy in 1958 while he was at the Massachusetts Institute of Technology (MIT)."

"At" is ambiguous – was McCarthy attending MIT, or teaching there? Looking briefly over his article, it seems that it was the latter, but as I don't actually know, I thought I'd bring it up here and let someone with a bit more knowledge on the subject fix it. 69.105.38.18 (talk) 02:37, 4 August 2010 (UTC)


 * McCarthy was a professor at MIT. --FOo (talk) 21:09, 6 November 2010 (UTC)

Lisp is the second-oldest high-level language in use?
The article states Originally specified in 1958, Lisp is the second-oldest high-level programming language in widespread use today; only Fortran is older.

Is Lisp really in "widespread use" today? I mean, the modern dialects (eg, Common Lisp) are, but the Lisp dialects in use today are entirely different beasts than the Lisp that was created in 1958 - one could argue that they are derived languages, rather than dialects (or is C an ALGOL dialect?). Thats like saying that ALGOL is still in widespread use because ALGOL-derived languages are in widespread use today. —Preceding unsigned comment added by 89.101.42.6 (talk) 19:18, 10 September 2010 (UTC)


 * The Lisp dialects used today are a rather closer descendant of the early ones than C is of Algol. There wasn't a single Lisp standard in the early days; rather, every university or research group that built a Lisp system had a slightly different one -- but all of these were mutually recognized as being "Lisp". It's probably worth noting that CL was considered an effort to find common ground among existing dialects, rather than to create a wholly new language. In any event, '60s Lisp is recognizable as a Lisp today, whereas Algol doesn't really look like C. --FOo (talk) 21:08, 6 November 2010 (UTC)

Spelling?
Is the number 1178 in section "Historically significant dialects", link "IEEE Scheme – IEEE standard, 1178–1990 (R1995)" meant to be a year? —Preceding unsigned comment added by 130.92.9.55 (talk) 12:36, 4 November 2010 (UTC)
 * No, it really is 1178, not 1978. The number 1178 is part of the name of the standards document, the number after the dash denotes a specific revision (or the year, that revision was published). The IEEE Standards Association uses (mostly) numerical codes to identify the individual standards it publishes, like IEEE 754-2008 for the 2008 revision of the binary floating-point arithmetic standard, IEEE 1394 for FireWire, or IEEE 1541-2002 for the document defining standardized binary prefixes. Strictly speaking, I think, the number denotes the respective IEEE standards committee. &mdash; Tobias Bergemann (talk) 15:06, 4 November 2010 (UTC)

Asymptotic complexity of appending two lists.
I didn't want to change anything since all I know about lisp is what I've read so far in this article. But to me, it sounds fishy that the asymptotic complexity of appending two linked lists is O(n). — Preceding unsigned comment added by Enisbayramoglu (talk • contribs) 16:48, 8 September 2011 (UTC)


 * O(n) where n is the total length of all but the last list being appended. Append is O(1) for the last list. It takes n cdr operations just to get to the end of a length-n list in the standard representation; also O(n) to copy it (which you have to do for 'append').  Of course, it's possible to use other representations (see CDR coding and unrolled linked lists), but they have worse performance characteristics when modifying lists (RPLACD). --Macrakis (talk) 17:30, 8 September 2011 (UTC)

Clojure
I have done some basic editing of the various mentions of this Lisp dialect. I am not an expert in Lisp and therefore do not claim to know what its importance and notability are amongst hardcore Lisp programmers, but the claims of it being "one of the three most important dialects of Lisp" seem a bit overblown and are in any case unreferenced, so I have deleted that part.

I have also chopped out a couple of superlatives and tried to give any mentions a more neutral tone. Even so, a few relevant references would be welcome--until then, this would only be an "important" dialect because Wikipedia says so. — Preceding unsigned comment added by 92.243.22.61 (talk) 10:46, 19 April 2012 (UTC)


 * Answer:
 * http://wenshanren.org/?p=267 — Preceding unsigned comment added by 85.243.248.53 (talk) 09:01, 30 July 2013 (UTC)


 * Blogs are not reliable sources. Number of downloads from github is also not the same as popularity or importance. Real sources are needed which makes such judgments or statements, not some misguided blog evaluation via web statistics. Yworo (talk) 22:30, 30 July 2013 (UTC)


 * Many Lisp-related pages mention Clojure, usually implying that it is as significant as Scheme and Common Lisp. I wonder if all these mentions were inserted by the implementer of Clojure? 87.113.146.102 (talk) 13:25, 17 May 2014 (UTC)


 * I have removed the mention of 'Clojure' from the last sentence of the first paragraph. The cited book, Practical Clojure, which is a beginners guide to the language, only mentions that it is gaining momentum, not that it is one of 'the most widely known general-purpose Lisp dialects' or an equivalent statement. A better reference would be one that demonstrates its assertion with gathered data. Even then, It shouldn't be mentioned before Scheme and/or Common Lisp. Wickedjargon (talk) 21:16, 12 May 2015 (UTC)

Can someone tell me what 'hosted' means in 'Clojure, which is hosted,...'? Is the word too ambiguous or will most learned readers understand it based on context? Wickedjargon (talk) 16:13, 14 May 2015 (UTC)


 * Answer: The word 'hosted' definitely would need to be explained. Here it means that the Clojure language does not come with its own runtime and infrastructure. The main implementation uses the JVM for services like memory management, garbage collection, thread management, OS interface, loading of code, native code generation (via the JVM JIT) and more. Versions for the CLR (the Common Language Runtime from Microsoft) and Javascript use the respective runtimes of those. Also the main Clojure implementation has its compiler written in Java. This is in contrast to many other Lisp implementations which use their own runtime system directly on top of the operating system and have their compiler written in Lisp. For Common Lisp their are hosted implementations, too. For example ABCL for the JVM. Scheme: KAWA and several others. 'Hosted' has the advantage that the services of the runtime (say, JVM) can be reused and that integration with another language (say, Java) is easier. It also means that some typical Lisp facilities are not very well supported. For example for some reason Clojure usually has longer startup times, can't save images, does not support Tail Call Optimization (because the JVM does not directly support TCO), and stack backtraces during debugging expose a lot of JVM/Java internals, ...). The explanation of 'hosted' should be done in another article. For example in the Clojure Wikipedia article. Joswig (talk) 07:09, 19 May 2015 (UTC)

Formatting of Lisp2 macro
The Lisp2  macro is incompatible with the PDF generator. I would like to create a reference book about Lisp and some other topics to which this article links, but the Lisp2 macro is translated in the PDF generator to HTML markup (I have also entered this at the helpdesk).

When did "resurgence of interest" occur?
What does the word 'recently' mean in the following sentence?


 * "After having declined somewhat in the 1990s, Lisp has recently experienced a resurgence of interest."

Should not the word 'recently' be bannished from Wikipedia?

Where is the 'recently-bot'?

Jack-cnv (talk) 14:18, 2 January 2013 (UTC)

Lots of confusion
The article does not distinguish reader macros and evaluation. The evaluator takes an expression such as   and returns the atom  ; the evaluator never sees a thing that looks like  ; that beast is not a s-expression. The s-expression reader  makes use of reader macros that transform the character stream   into the s-expression  ; sometime later   may look at that expression and compute its value. In some sense, reader macros are outside of the language; when a Lisp program examines an s-expression, it never sees. Reader macros are examples of Moses' mud. Quasiquote is just a more powerful reader macro that makes an expression that builds the specified pattern.

The article also confuses the notion of operator and special form. Many languages treat  as an operator and use a different mechanism for functions such as. Lisp doesn't do that;  looks like an alphabetic character and it is used just like other (polymorphic) functions. A Lisp programmer can pass  as a functional argument; a FORTRAN programmer cannot do that (he must define his own ADD function). Lisp has special forms; it doesn't have operators in the sense of.

Consequently, the article loses the clean notion of. Glrx (talk) 04:02, 30 April 2013 (UTC)

Generational GC
I removed the claim that generational GC was originally developed for Lisp, it was in fact originally developed by David Ungar for a variant of Smalltalk-80 as evidenced here. Teslacuted (talk) 17:42, 5 August 2013 (UTC)


 * The edit in question about garbage collection (computer science). The original statement appears to be accurate, so I'm tempted to restore it. Original GC, Baker's copying, and generational appear to be motivated by Lisp.
 * David Ungar lists 1984 paper on generational garbage collection
 * http://www.cs.washington.edu/education/courses/cse501/03wi/slides/slides.03-06.pdf mention generation and cites to Ungar
 * http://c2.com/cgi/wiki?GenerationalGarbageCollection suggests Baker understood generation issue in 1983
 * Lieberman and Hewitt's paper, A Real-Time Garbage Collector Based on the Lifetimes of Objects, (LISP) is before 1984. http://web.media.mit.edu/~lieber/Lieberary/GC/Realtime/Realtime.html
 * also published in CACM, Volume 26, Issue 6, June 1983, Pages 419-429, doi 10.1145/358141.358147, http://dl.acm.org/citation.cfm?id=358147
 * http://www.cs.utexas.edu/users/mckinley/395Tmm-2003/talks/LH83.pdf cites to CACM June 1983
 * I don't know if L&H paper cites to Ungar.
 * Glrx (talk) 19:34, 26 August 2013 (UTC)

Ungar himself attributes Moon here. My mistake. Teslacuted (talk) 22:29, 28 August 2013 (UTC)


 * If it's any consolation, the original claim was not sourced. Glrx (talk) 23:12, 28 August 2013 (UTC)

Restored clearer factorial definition
I've reverted change of the basic factorial implementation to the previous version that used a simple 'if' statement. There's nothing at the if sentence that makes it less functional;the = comparison expression is more direct than a zerop predicate, and both the base and recursive cases are easier to read than guarded clauses. Remember that this page is intended for people that doesn't know Lisp yet. Diego Moya (talk) 21:09, 5 August 2013 (UTC)


 * The example as it is now is not clear to people who don't know Lisp -- or even to someone who studied it decades ago and has forgotten it.211.225.33.104 (talk) 07:05, 16 June 2014 (UTC)

Lacking good examples
Hi,

I'm a seasoned programmer and not very stupid. I understand lambda calculus and most simple procedural languages (C is my stock in trade). I used to program in FORTH a lot. I would have hoped that reading this article I could get a feel for the related LISP language. Sadly this article is deficient.

To put it simply (+ 1 2 3 4) evaluates 10. OK. Not as good as FORTH's reverse polish 1 2 3 4 + + + evaluates 10 --- but where do I go from here? Nothing in this article enables me to define (foo 1 2 3 4)! maybe I could perhaps use lambda but it's not clear how. Where does defun come from? In FORTH I can define a function: : FOO * + ; and 1 2 3 FOO would evaluate 7. I cannot read this article and do the same in LISP (I think).

To be any use this article *must* include a clear example of function definition. I make no apology for the fact that function definition may not be in the LISP paradigm. Tell me how to define (foo x y) or forget it.

kind regards, MikeMichaelbarclay (talk) 22:44, 17 October 2013 (UTC)

((God knows why the tildas mail me at michael.j.barclay@gmail.com I'm a real person and I'm trying to help))


 * The article gives many clear examples of function definition. Your function foo would be defined as (defun foo (a b c d) (+ a b c d)).  In some dialects of Lisp it could also be defined as something like (setq foo (lambda (a b c d) (+ a b c d))) -- see Lisp-1_vs._Lisp-2.
 * Re "evaluates 10..."; we don't say that the expression evaluates its value, but rather that Lisp/the Lisp system/the interpreter/the language system evaluates an expression and returns a value, e.g., "Lisp evaluates (+ 1 2) as 3" or "(+ 1 2) evaluates to 3".
 * Re "not as good as FORTH's ...", this article describes Lisp, it doesn't evaluate it as better or worse than other languages.
 * Re "where does defun come from": (defun f (a) b...) is a shorthand for (place-in-function-definition-slot-of-symbol 'f #'(lambda (a) b...)). The function definition slot may be on the symbol's property list (in early Lisps), in a special slot attached to the symbol (in most modern Lisps), or in the value slot (Lisp-1's with a single function namespace). --Macrakis (talk) 23:22, 17 October 2013 (UTC)

Undialects in infobox
I deem the following links in the "dialects" slot being not dialects: Rursus dixit. ( m bork3 !) 11:19, 10 January 2014 (UTC)
 * Racket, is a Scheme implementation,
 * T, is a Scheme implementation.

If Then Else
The article claimed: The ubiquitous if-then-else'' structure, now taken for granted as an essential element of any programming language, was invented by McCarthy for use in Lisp, where it saw its first appearance in a more general form (the cond structure). It was inherited by ALGOL, which popularized it.'' No quotation os given. If/Then/Else appears in Algol58 - as defined by the middle of 1958. At that time, Lisp had cond, if it existed. -- Zz (talk) 18:23, 4 June 2014 (UTC)
 * We see two references now. One is from Paul Graham and neither an independenrt nor an authoritative source about the history of Algol respectively Lisp. The other, by John McCarthy, even refutes the claim: I invented conditional expressions in connection with a set of chess legal move routines I wrote in FORTRAN for the IBM 704 at M.I.T. during 1957-58. This program did not use list processing. The IF statement provided in FORTRAN 1 and FORTRAN 2 was very awkward to use [...] This led to the invention of the true conditional expression which evaluates only one of N1 and N2 according to whether M is true or false and to a desire for a programming language that would allow its use. A paper defining conditional expressions and proposing their use in Algol was sent to the Communications of the ACM but was arbitrarily demoted to a letter to the editor, because it was very short. For one, it does not say If/Then/Else here, as claimed. Secondly, the development began in a Fortran context and it has been passed on directly to Algol58. So, Algol cannot have it from Lisp. -- Zz (talk) 19:16, 4 June 2014 (UTC)


 * These accounts do not seem inconsistent. McCarthy, while writing a Fortran program, adopted a COND or if-then-else structural paradigm; presumably he implemented it with Fortran's IF and GOTO.
 * McCarthy, while developing Lisp, creates the COND language form to realize the M/N1/N2.
 * McCarthy writes a paper proposing that Algol use if-then-else.
 * Glrx (talk) 19:11, 15 July 2014 (UTC)
 * Algol 60 had the first if-then-else conditional *statement*. There were many different syntax proposals for conditional statements during the Algol 58 design process, and most of them are very odd from a modern perspective: see . The `else` keyword came from the German members of the Algol 58 committee. The keyword `then` first appeared in an Algol 60 draft. McCarthy was involved with Algol. His name appears (with coauthors) on a proposal that includes a multi-branch conditional with no special syntax for an 'else' or for a default fallback clause.
 * McCarthy invented the conditional *expression*, which returns a value. His preferred syntax was (cond1 -> expr1, cond2 -> expr2, ...). There was no distinguished `else` clause: instead you used `T -> expr` as the final clause to specify a fallback. 209.183.136.7 (talk) 20:05, 19 April 2023 (UTC)

Second Oldest Programming Language
The article claims: Originally specified in 1958, Lisp is the second-oldest high-level programming language in widespread use today; only Fortran is older (by one year). Today's Lisp and Fortran dialects are at least as different to the originals as, for instance, C or Pascal are to Algol. The Algol family is so common that people care for fine details within, but for a claim of that strength, I would either expect a quote from a reputable source (in so far as it is held as a common view) or a working definition of language family. -- Zz (talk) 18:31, 4 June 2014 (UTC)
 * The reference given relates John McCarthy's personal views. Something more general is needed, preferably one that addresses the points above. -- Zz (talk) 19:25, 4 June 2014 (UTC)


 * I disagree. Today's Lisp and Fortran dialects have been extended, but they are still very similar. Some old programs will still run under new systems. That is not the case with feeding a C or Pascal program to an Algol compiler.
 * McCarthy is a significant authority, so his views are WP:DUE. Glrx (talk) 19:03, 15 July 2014 (UTC)
 * Unless something is a commonly held view, it is a general Wikipedia guideline to mark it as the opinion of the author. I see McCarthy as pretty relevant, but not the only view possible. If you think it is a majority view, find a source stating that.
 * The first sentence in the article states: Lisp (historically, LISP) is a family of computer programming languages[.]. So, it is an article about a family of languages - as opposed to what you claim. And I dare you to show me relevant Lisp 1.5 programs that run on current implementations. Without need, the second sentence changes the topic from the family of languages to one language and claims it to be second oldest. But things have happened in the meantime. There is no single Lisp anymore, and what we have now is different from the first Lisps. And if we go by language families, the Algol family is slightly older even. I propose to turn the second sentence into a statement that the Algol and the Lisp family of languages tie for second place in age. -- Zz (talk) 18:19, 16 July 2014 (UTC)
 * Actually the mainline Lisp dialects like Common Lisp (or Emacs Lisp) can relatively easy run old Lisp. They still have much of the core of the Lisp 1.5 language. Here is an example to load Lisp code from 1960 (Wang algorithm for propositional calculus): http://www.informatimago.com/develop/lisp/com/informatimago/small-cl-pgms/wang.html Joswig (talk) 23:52, 19 July 2014 (UTC)

The 1+ example is bogus
At least with regard to Common Lisp. The C x++ operator has a side effect but the Lisp (1+ x) is exactly equivalent to (+ x 1). incf would be a closer parallel to the C ++ operator. — Preceding unsigned comment added by Wolfamade (talk • contribs) 10:08, 30 January 2015 (UTC)

Why mention Peter Seibel's book in 2000-present section
The last sentence of the first paragraph in the section 2000-present reads "A new print edition of Practical Common Lisp by Peter Seibel, a tutorial for new Lisp programmers, was published in 2005." Aren't there many recently published books on Lisp? Why is this book mentioned specifically? The sentence doesn't connect with the previous and following text smoothly. This sentence should be removed. --Wickedjargon (talk) 00:15, 9 May 2015 (UTC)

Practical Common Lisp had a different approach for a Lisp introductory book. It focused on the ANSI Common Lisp standard including CLOS and Macros, It also came with more practical examples - not AI related (like Winston/Horn Lisp). It explained a bit more of the development style. It was published both freely online in HTML and as a printed book. Plus it was well written and showed good programming style. This made it a favorite in the Lisp community. http://www.lispforum.com/viewtopic.php?f=18&t=13  ITA/Google gave it to all new hires to learn Lisp. The Google Style Guide for Common Lisp says 'This guide is not a Common Lisp tutorial. For basic information about the language, please consult Practical Common Lisp.' https://google-styleguide.googlecode.com/svn/trunk/lispguide.xml Since it is the best current introduction to practical Lisp programming, I would recommend to have it mentioned. Joswig (talk) 07:18, 19 May 2015 (UTC)


 * I reverted [the book] as Wickedjargon suggested. The topic of the paragraph was the resurgence of Lisp, but the mere fact of publishing a book does not carry that implication. The implication is WP:SYN. Otherwise, it's a throw away sentence. Furthermore, WP is not meant to be an introductory book/tutorial to learn a language or a source of product or book reviews. Straw polls are not reliable secondary sources. WP uses sources to back up statements, so the book can be used to support statements about the language, but just stating publication in the body of the article is advertising. I have no qualms about listing it in EL or further reading -- and that is where it is mentioned already. Glrx (talk) 15:00, 19 May 2015 (UTC)

Revert to WickedJargon 12 May 2015
I'm trying to revert the article to 12 May 2015, but getting an exception thrown at me.

The intervening edits have confused the lisp timeline, confused the versions of Common Lisp, arbitrarily assigned major dialects, and do not have a neutral point of view wrt Clojure. Maclisp and Interlisp were major dialects in their day. A source given for Clojure denies the relevance of its ranking methodology; generally the Clojure sources are weak because they are biased: a non-Clojure non-JVM reference should be used to indicate prominence. Google searches about Clojure also turn up weak sources complaining about a single implementation, lack of specification, and a toy aspect. Compare multiple implementations of Common Lisp and Scheme.

Scheme has had its own conferences and was taught at major universities. Common Lisp is an ANSI standard; there were meetings and ballots. Both of them took significant steps advancing lisp compared to the contemporary Maclisp and LispM lisps.

The introduction of Clojure as a major dialect has been reverted many times in the past.

Glrx (talk) 23:49, 18 May 2015 (UTC)
 * clojure is used in professional applications, reliably multiply cited, reverted.


 * That's not the way this process works. See WP:BRD. You need to discuss here and get consensus. Glrx (talk) 14:41, 19 May 2015 (UTC)

Let's look at OMPIRE's edits.

Java as a language influenced by Lisp. The quote from Guy Steele is not a useful reference for Wikipedia. On the Java page Lisp is not mentioned at all. Sources which describe the Lisp influence on Java are not provided. Java may have some influence from Lisp (Gosling had implemented Mocklisp for his Emacs and Guy Steele worked on the Java standard document), but we would need useful references where this influence is described and what the consequences are.

The Clojure references are also not very convincing. Clojure is a popular Lisp derived language, but the quotes are more of a sensationalist type ('.You can bet that whatever language you are using in 10 years will be heavily influenced by Clojure').

The reordering of parts of the article fails to improve the article. Joswig (talk) 18:00, 26 May 2015 (UTC)

Undoing Loadmaster's revision at 15:13, 20 June 2015‎
I am undoing Loadmaster's revision for the following reasons. He changed the text...


 * from: "Among the active programming languages only Fortran..."


 * to: "Among still-active programming languages, only Fortran..."
 * Reason: The article here is quoting a book. You cannot change a quotation from a book.


 * from: "Like Fortran, Lisp has changed a great deal since its early days,"
 * to: "Like many older programming languages, Lisp has changed a great deal since its early days"


 * Reason: Disrupts the flow. (The previous sentence is on Fortran). Obfuscates the details. Fortran was a great example. No examples of "many older programming languages" are provided. "older" is too ambiguous. It may be misinterpreted as "around the same age as LISP/Fortran.

--Wickedjargon (talk) 06:49, 21 June 2015 (UTC)
 * from: "a function f that takes three arguments would be called"
 * To: "a function f that takes three arguments would be invoked as"
 * Reason: The term "call a function" is more popular than "invoke a function". Since in Lisp, a function cannot be invoked without also being called, why not stick with "called"?


 * (1) Maybe I missed it, but I see no indications of a quotation. Footnoting a sentence does not designate it to be a quotation. Unless it's a quoted extract from a source and clearly indicated as such, it's considered paraphrased text, which can be modified any way we see fit to make it more understandable.
 * (2) Why should we limit the comparison to Fortran? Other examples of older languages that have evolved over the decades include COBOL and RPG, which are still in use today.
 * (3) The word "called" also means "is named"; "invoke" has no such ambiguity.
 * — Loadmaster (talk) 14:53, 22 June 2015 (UTC)


 * The section is about Loadmaster's edit and Wickedjargon's revert. I agree with most of the revert.
 * (1) The evidence of a quotation is the cite web's  parameter. The quotation is inside a footnote.
 * (2) Yes, many languages have changed over time. Sticking with the specific "Fortran" instead of the vague "many older programming languages" is better. Would a reader know which languages have changed vs which haven't changed over time? I doubt the typical WP reader would be familiar with COBOL or RPG. I agree with Loadmaster's observation about other languages changing, but the Fortran example is specific.
 * (3) I'm not big on "called" vs "invoked", but the sentence has already indicated it ia about how to write a "function call". However, the original sentence is odd: "... would be called "; I would have used "called as". Certainly decorating "f" is an improvement.
 * Glrx (talk) 15:43, 22 June 2015 (UTC)
 * I agree Glrx's (3). Wickedjargon (talk) 01:05, 24 June 2015 (UTC)


 * I'm not going to belabor the discussion, but I will point out that
 * (1) per Quotations, the quotation is not visibly indicated as an inline quotation in the lede paragraph; and since it's not, it can be paraphrased. Or it can be labeled specifically as a quotation (e.g., by surrounding it with explicit quote marks).
 * (2) The "typical WP reader" would probably not be familiar with Fortran, either.
 * (3) "called as" is certainly clearer than "called". And if we are going to decorate the invocation (f a b c) then we should decorate the name f by itself also.
 * — Loadmaster (talk) 04:34, 3 July 2015 (UTC)
 * I don't understand what you mean by "it can be labeled specifically as a quotation (e.g., by surrounding it with explicit quote marks)". It is indeed surrounded by quotation marks. Check the second item under references in your revision. In regards to (3), those changes have been re-added. Wickedjargon (talk) 19:55, 3 July 2015 (UTC)


 * The sentence is not indicated explicitly as a quotation in the lede paragraph. I'm talking about paraphrasing the sentence in the lede paragraph, not the actual quoted text in the footnotes. — Loadmaster (talk) 02:37, 4 July 2015 (UTC)

(2) As a compromise, I changed the wording of the third lede sentence to: "Like Fortran and other older languages still in use, Lisp ...". — Loadmaster (talk) 22:07, 7 July 2015 (UTC)


 * The first two bullets of my original post refer to the changes you made in the footnotes, where you edited a quotation from a textbook. Next time Edit>Find in your browser to avoid confusion. Wickedjargon (talk) 14:47, 8 July 2015 (UTC)


 * Mea culpa. All of this time, I thought my edit was to (only) the lede para text. — Loadmaster (talk) 18:08, 9 July 2015 (UTC)

External links modified
Hello fellow Wikipedians,

I have just added archive links to 1 one external link on Lisp (programming language). Please take a moment to review my edit. If necessary, add after the link to keep me from modifying it. Alternatively, you can add to keep me off the page altogether. I made the following changes:
 * Added archive http://web.archive.org/web/20050617031004/http://www8.informatik.uni-erlangen.de:80/html/lisp-enter.html to http://www8.informatik.uni-erlangen.de/html/lisp-enter.html

When you have finished reviewing my changes, please set the checked parameter below to true to let others know.

Cheers.—cyberbot II  Talk to my owner :Online 11:26, 27 February 2016 (UTC)

Anybody have a reference for a Lisp n-tuple story?
Decades ago I was told a story about a bug in the Lisp printer, but I don't remember the speaker was. I know I've talked to Whitfield Diffy about his Lisp pretty printer, so maybe it came from him. I'm not sure.

Anyway, the original Lisp focused on n-tuples, so the original printer was supposed to print them out using typical paren and comma notation:. The routine had a bug, so it printed the tuples without commas (or put an odd comma at the end). People preferred the result without commas, so the commas were dropped. Glrx (talk) 04:41, 26 March 2016 (UTC)

Add examples of Scheme (and other dialects)
The examples in the Examples section looked quite okay to me, but I thought it would better reflect Lisp as a collection of dialects if we would add the same examples in Scheme and perhaps several other dialects (Clojure or any of the other newer dialects, or maybe one of the defunct dialects?).

I've been experimenting with tables of syntaxhighlights (the other way around - syntaxhighlights with tables in them - doesn't work), but (especially with the indentation taught in "Structure and Interpretation of Computer Programs") the examples aren't all of equal height in different dialects, which looks wrong as the content of the tables is. Maybe there is some way to extend the syntaxhighlight for a few extra lines? Whitespace doesn't work.

As for now, I've resorted to borderless tables and would like anyone to improve - with respect to WP editing, I've no idea what I'm doing --El-totsira (talk) 22:26, 22 June 2016 (UTC)


 * I've reverted recent modifications to the Examples section to provide CL/Scheme comparisons as inappropriate. There is little reason to compare the syntactic differences among implementations:  v.   is not interesting; some examples are identical save for that distinction. The Scheme version of   does not exploit a lexical accumulation; a CL version could exploit the same scoping. The comparisons do not show any fundamental distinctions in the language. Using an optional arg for the accumulation probably arose as a way of illustrating optional arguments, but it seems to be a poor method of computing a tail-recursive factorial. That macros exist and can create different syntax is not something to show by examples. Glrx (talk) 20:56, 27 June 2016 (UTC)

External links modified
Hello fellow Wikipedians,

I have just modified 2 external links on Lisp (programming language). Please take a moment to review my edit. If you have any questions, or need the bot to ignore the links, or the page altogether, please visit this simple FaQ for additional information. I made the following changes:
 * Added archive https://web.archive.org/web/20100717111134/http://history.siam.org/sup/Fox_1960_LISP.pdf to http://history.siam.org/sup/Fox_1960_LISP.pdf
 * Corrected formatting/usage for http://www.cl-user.net/asp/erw/sdataQIvH87hu8NU%24DM%3D%3D/sdataQo5Y-1Mh9urk

When you have finished reviewing my changes, you may follow the instructions on the template below to fix any issues with the URLs.

Cheers.— InternetArchiveBot  (Report bug) 21:29, 16 May 2017 (UTC)

C-style bracket closing?
Is it normal as shown in the examples to just pile up all the parenthesis in a huge blob? Keeping track of them seems difficult that way. But spacing them out across additional lines as with curly braces in C/C++ seems to improve readability.

(defun factorial (n)   (if (= n 0) 1 (* n (factorial (- n 1))))) vs something like: (defun factorial (n)   (if (= n 0) 1 (* n         (factorial (- n 1) )      )    ) ) --DMahalko (talk) 18:00, 29 May 2017 (UTC)


 * Yes, piling closing parens is absolutely normal, and using C-style positioning of them would be absolutely un-idiomatic. Lisp code is read by indentation, and any Lisp IDE will automatically format the code that way and will make balancing of the parens and navigating the expression tree convenient. See e.g. the corresponding chapter of the GNU Emacs manual. Tea2min (talk) 14:33, 30 May 2017 (UTC)


 * No, other way is to separate with spaces parenthesis opened in previous lines. For example:
 * (defun factorial (n)
 * (if (= n 0) 1
 * (* n (factorial (- n 1))) ))
 * or
 * (defun factorial (n)
 * (if (= n 0) 1
 * (* n (factorial (- n 1))) ) )
 * where indenting shows the structure, the spaces separating parens allow us to see how they match. — Preceding unsigned comment added by 2806:107E:C:2568:218:DEFF:FE2B:1215 (talk) 12:27, 4 April 2018 (UTC)

External links modified
Hello fellow Wikipedians,

I have just modified 2 external links on Lisp (programming language). Please take a moment to review my edit. If you have any questions, or need the bot to ignore the links, or the page altogether, please visit this simple FaQ for additional information. I made the following changes:
 * Added archive https://web.archive.org/web/20160408134008/http://julia.readthedocs.org/en/latest/manual/introduction/ to http://julia.readthedocs.org/en/latest/manual/introduction/
 * Added tag to https://quachquynh.com/wp-content/uploads/2023/05/AIM-349.pdf
 * Added archive https://web.archive.org/web/20080905110332/http://cl-user.net/ to http://www.cl-user.net/

When you have finished reviewing my changes, you may follow the instructions on the template below to fix any issues with the URLs.

Cheers.— InternetArchiveBot  (Report bug) 04:03, 24 December 2017 (UTC)

It is a tradition to learn LISP writing a LISP interpreter, making it a formative language
I don't have references for this assertion, but just browse many LISP courses.

A simple interpreter is very easy to write, because the eval function is the kernel of the interpreter. For that reason it became a tradition to learn LISP building the interpreter. Garbage collection is not always included in such courses, unless they are advanced.

Some times the LISP interpreter is written in some LISP dialect, other times the basic LISP functions are implemented in other programming language, in such case also an S-Expression parser is also build.

A programmer who learn to build a parser, represent data structures and even implement a garbage collection algorithm, acquire key knowledge for programmers.

That tradition in great part the reason that produced many LISP dialects. It was great, because LISP also became an ideal language to experiment with. Adding other features like extending it with problem solving features and logic programming.

I know that from my experience, but can not cite some study about this particular feature which is absent in the learning of the major part of languages.

Although some languages express their semantics in a circular form, i.e. by a program in the same language that interpret it. That is a way to show that such language is like an Universal Turing Machine, a Turing Machine that can be programmed to work as a ny Turing Machine, the idea in which John von Neumann based the stored program machine architecture.

Unfortunately in now days, the semantics of many popular programming languages is only described in natural language, i.e. plain English.

I am tempted to add a section, maybe titled LISP training to describe the advantage of LISP to develop a more structured mind. — Preceding unsigned comment added by 2806:107E:C:2568:218:DEFF:FE2B:1215 (talk) 09:31, 5 April 2018 (UTC)

Requested move 20 February 2019

 * The following is a closed discussion of a requested move. Please do not modify it. Subsequent comments should be made in a new section on the talk page. Editors desiring to contest the closing decision should consider a move review after discussing it on the closer's talk page. No further edits should be made to this section. 

The result of the move request was: CONSENSUS TO NOT MOVE. Crlf0710 (talk) 12:36, 27 February 2019 (UTC)

Lisp (programming language) → Lisp (programming language family) – This article is about the Lisp programming language family, not the member with name LISP 1.5 or another one. Crlf0710 (talk) 19:31, 20 February 2019 (UTC)

UPDATE: I changed my mind and am giving up the renaming proposal. Crlf0710 (talk) 12:32, 27 February 2019 (UTC)

Survey

 * Feel free to state your position on the renaming proposal by beginning a new line in this subsection with  or  , then sign your comment with  . Since polling is not a substitute for discussion, please explain your reasons, taking into account Wikipedia's policy on article titles.


 * (I requested this move) Crlf0710 (talk) 17:11, 21 February 2019 (UTC)
 * I've struck your !vote as your nom already counts per Requested_moves. --В²C ☎ 18:54, 26 February 2019 (UTC)
 * ok, i've add a redirect from Template:Strikeout to Template:Strikethrough to make it appear correct. — Preceding unsigned comment added by Crlf0710 (talk • contribs) 11:52, 27 February 2019 (UTC)
 * Support as semantically correct. Curly "JFC" Turkey 🍁 ¡gobble! 23:16, 21 February 2019 (UTC)
 * Oppose. Doesn't comport with usual practice either inside Wikipedia or outside and is not a title the reader is likely to expect for this topic, violating the spirit of WP:COMMONNAME.  Pascal (programming language family) is a redlink, although admittedly there are more Lisp dialects than Pascal dialects.  Even C (programming language) has many dialects, as does the English language, but the article is not titled English language family.  The title Lisp (programming language) is readily understood by readers.  This is a solution in search of a problem. Quale (talk) 06:15, 23 February 2019 (UTC)
 * Taking your Pascal example, Pascal (programming language) seldom talks about Delphi (programming language), and LISP (programming language) should talk less about Common Lisp and focusing on LISP 1, LISP 1.5 and (optionally) LISP 2. While there's spiritual connection and historical inheritance between these languages, and the later occuring language can pick up programs written in the earlier one using its powerful self configurable runtime system. They're in fact different languages. It's only a concept of Lisp programming language family that can connect them together.  Crlf0710 (talk) 07:28, 24 February 2019 (UTC)
 * I don't agree. First off, in many contexts today "lisp" is likely to refer to Common Lisp.  There's a reason that "Lisp 1" is called "Lisp 1" and not just "Lisp", obviously "Lisp" is not commonly used to refer to the "Lisp 1" language today except perhaps in certain contexts where it is clear that a historical discussion is intended.  That would be akin to the claim that English language should spend almost all of its time talking about Old English because clearly in your view Modern English is a different language.  And it is a different language, but that isn't a problem for English language as that article describes the English language even though "English" is really more than a dozen closely related languages that vary over time and geography.  Lisp is almost exactly the same.  Also, what is Lisp (programming language family) supposed to disambiguate?  If there was an article that talked about a single lisp dialect and that article was called "Lisp (programming language)" and there was another article that talked about the lisp programming language family then the family article would need disambiguation such as "Lisp (programming language family)" to distinguish it from the first individual dialect article.  But there is no "Lisp (programming language)" article talking about a single lisp dialect, so the complicated disambiguation you propose is not needed.  In fact there are many articles on dialects of lisp, but astonishingly all the dialects have individual names that are not simply "lisp" so no disambiguation is needed between the articles for those individual dialects and Lisp (programming language).  The disambiguation for this article is necessary because of lisp, the speech impediment.  With Pascal (programming language) the situation is exactly the same.  Quale (talk) 22:07, 24 February 2019 (UTC)
 * Of course Common Lisp was an influential Lisp dialect, especially in the 1980s and 1990s. It directly inherited from Maclisp, Interlisp and Zetalisp, and referenced Scheme, Standard Lisp, S-1 Lisp and other dialects. Maybe we could even say it is the Lisp (dialect) at its time. However even at its time, Scheme is influential too. Nobody who knew Scheme would say it isn't a Lisp, even if its fragmented nature and minimalist attitude does make its users share less with the whole Lisp community. Which makes it very clear that there are two Lisp concepts. One is the whole Lisp programming language family, which includes quite a few programming languages, following Lisp community tradition (and attitudes of John McCarthy himself, but i can find the reference now) called Lisp dialects. The other is a LISP programming language, designed by John McCarthy. It is the initial member of the former, which has versions 1.0, 1.5, then ported, developed, forked into MacLisp, and BBN Lisp. both replaced by a new language called Common Lisp. This new language, like many other Lisp dialects, is less related to John's classical LISP, however it has followed many of earlier traditions and achieved quite impressive compatibility. But at this point, it's inappropriate to talk about 'S-expressions' etc, the stuff in John's classical LISP. Because Common Lisp actually works differently. You'll need to talk about Common Lisp 'reader's, Common Lisp 'evaluation' models and strategies(repl/eval/compile/compile-file/load), Common Lisp typesystems. For Scheme you'd talk about Scheme syntax and procedures, 'external representation's, and so on. Since these are the essentials of the new languages. Crlf0710 (talk) 15:26, 25 February 2019 (UTC)
 * About the disambiguation itself. Of course it's for disambiguating this article from lisp and Locator/Identifier_Separation_Protocol etc. Actually i do want to create a LISP (programming language), and merge LISP 2 into it. However yes this article is only for historical interest, so there's no need to hurry. If its existence is the premise of this move, i can do it now (but only if people here think it's appropriate). Crlf0710 (talk) 15:35, 25 February 2019 (UTC)
 * I'm familiar with the history of lisp, but it's irrelevant to the disambiguation for the article. Your talk of Common Lisp as being influential especially in the 1980s and 1990s is odd to me as Common Lisp is still the preeminent lisp today and it represents the terminal point of classical lisp development from the original McCarthy Lisp through Lisp 1.5, MacLisp and the Lisp Machine lisps with some Interlisp and Scheme sprinkled in.  I don't say Common Lisp is the preeminent lisp out of any favoritism towards it as my tastes lean decidedly toward Scheme, but it is just an acknowledgement of reality.  Your mention of wanting to merge the LISP 2 article is even more strange, as LISP 2 was an evolutionary dead end with no living progeny that had little influence on subsequent developments.  Even so, I don't see any reason to merge LISP 2 into any other article as there should be plenty of things to say about it to justify standalone treatment.  (See for example http://www.softwarepreservation.org/projects/LISP/lisp2_family/.)  I agree that lisp offspring and relatives are unusually numerous and diverse and that this is a very important and distinctive characteristic of lisp, but I don't agree that this requires inventing a new disambiguation not used by other programming language articles.  The correct place to describe the diversity of lisp culture is in the article, not in the disambiguation.  It is unreasonable to expect the reader to draw any useful conclusions from a disambiguation that appears oddly out of place compared to other articles in Category:Programming languages.  It is also not in accord with common practice outside of Wikipedia since programmers generally refer to lisp as a programming language and not a programming language family.  Quale (talk) 06:56, 27 February 2019 (UTC)
 * About Common Lisp is still the preeminent lisp today, i don't think so, for example, according to, Common Lisp ranks at #42, after Emacs Lisp (#20), Clojure (#23), Scheme (#40). Maybe there're data that say otherwise, but at least this view is questionable.   Crlf0710 (talk) 12:13, 27 February 2019 (UTC)
 * About it(Common Lisp) represents the terminal point of classical lisp development , i partially agree. It's just like Visual Basic.NET represents the terminal point of Visual Basic development. But likewise, their relationship is even weaker. Visual Basic.NET finally get its suffix dropped. Common Lisp never did that before its committee disbanded. So its proper name is always Common Lisp or CL for short, never Lisp. My point is that they should be different articles and linked together. Lisp (programming language) should be about the original McCarthy Lisp, just like BASIC is only for classical BASIC. Crlf0710 (talk) 12:13, 27 February 2019 (UTC)
 * Oppose. The parenthesis in the title is for disambiguation, and the disambiguation should be as simple as required but no more complex. Lisp is a programming language. There are dialects, but we need not distinguish them in the disambiguation phrase. Glrx (talk) 06:21, 23 February 2019 (UTC)
 * But the problem is that these dialect doesn't have so much in common, other than naming similarity and textual representation similarity(still different). It is very inappropriate to ignore these differences and talk about the syntax and semantics of a bunch of different programming languages as a single one. Crlf0710 (talk) 07:38, 24 February 2019 (UTC)
 * Oppose the nom is based on an excessively pedantic argument. The term "programming language" can refer to a family of languages. There is nothing confusing or misleading about this title. --В²C ☎ 18:54, 26 February 2019 (UTC)

Discussion

 * This article have exhibited quite a few issues from technical point of view. Especially, the Syntax and semantics section tries to introduce a hypothesis programming language Lisp, however there's no reliable sources for these descriptions. Most modern Lisp dialects, while still kept some sort of backwards compatibility, does not use these over-simplified descriptions. These descriptions are, at best, inaccurate, if not simply wrong for these modern Lisp dialects.


 * The above discussion is preserved as an archive of a requested move. Please do not modify it. Subsequent comments should be made in a new section on this talk page or in a move review. No further edits should be made to this section.

First LISP Compiler
The article currently says, "The first complete Lisp compiler, written in Lisp, was implemented in 1962 by Tim Hart and Mike Levin at MIT," referencing AIM-39 written in 1962. However, the Lisp I Progammer's Manual published May 1960, section 4.2, clearly states that a compiler was already available by that time. Do we have any evidence that this compiler was somehow "incomplete"? Certainly there's no indication of that in L1PM. Cjs (talk) 03:41, 9 September 2019 (UTC)

Undefined constructs
Two undefined constructs appear in examples: # and block. Can someone fix this?

(Footnote 54 explains one use of #, but doesn't seem to shed any light on other examples. An appropriate fix for block might be to delete the arcane example that uses it.)

I also suggest presenting a more straightforward example of mapcar, without #. Perhaps the existing example would make a good illustration for #. Mdmi (talk) 21:04, 15 December 2019 (UTC)

LISP first appeared in 1960
When did LISP first appear? Development began in 1958. The paper describing the design of LISP was published in April 1960. The first working implementation of LISP was written based on this 1960 paper (but we don't know the year).

In the FORTRAN page, development began in 1953, a draft specification was published 1954, the official manual was published in 1956, and the completed compiler was released in 1957. Wikipedia says that FORTRAN first appeared in 1957.

Based on how the FORTRAN article is written, it is consistent to say that LISP first appeared in 1960 when the specification was published. We unfortunately don't know the year that the interpreter was implemented, although that year might have been 1960. — Preceding unsigned comment added by 209.183.136.7 (talk) 18:04, 15 December 2022 (UTC)


 * See Early LISP History (1956-1959) by Herbert Stoyan available here: [Https://web.archive.org/web/20050405213907/http://informatik.uni-erlangen.de/html/lisp/histlit1.html https://web.archive.org/web/20050405213907/http://informatik.uni-erlangen.de/html/lisp/histlit1.html]
 * Towards the end, it states:
 * This was pure theory then because the first garbage collector was implemented by Dan Edwards during June/July of 1959. At the end of April Dan Edwards was one of the first users of the LISP-system.
 * We have to make it clear that the developing LISP-implementation already had serious users at this time...
 * And a few paragraphs down:
 * By chance one early version of the LISP-interpreter - dated 5/15/59 - is saved at MIT (in the possession of J. Moses) which does not contain the garbage collector.
 * Also, the fact that both of the references provided on the page state that only Fortran is older than Lisp should be taken into account. These are references from people who were around at the time, and it isn't as if COBOL is something they would have been unaware of.
 * Unsuitably Silly Name (talk) 07:40, 21 January 2024 (UTC)