I have no time to watch a full video. Who is speaking?

On topic, my suggestion to make a better language is easy: create more tooling and portable libraries for Common Lisp. Port some of the nicer features of Clojure and Racket to Common Lisp and standarize them on a portable lib.

This was a bit of humor delivered for entertainment at the closing of an Android conference (360AnDev, which I highly recommend). The speakers are two of the most well known in the Android community (Chet Haase and Romain Guy, both from Google).

On the "easy" front, your suggestions are cool. Why do you think this hasn't happened?

This is a good question and deserves its own article. Much fun (sometimes justified) has been made of the archetipical "Smug lisp hacker" or "Smug lisp weenie" who thinks that Common Lisp is the best of the best.

On the other opposite side of the spectrum are people who claim that as long as a language is turing-complete, all languages are "equally good" or even "equally powerful". Which isn't really a practical advice, otherwise Assembler would be used for prototyping web apps...

Now, what Common Lisp is, is the evolution of a language invented in 1958, a language which has the peculiar characteristic of being able to be extended almost without limit. This marks the difference with other late-50s languages like COBOL and FORTRAN; to extend Cobol and Fortran (and Java, for that matter), you need to convince the governing body of the language to add feature X, and then they need to release a new revised standard that supports feature X. (Example: C++14 after C++11)

While with Lisp it often can be implemented into the language using the facilities that the language brings in, just like that. This allowed Lisp to evolve with the state of the art in computer science, compilers and languages, all through the 60s, 70s, 80s, and 90s. Common Lisp (ANSI standard, 1994) wasn't really "designed"; basically, it was the standarization of things that were already proven to be "good" and to be "the right way of doing things" all through the past, so it has surprisingly few negatives.

One of the power features of Lisp is that it is truly a "programmable programming language"; some would say "the programmable programming language". What this means that meta-programming is really easy in Lisp, so easy that this is the bread&butter of a Lisp coder. In other words, you not only write "source code", you also write "source code that generates source code" quite often, and to a really good effect in productivity and code readability as well (i.e. by reducing boilerplate and narrowing down the source code to the most higher-level description of the problem.)

Another of the interesting power features are the object orientation facilities. CL was the first object oriented language to receive the ANSI standard. The object oriented system (CLOS) is probably still the most rich in features and most extensible, compared to other programming languages.

Finally, the language allows many programming paradigms (OO, functional, imperative, procedural, even logic programming, aspect oriented). Fortunately, being able to use a multi-paradigm language is finally being recognized to be a Good Thing.

However, to answer your question:

    Why do you think this hasn't happened?

There is a problem with Common Lisp; the problem is that, to be able to leverage its intrinsic power, then you would probably be well versed in all the programming paradigms mentioned above. Additionally, the language, being so flexible and expressive, has many, many features and keywords and standard functions, so it represents a large "surface area" that the beginner must walk through in order to truly appreciate and make best use of the language.

So, Perl is "There is more than one way to do it",

Python is "There should be one-- and preferably only one --obvious way to do it.",

...Common Lisp is "There is more than one way to do it, however there exists a best way of doing it, and you should do it that way, but that way won't be obvious if you are a beginner."

However, the language features are mostly very coherent and orthogonal, so learning it will not be particularly hard; it will simply take time. To put it in other words, it can be complex, but it is never complicated.

So, higher learning curve, less developers available, thus less amount of "very nice" tooling available. However, this might change in the next years.

-----

TL;DR: Learning curve is high to be able to take advantage of its full power. So there aren't so many developers.