The following analysis is admittedly reckless, especially when one takes into account the great pleasure many programmers take in nit-picking and criticizing other people's opinions on programming languages. Nevertheless, it may raise one or two enlightening points. If you aren't afraid of awkward generalizations and the like, read on.
LISP is a family of programming languages, whose roots go all the way back to 1958 (which is quite old in the world of computer science). There are many languages in this family, such as emacs lisp, common lisp, scheme, clojure, picolisp, etc., and programmers have been using these languages (and developing new ones) all the way up to modern times. Few languages have lived so long, save for ones like FORTRAN and COBOL; but where many programmers are passionate LISP enthusiasts, one would be hard-pressed to find somebody who loves FORTRAN or COBOL. Why is this? In short, languages can attain longevity in two different ways.
Many old and decrepit systems (viz. ones in governments, hospitals, and banks) still rely on code written in COBOL, despite the fact that the language is hilariously complex and poorly suited to modern computing tasks. These systems still run COBOL today because replacing COBOL with another language is seen as prohibitively difficult. In effect, COBOL is a "zombie language" in that its widespread use in the past means that it is still used today, though it might be more accurate to say that it is 'maintained' rather than 'used'. As time goes on, we may see commonly used languages like Java, Perl, and Go meet the same fate as COBOL: not used, but maintained; not alive, but undead. The case of COBOL shows that one way in which languages can achieve longevity is through technical debt.
Contrast this with the case of LISP. Clearly, long-lived LISP has not survived this long due to technical debt; rather, it remains in use due to its extensibility. In his famous talk "Growing a Language," Guy Steele cites Eric S. Raymond's idea of "The Cathedral and the Bazaar," which argues that the ability to compose, patch, and build on top of old, extensible systems is more valuable than rigid, centralized planning. Steele shows that you can apply this principle to programming languages, so that they grow and evolve just as human languages do. LISP is designed in such a way that it can change over time, and it is through this property--not through technical debt--that is survives today.
One can define the 'kernel' of LISP in the following way,
which has been likened
equations (click for a larger version):
It is pretty amazing that a few simple rules (almost maximally simple, perhaps) define a language that can grow, evolve, and thrive for almost 70 years.
This amazing fact raises an important question. Is there another set of "Maxwell's equations" that is significantly different from the ones above? That is, can one define another "growable language" which isn't just some other form of LISP?