Talk:Lisp (programming language)

From Wikipedia, the free encyclopedia
Jump to: navigation, search
WikiProject Computing (Rated B-class, Mid-importance)
WikiProject icon This article is within the scope of WikiProject Computing, a collaborative effort to improve the coverage of computers, computing, and information technology on Wikipedia. If you would like to participate, please visit the project page, where you can join the discussion and see a list of open tasks.
B-Class article B  This article has been rated as B-Class on the project's quality scale.
 Mid  This article has been rated as Mid-importance on the project's importance scale.
WikiProject Computer science (Rated B-class, High-importance)
WikiProject icon This article is within the scope of WikiProject Computer science, a collaborative effort to improve the coverage of Computer science related articles on Wikipedia. If you would like to participate, please visit the project page, where you can join the discussion and see a list of open tasks.
B-Class article B  This article has been rated as B-Class on the project's quality scale.
 High  This article has been rated as High-importance on the project's importance scale.

Random "citations needed" are not[edit]

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 (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)


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[edit]

The Qi manual pages 18-31 [1] 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)


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[edit]

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 (talkcontribs) 04:58, 9 March 2011 (UTC)

Who uses Lisp?[edit]

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. (talk) 20:30, 22 August 2009 (UTC)

Object-Oriented Language?[edit]

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 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?[edit]

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.


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 (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 :)[edit]

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 (talkcontribs) 05:17, 14 February 2011 (UTC)

BEE Lisp, possible spamming[edit]

Beware that anon users (,, 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. (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 (talk) 21:11, 24 June 2010 (UTC)

"somehow compatible" ?[edit]

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[edit]

Why is there no information about muLisp? Why is it ommitted? —Preceding unsigned comment added by (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"?[edit]

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. (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?[edit]

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 (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)


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 (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. — Tobias Bergemann (talk) 15:06, 4 November 2010 (UTC)

Asymptotic complexity of appending two lists.[edit]

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 (talkcontribs) 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)


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 (talk) 10:46, 19 April 2012 (UTC)

Answer: — Preceding unsigned comment added by (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? (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[edit]

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?[edit]

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[edit]

The article does not distinguish reader macros and evaluation. The evaluator (eval) takes an expression such as (QUOTE FOO) and returns the atom FOO; the evaluator never sees a thing that looks like 'foo; that beast is not a s-expression. The s-expression reader (read) makes use of reader macros that transform the character stream 'foo into the s-expression (QUOTE FOO); sometime later eval 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 'foo. 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 atan(y, x). 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 eval. Glrx (talk) 04:02, 30 April 2013 (UTC)

Generational GC[edit]

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 mention generation and cites to Ungar
also published in CACM, Volume 26, Issue 6, June 1983, Pages 419-429, doi 10.1145/358141.358147, 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[edit]

I've reverted Marcodx it (talk · contribs) 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. (talk) 07:05, 16 June 2014 (UTC)

Lacking good examples[edit]


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 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#The_function_namespace.
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[edit]

I deem the following links in the "dialects" slot being not dialects:

  • Racket, is a Scheme implementation,
  • T, is a Scheme implementation.

Rursus dixit. (mbork3!) 11:19, 10 January 2014 (UTC)

If Then Else[edit]

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)

Second Oldest Programming Language[edit]

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): Joswig (talk) 23:52, 19 July 2014 (UTC)

The 1+ example is bogus[edit]

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 (talkcontribs) 10:08, 30 January 2015 (UTC)

Why mention Peter Seibel's book in 2000-present section[edit]

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. 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.' 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[edit]

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‎[edit]

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

--Wickedjargon (talk) 06:49, 21 June 2015 (UTC)

(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 quote= 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 (f arg1 arg2 arg3)"; 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 Wikipedia:Quotations#Comparison_with_paraphrases, 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[edit]

Hello fellow Wikipedians,

I have just added archive links to one external link on Lisp (programming language). Please take a moment to review my edit. If necessary, add {{cbignore}} after the link to keep me from modifying it. Alternatively, you can add {{nobots|deny=InternetArchiveBot}} to keep me off the page altogether. I made the following changes:

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

You may set the |checked=, on this template, to true or failed to let other editors know you reviewed the change. If you find any errors, please use the tools below to fix them or call an editor by setting |needhelp= to your help request.

  • If you have discovered URLs which were erroneously considered dead by the bot, you can report them with this tool.
  • If you found an error with any archives or the URLs themselves, you can fix them with this tool.

If you are unable to use these tools, you may set |needhelp=<your help request> on this template to request help from an experienced user. Please include details about your problem, to help other editors.

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

Anybody have a reference for a Lisp n-tuple story?[edit]

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: (A, B, C, D). 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)[edit]

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: define v. defun is not interesting; some examples are identical save for that distinction. The Scheme version of factorial 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)