I have been reading a bit about Common Lisp and I am considering trying to learn it (I only know very basic concepts) or even using it for some project.
Question: how stable is Common Lisp as a language? What I mean is, regardless of new libraries, are new language features (involving new syntax and semantics) being added to the language? In other words, if I learn Common Lisp now, would I be able to use the same language in 10 years from now, or read code that was written 10, 20 years ago (apart, of course, from having to get familiar with different libraries and API’s)?
3
There is the ANSI Common Lisp standard and the Common Lisp Hyperspec. It’s generally reasonable to assume that standardised languages will stay relatively stable and that most new language additions will be consistent with the standard / not break existing code.
Of course, one of the powers of Lisp is that you can extend the language almost arbitrarily, so there’s quite a possibility that some new libraries or DSLs will look completely different from any other previous Lisp code. That’s just a danger of the meta-programming territory. But the core language itself is likely to stay pretty stable.
If you are interested in Lisps in general as opposed to Common Lisp specifically, I’d also recommend you check out Clojure (a modern, pragmatic, functional Lisp) and Scheme (a very clean, elegant Lisp ideal for learning).
9
The first edition of the book Common Lisp The Language, written by the lispers
at CMU (Carnegie-Mellon University)[1] and published in 1984, served as a basis
for ANSI Common Lisp the standard. The second edition (published in 1990)
reflected the current state of the standardisation process that was still
ongoing.
In 1994, the ANSI Common Lisp standard was finally published. It differed in
certain ways from the dialects described by the two editions of Common Lisp The
Language but acknowledged the practical importance of both editions by
suggesting that the keywords :cltl1 and :cltl2 be included in the *features*
list, allowing for conditionals to be added to code that must interoperate
between ANSI Common Lisp and these other two dialects.
CLTL1 (as it is known) is ancient history today and most, if not all,
implementations have settled on something somewhere in between ANSI and CLTL2.
However, the ANSI standard suffered from a bigger problem that had nothing to do
with the language per se; it failed to address one or two important practical
aspects of everyday programming and discrepancies arose in the way
implementations addressed these practical needs. As a result of this (not the
minor language differences between ANSI and CLTL2) lispers talk toady about
portable versus non-portable code.
So, to summarise, the core language (the fixed set of 24 special forms[2] which
every implementation must include if it wants to call itself Common Lisp) is
absolutely rock solid and cast in stone, but practical shortcomings in the ANSI
standard have lead to discrepancies in the way implementations make up for them.
[1] SBCL builds on the original CMU code base, hence the name Steel Bank Common
Lisp. (Carnegie was a steel magnate and Mellon was a Wall Street financier).
[2] Common Lisp special forms
4