There may be a little more structure behind this. Lisp, at his time, was incredibly different and prone to creativity and abstractions[1]. Amazing vehicle to explore. Most of the socially successful languages aren't about exploration but about economy of scale, lever. Most people are more happy building application by standing on shoulders of libs rather than finding new solutions to odd problems. I feel it's a bit similar to Haskell these days. They reinvent a world with their own abstractions, extremely powerful ones (concise yet general yet fast) but lots of people don't want to abstract this way.
[1] at a cost, you'd need high end machines to enjoy the benefits without the memory/gc issues.
Lisp (Common Lisp, anyway) has not changed in this century -- and even 20 years ago, Common Lisp didn't require a very high end machine (at work I had a modest Sun workstation and at home a Macintosh -- and both did just fine with Common Lisp).
It's still an amazing vehicle for exploration -- and it's still very good for building software. Some of Lisp's benefits lost their impressiveness because other languages have included those things as well.
But we live in BlubWorld.
And most people don't see the value in languages that look weird to them. They can't.
Lisp came before the 60s. I try to put myself in the shoes of the industry where cons cells and GC would mean 'no' to your business. It wasn't until the 80s that lisp was usable in the mainstream (wild guess).
And yes CL is perfectly adequate to write solid mundane software (quicklisp was a gift here). But in this context, lisp strength, strong metalevel facilities and culture, has no value. Plus they have costs too, macro-fu require a certain view point on code.
It's going too far to say "has no value". It may be true that its value is not immediately obvious, though.
In my opinion, Lisp is more attractive than any other language because of its Condition System -- though macros rightfully get more attention -- what it lacks is libraries.
But hopefully, that condition won't last too long. If nobody beats me to the punch I'm working on a way to steal Python's libraries by transpiling them into Lisp.
Libs ? quicklisp seemed fully featured. The problem seemed like a community / branding problem. People are used to python libs and word of mouth so lisp is a vacuum.
The condition system looks very nice, but I rarely see people talking about it. Not saying it is not useful, just that I'd love to know more about usage. Maybe at one point people leave conditions to go into typed programming too.
The 'no value' was a bit strong, I meant it relatively to trendy and stable languages.
Actually, Common Lisp has a very nice (optional) type system.
It is not uncommon to declare types once everything is working to speed things up -- so with Lisp, you get the best of both worlds.
What sets Lisp's condition system apart is that it separates signaling a condition, handling it, and restarts. In other words, the decision about which handler to choose for an exception is usually made in much higher-level code, where it belongs.
And when no suitable handler is found you get dropped into the debugger. While in the debugger you can create the handler you need, and then call it.
And all this without unwinding the stack at all.
So while in another language I'll have to restart a long running process over and over again until the code covers all the unexpected cases -- in Lisp I can just start off assuming the happy path and refine as I go along, without ever having to start over because of an error.
I almost always feel that people talk about the wrong things regarding Lisp. A huge deal is made over macros, but nobody ever mentions the reader which is what makes macros possible. And when people do talk about macros they almost never mention reader macros.
And sometimes people do make a completely justified big deal out of the MOP (meta-object protocol) -- but frankly, I think generic functions and multiple dispatch are far more important. Or the fact that Lisp offers multiple-inheritance done right (multiple inheritance gets a bad rap because most other languages lack the flexibility to properly handle them).
But seriously, the Condition System. It is in my mind, the killer feature of Lisp.
I wonder if you noticed the language which just shipped its first official version with:
* a typing system some call "gradual typing" (loosely similar to optional typing);
* a condition system;
* "grammars/actions" which are not only first class in the language but are self-applied in a bootstrapping fashion during parsing (which I'm thinking is equivalent in power to reader macros);
[1] at a cost, you'd need high end machines to enjoy the benefits without the memory/gc issues.