Clojure is more like scheme in that it only has a one scope environment. Common Lisp (and Lisp) are defined by having 2 scope in the environment. One scope for the functions and one scope for variables, if I remember correctly. An easy way to learn your way around lisp is to read and work through Graham's essay "Roots of Lisp": http://paulgraham.com/rootsoflisp.html

Also called Lisp-1 vs. Lisp-2; mainline LISP has separate namespaces for function and variable values, Scheme and Clojure have just one.

This was the big breaking change from Scheme that CL wasn't willing to make because it would have broken too much invaluable code.

...because it was a bad idea. I did some serious work with a Lisp-1 (Arc) and it was a PITA with no discernible win to it.

It's _a_ Lisp. It's not _the_ lisp and not a particular good one either.

What did you mean by this then?

> It's not LISP and its not Lisp either

LISP is mostly a historical term used for 1.5 era lisps.

Furthermore note the difference between "X is Lisp" and "X is _a_ Lisp".

Well, as I score it, it's not a LISP, as in LISt Processing, since lists are no longer the principle collection type, and others are first class syntactically. Not to mention the use of vectors (denoted with square braces []) for special form syntax like in defn and let.

But it's most certainly a "Lisp".

By "lists", you mean "linked lists as implemented with pairs"? What's the practical difference between lists and the seq abstraction (immutability aside)? It's true that Clojure provides a lot of data types, but none that would be unfamiliar to a CL programmer. And you can handle all of them more or less like lists, and as a bonus you can use the same set of functions to do so.

I would think that the immutability of these data structures would be a bigger difference, both conceptually and in the difficulty of porting CL code into Clojure.

Yes, as implemented with pairs, syntactically with parens.

None, except vectors and maps (and sets and regexs and ...) being syntactically first class, and being used heavily, not just in special form syntax but in real use. For a whole lot of programming, maps are where it's at for your data structures.

True, these shouldn't be unfamiliar to a CL programmer (although the pervasive use of maps might well be, don't remember how much association lists and properly lists were used).

As someone who adopted the mostly functional Scheme style I don't find the enforced immutability a bigger difference, but I could well see that being true for CL programmers. And for many/some? the bias against OO vs. CL's CLOS, which many claim is the very best OO system ever (as far as I know the only popular one with a MOP).

the practical difference between lists and seqs is laziness (details like chunking, too).

You answered why it's not a LISP. What about the second part of the phrase I quoted?

Can't answer, since I disagree, and for that matter the author of the quote later changed his stated opinion.