Hacker News Reader

Comment by kbp | Hacker News Reader

Lisp isn't really a functional language, it just pioneered a lot of concepts in functional programming. It has almost no concept of immutability, imperative code is everywhere, and if you try to write in a pure functional style you'll probably find it awkward compared to something like an ML-style language.

Lisp is a multiparadigm language. It has closures and higher order functions and uses them where they make sense; it also has a lot of imperative constructs, and a very sophisticated object system. They all work together and make Lisp a unique, interesting language. If you're only interested in the functional parts, you'd probably be happier with Haskell or Clojure.

View on HN

Clojure is lisp actually. It is also mutable but it makes mutability as an explicit transaction but the entire thing runs on a JVM so you can use all Java libraries (so no library scarcity for lisps). So if you are doing heavy work it is either this or Common lisp. Clojure is preferable because Java has more momentum than CL.

Armed Bear Common Lisp[0] runs on the JVM.

0: https://common-lisp.net/project/armedbear/

So does Frege [0]. (Your Haskell dialect that runs on JVM) But you know what compared to something like SBCL or Clojure they are just not that popular. They do deserve more attention though.

[0] https://github.com/Frege/frege

Yes, Clojure is a Lisp. Lisp is also the shorthand way people refer to Common Lisp. Lisp in the context of OP means Common Lisp.

Common Lisp has an implementation, ABCL, which runs on top of the JVM. Access to the Java ecosystem is a shared trait, not a difference.

Being a multi-paradigm language CL has a wealth of features That Clojure doesn't and they all play well together. Except for the type system and the class system.

For example, it has places and the ability to define your own setf forms.

Common Lisp makes iteration easy with the lisp macro.

Common Lisp has tagbody and gotos so one compile FSMs efficiently

Common Lisp has an object system were the semantics are describe using the same object system. So users can extend the object model according to their needs.

Clojure is designed to support one style of programming envisioned by its hypemaster. Rich Hickey is a brilliant person, and has done an excellent job designing Clojure, but

Clojure approach to 'user erros' is we don't guarantee to signal an error, we may do w/e.

By momentum you mean it is trending. We know mainstream programming is a pop culture, but we shouldn't encourage it by recommending one language over another based a FAD.

> We know mainstream programming is a pop culture, but we shouldn't encourage it by recommending one language over another based a FAD.

To further underscore this point, Common Lisp was created in 1984 incorporating elements of proven late 1970s Lisps like MACLISP; CL has been successfully used on spaceships and important complex systems, and the CL ecosystem continues to evolve and grow till today. The specification has been unchanged since the '80s and probably won't change any sooner, since the language is extensible and thus can evolve as the state of the art evolves.

CL is largely free from any kind of fad; everything that is built into the language is there either because (a) it has been proven to be necessary and proven to work correctly in the best way possible, or (b) was needed for backwards compatibility with earlier lisps.

Clojure is a new language and tries to be nice to newcomers, but it's difficult to compete against technology that has at least 33 years of continuous evolution. Also, if you need to interoperate Java classes with CL, there's ABCL which will do it nicely.

As a lisper said, "those who don't know Common Lisp are doomed to reinvent it."

The original LISP is pure functional in the sense that you don't change state of an object.

> The original LISP is pure functional in the sense that you don't change state of an object.

Are you sure about that? RPLACA, RPLACD, NCONC, etc are present in the Lisp 1 Programmer's Manual dated March 1st, 1960: http://bitsavers.trailing-edge.com/pdf/mit/rle_lisp/LISP_I_P...

The original paper of LISP by John McCarthy http://www-formal.stanford.edu/jmc/recursive.html

Or the more accessible explanation by Paul Graham http://www.paulgraham.com/rootsoflisp.html

There are only few primitives and no such things as RPLACA, RPLACD, and NCONC.

They are in the Lisp 1 Programmer's Manual, also dated 1960.

The white paper doesn't reproduce the entire reference manual; what are the odds?

I'm not talking about the implementation of LISP 1 by Steve Russell, but the original idea of LISP invented by John McCarthy that shows its purity, and that is before the implementation by Russell.

The paper you cited is dated 1960 and bears McCarthy's name.

The Lisp 1 Programmer's Manual is dated 1960 and ... bears McCarthy's name.

The paper you cited has a section titled The LISP Programming System which says:

"The LISP programming system is a system for using the IBM 704 computer to compute with symbolic information in the form of S-expressions."

The Programmer's Manual's Preface begins:

"LISP 1 is a programming system for the IBM 704 for computing with symbolic expressions."

Looks like they are about exactly the same thing to me: an implementation for a specific computer (IBM 704), described in the same year by the same author, with an a nearly identical sentence in the intro.

John McCarthy is not the one who implemented LISP 1 in IBM 704, but it is Steve Russell. McCarthy invented the idea of LISP in 1958 https://www-cs.stanford.edu/memoriam/professor-john-mccarthy that is before the 1960 paper and the LISP 1 manual. In the 1960 paper, he showed that LISP can be implemented in just few primitives that showed its purity of LISP. Of course you can develop a non pure version of LISP which is more practical.

The original idea of McCarthy was to have a list processing language on the IBM 704.

http://jmc.stanford.edu/articles/lisp/lisp.pdf

Lisp was always as much as an idea as a real proramming language and both were developed together. Lisp was developed as a practical tool for AI research, especially for his AI research.

In the paper you shown

"One mathematical consideration that influenced LISP was to express programs as applicative expressions built up from variables and constants using functions. I considered it important to make these expressions obey the usual mathematical laws allowing replacement of expressions by expressions giving the same value. The motive was to allow proofs of properties of programs using ordinary mathematical methods. This is only possible to the extent that side-effects can be avoided. Unfortunately, side-effects are often a great convenience when computational efficiency is important, and “functions” with side-effects are present in LISP."

Reading above, in his original idea, he clearly had the idea of mathematical pureness for LISP, but for practical reasons the real implementation became one with side-effects.

> The original paper of LISP by John McCarthy http://www-formal.stanford.edu/jmc/recursive.html

> Or the more accessible explanation by Paul Graham http://www.paulgraham.com/rootsoflisp.html

> There are only few primitives and no such things as RPLACA, RPLACD, and NCONC.

That paper is from a month after the manual I posted. It's pretty open about not covering the entirety of Lisp, too, for instance in the section "The LISP Programming System" it says: In addition to the facilities for describing S-functions, there are facilities for using S-functions in programs written as sequences of statements along the lines of FORTRAN (4) or ALGOL (5). These features will not be described in this article.

The implementation by Steve Russell includes those facilities, but the original idea of LISP by John McCarthy don't have to include those facilities and can be implemented as a pure functional language and is shown in the paper.

But can you find anything to point to from that period that talks about an actual programming language called Lisp from that time that was purely functional? McCarthy's 1960 paper isn't about Lisp, it's about recursive functions of symbolic expressions and their computation by machine, using a subset of Lisp as a vehicle for talking about the latter part. The section that is actually about Lisp has an explicit disclaimer that he will only be talking about Lisp as it applies to the broader theory he is discussing. It's about Lisp in the same way that SICP is.

No one's denying that Lisp's early history wasn't wrapped up in early research on functional programming, but I haven't seen any evidence to support the claim that any programming language or anything called Lisp from that time period was purely functional.

So the definition of "LISP" matters. Your definition of LISP seems to be the actual implementation, such as LISP 1. But as many historians say, LISP was invented in 1958, which the implementation did not even exist. From this fact, LISP does not only mean the actual implementation, but also the idea and the idea is written in the 1960 paper, which represents a pure LISP. The idea is the most important thing of LISP and that is why McCarthy is called the Father of LISP and Steve Russell is not. To further say, there may not exist a pure implementation of LISP in 1960, but there exists the idea of pure LISP in those days that is shown in the 1960 paper.

My point was that I have never seen any evidence that such an idea was ever called Lisp. Even the 1960 paper differentiates between the functional programming theory and the language Lisp being used to explore that theory. If we're bundling all the theory leading up to Lisp under the "Lisp" name, then why stop at McCarthy? Church's lambda calculus was definitely purely functional.

As for McCarthy's original conception of Lisp, in 1979[1] he wrote: LISP also allows sequential programs written with assignment statements and go tos. Compared to the mathematically elegant recursive function definition features, the ``program feature'' looks like a hasty afterthought. This is not quite correct; the idea of having sequential programs in LISP antedates that of having recursive function definition.

1: http://www-formal.stanford.edu/jmc/history/lisp/node4.html

>My point was that I have never seen any evidence that such an idea was ever called Lisp.

I'm not the only one who has this view.

From Paul Graham, http://www.paulgraham.com/rootsoflisp.html

"There were already models of computation, of course - most notably the Turing Machine. But Turing Machine programs are not very edifying to read. If you want a language for describing algorithms, you might want something more abstract, and that was one of McCarthy's aims in defining Lisp. The language he defined in 1960 was missing a lot. It has no side-effects, no sequential execution (which is useful only with side effects anyway), no practical numbers, and dynamic scope. But these limitations can be remedied with surprisingly little additional code. If you understand McCarthy's eval you understand more than just a stage in the history of languages. These ideas are still the semantic core of Lisp today. So studying McCarthy's original paper shows us, in a sense, what Lisp really is. It' s not something that McCarthy designed so much as something he discovered. It's not intrinsically a language for AI or for rapid prototyping, or any other task at that level. It's what you get (or one thing you get) when you try to axiomatize computation."

Since the word LISP is not mathematically defined and has different meanings in different contexts, there are different views of what LISP is and I understand your confusion.

What are car and cdr called in the pure theory, and why didn't they just stick with those names?

> The language he defined in 1960 was missing a lot. It has no side-effects, no sequential execution (which is useful only with side effects anyway), no practical numbers, and dynamic scope.

The language LISP I in 1960 had numbers, side-effects and sequential execution.

http://www.mirrorservice.org/sites/www.bitsavers.org/pdf/mit...

Lisp I programmer's manual from 1st March 1960.

It had PROG -> sequential execution. chapter 4.5

It had floating point numbers -> chapter 4.4.

It had side-effects -> SET, SETQ. chapter 4.5

>The language LISP I in 1960 had numbers, side-effects and sequential execution.

Yes, true. But in this context Paul Graham was talking about the language defined in the 1960 paper below and not LISP I.

"Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I"

http://www-formal.stanford.edu/jmc/recursive.html

Really? That has numbers, too. There are several examples with numbers in the paper.

In the paper McCarthy mentions also:

'6. A ``program feature'' allows programs containing assignment and go to statements in the style of ALGOL.'

'7. Computation with floating point numbers is possible in the system'

Basically the paper is more a collections of ideas around various ways to describe parts of LISP. The actual LISP language is described somewhere else. See the LISP I Programmer's manual linked earlier, which gives a complete overview of the state of the LISP language in 1960.

>In the paper McCarthy mentions also: >'6. A ``program feature'' allows programs containing assignment and go to statements in the style of ALGOL.' >'7. Computation with floating point numbers is possible in the system'

This part is about the status of LISP I and not what Graham is referring to. Did you look at the article by Graham?

http://www.paulgraham.com/rootsoflisp.html

He is talking about the core of LISP that he found in the 1960 paper that is pure.

>Basically the paper is more a collections of ideas around various ways to describe parts of LISP

There is clearly a gem in the paper that is viewed as a pure LISP.

I think the argument comes because your initial statement was "The original LISP is pure functional," which isn't true. McCarthy's original idea of Lisp was not purely functional and the original Lisp implementation was not purely functional. I think that it is true to say that the first real description of a purely functional language came up in the context of work on Lisp, but what you and Paul Graham seem to be doing is saying that that pure Lisp is the real Lisp and what was called Lisp before that (in theory and implementation) was still just a lead-up to his "discovery" of Lisp.

>I think the argument comes because your initial statement was "The original LISP is pure functional," which isn't true.

Since LISP I is the real first implementation, I don't mean the original LISP in the sense of the first LISP, but rather "a core of LISP defined in the original paper". I called that the original LISP. I have explained this view many times so far.

>McCarthy's original idea of Lisp was not purely functional

At least McCarthy had some pureness in his mind for LISP and it is not black or white argument.

>the original Lisp implementation was not purely functional.

True.

> but what you and Paul Graham seem to be doing is saying that that pure Lisp is the real Lisp and what was called Lisp before that (in theory and implementation)

This is not my intention.

> At least McCarthy had some pureness in his mind for LISP and it is not black or white argument.

In his 1958 paper describing what would become Lisp, literally the first example of the use of car he gives is destructively modifying a cons, ie, RPLACA. In his own words, which I quoted earlier and you didn't respond to: "Compared to the mathematically elegant recursive function definition features, the ``program feature'' looks like a hasty afterthought. This is not quite correct; the idea of having sequential programs in LISP antedates that of having recursive function definition."

It seems black and white to me.

> > but what you and Paul Graham seem to be doing is saying that that pure Lisp is the real Lisp and what was called Lisp before that (in theory and implementation)

> This is not my intention.

Could you explain how your intention differs? McCarthy's original conception of Lisp was not purely functional (according to McCarthy himself as well as the historical evidence), and the original implementation was not purely functional, so how would the purely functional subset described in a later paper be "the original LISP" if you aren't denying the earlier work?

http://jmc.stanford.edu/articles/lisp/lisp.pdf

Seems not black or white to me. This paper is also written by McCarthy. He had pureness in his mind, but the real implementation had side-effects for practical reasons.

>McCarthy's original conception of Lisp was not purely functional (according to McCarthy himself as well as the historical evidence)

Again not black or white (according to McCarthy himself). The pure language is written in the original LISP paper and Graham and I viewed it as the core and it also showed the pureness of LISP.

>so how would the purely functional subset described in a later paper be "the original LISP" if you aren't denying the earlier work?

Again the definition. I have already explained what I meant with "the original LISP".

> > so how would the purely functional subset described in a later paper be "the original LISP" if you aren't denying the earlier work?

> Again the definition. I have already explained what I meant with "the original LISP".

I didn't ask what you meant by it, I asked how using that definition is different from claiming that McCarthy's earlier work on Lisp wasn't Lisp. In the same paper you just quoted, McCarthy says that Lisp was planned to have sequential programs before it was planned to have recursive functions; the part you quoted does not say that destructive functions were added later or that he ever planned not to have them. In the 1958 paper, he was already describing a language with mutable objects.

>McCarthy's earlier work on Lisp wasn't Lisp.

I didn't say this. I have already explained about the difference between the first LISP implementation and the core language written in the 1960 paper. There is no one true definition of LISP and I have already talked about this. People have different views of what LISP is.

You said black and white and it is not true from the paper I have shown.

>In the 1958 paper, he was already describing a language with mutable objects.

I am not talking about the 1958 paper. I am not also talking about which idea is first or not. Since it is not written clearly in the papers shown so far which idea is first, but I have showed that it is not black or white. Graham and my claim is based on the so called "original LISP paper" in 1960 and the pure version of LISP is written in it.

You and I have different views of LISP and that is OK. But please don't force your view to us, since there is no one true definition or interpretation of LISP.

> >McCarthy's earlier work on Lisp wasn't Lisp.

> I didn't say this.

Again, I was asking how what you did say was different from it. Your answer seems to just be that your definition of Lisp means the subset described in the 1960 paper, and doesn't include the original implementation or McCarthy's earlier writing on the subject.

> You said black and white and it is not true from the paper I have shown.

The paper you quoted said that Lisp was originally conceived as an impure language (the part I quoted) and that that was unfortunate, but true (the part you quoted).

> I have already explained about the difference between the first LISP implementation and the core language written in the 1960 paper. [...] I am not talking about the 1958 paper.

So you meant to say that the 1960 paper was the first description of a pure language. Calling the 1960 paper's subset of Lisp "the original LISP" and disregarding the already-existing implemented Lisp system which the paper acknowledges, as well as McCarthy's previous writing on the subject, is misleading at best.

> I am not also talking about which idea is first or not.

Then we have different definitions of "original," too.

>Your answer seems to just be that your definition of Lisp means the subset described in the 1960 paper,

Not true. I also consider LISP I as LISP, Common Lisp as LISP, and understand people calling Scheme as LISP, or Clojure as LISP. I really respect all of the works involving the LISP family.

>The paper you quoted said that Lisp was originally conceived as an non-pure language (the part I quoted) and that that was unfortunate, but true (the part you quoted).

The paper is referring LISP to the actual implementation and that is impure as we know. From the part I quoted, he had both pure and non-pure ideas and that I call "not black or white".

>So you meant to say that the 1960 paper was the first description of a pure language.

No I did not say this. Since it is not clear if it is the first pure language or not.

>Calling the 1960 paper's subset of Lisp "the original LISP"

I have already explained what I meant. I will also add that since the 1960 paper is so called "the original LISP paper", and the paper refers to the LISP implementation and describes a pure core LISP, I called the pure part "the original LISP" meaning the core of LISP in the original LISP paper. The most important part is the meaning and since I have explained what I meant, if you are not satisfied with the wordings, just use a different symbol "XXX LISP" and you will be satisfied.

>and disregarding the already-existing implemented Lisp system which the paper acknowledges,

No I am not. You seem to be disregarding that a pure LISP can be constructed from the idea in the paper.

>as well as McCarthy's previous writing on the subject, is misleading at best.

Not true.

Since I have to wait for more than an hour to reply in a deep comment level, I will reply here to kbp.

>The confusion seems to stem from your insistence on using the word "original" to mean the pure Lisp described in the 1960 paper, despite the fact there was Lisp before that. It seems like it's mostly a disagreement about the meaning of the word original; I consider your use misleading.

Yes I should have used a different word and I am sorry for making a confusion. After this long discussion about the history of LISP, I can now come up with a better word instead of using "original", and also I have an updated view of the LISP history.

>As I said several times, The 1960 paper describes a pure subset of Lisp, I was only disagreeing that it was the original Lisp.

Great!

>I think we understand each other now.

Yes it seems so.

>It was nice reading some old papers I hadn't seen before :)

Definitely true and thanks for having a very long discussion :)

Herbert Stoyan researched about the early history of Lisp and wrote books about that.

https://github.com/papers-we-love/papers-we-love/blob/master...

He says:

> LISP is understood as the model of a functional programming language today. There are people who believe that there once was a clean "pure" language design in the functional direction which was comprised by AI-programmers in search of efficiency. This view does not take into account, that around the end of the fifties, nobody, including McCarthy himself, seriously based his programming on the concept of mathematical function. It is quite certain that McCarthy for a long time associated programming with the design of stepwise executed "algorithms".

> On the other side, it was McCarthy who, as the first, seemed to have developed the idea of using funtional terms (in the form of "function calls" or "subroutine calls") for every partial step of a program. This idea emerged more as a stylistic decision, proved to be sound and became the basis for a proper way of programming - functional progamming (or, as I prefer to call it, function-oriented programming). We should mention here that McCarthy at the same time conceived the idea of logic-oriented programming, that is, the idea of using logical formulae to express goals that a program should try to establish and of using the prover as programming language interpreter. To come back to functional programming, it is an important fact that McCarthy as mathematician was familiar with some formal mathematical languages but did not have a deep, intimate understanding of all their details. McCarthy himself has stressed this fact (23). His aim was to use the mathematical formalismus as languages and not as calculi. This is the root of the historical fact that he never took the Lambda-Calculus conversion rules as a sound basis for LISP implementation. We have to bear this in mind if we follow now the sequence of events that led to LISP. It is due to McCarthy's work that functional programming is a usable way of programming today. The main practice of this programming style, done with LISP, still shows his personal mark.

Thanks for an interesting reference. This seems to be an important paper and I would like to take time later and read it in more depth.

That's not THE core of Lisp. It's a comstruction of a pure subset variant of Lisp. The actual LISP wasn't pure. Not before this particular paper and not after.

>It's a comstruction of a pure subset variant of Lisp.

We viewed it as the core of LISP and this is just one view of LISP.

>The actual LISP wasn't pure. Not before this particular paper and not after.

LISP I is not pure and I agree.

Two of Graham's Seven Primitive Operators are car and cdr. These names come from the IBM 704 implementation; they could not have existed in the theory which came before it. Since those names were used, this casts a suspicion that the theory didn't have these functions, and therefore wasn't about Lisp.

What Graham's Paper is describing is a back formation abstracted from what they got running on that IBM 704.

I doubt that the theory had quote, either, which is the gateway to "code is data". Since code-is-data is the core of Lisp, a theory without code-is-data (like the vapid nonsense that is Lambda Calculus) isn't about Lisp.

>Two of Graham's Seven Primitive Operators are car and cdr. These names come from the IBM 704 implementation;

Since the 1960 paper is after the LISP I manual and Graham's article is based on that paper the actual wordings are clearly influenced by LISP1.

>What Graham's Paper is describing is a back formation abstracted from what they got running on that IBM 704.

We viewed it as the core of LISP.

>Since code-is-data is the core of Lisp

Yes an another important part of LISP.

I found an even older reference to impure Lisp; doubt I'm going to do better than this: McCarthy's 1958 paper "An Algebraic Language for the Manipulation of Symbolic Expressions"[0], immediately after introducing our good friend car, says: "For example, statement beginning car (i) = causes a quantity to be computed and stored in the address part of register leaving the rest of the register unchanged."

0: http://www.softwarepreservation.org/projects/LISP/MIT/AIM-00...

You are right, the 1960 paper describes a language that is a pure functional language. I think it even was the first published pure functional language (pointers to earlier work welcome, of course).

Reply on news.ycombinator.com