Is it still at the "top end of the power spectrum", against which all others are merely different shades of Blub? And if so, _which_ Lisp and why?
Obviously this is asking for subjective opinions and experience among the crowd.
In one or another Arc (or Bel) intro essay, there's this notion that "a true hacker's-dream language" would be a new Lisp other than Common Lisp which is there accused of various suckages, and apparently also other than all the numerous Scheme variants (at least in the "no such corset of 'hygienic' macros, plz" sense). Perusing the various search results on 'CL vs Scheme / Racket' had me personally more convinced of CL for heavy-duty "real-world", non-"write-yourself-a-Foo" projects, though (wrt. perf / compilers / library ecosystem).
The last time I got hooked on pg's persuasive Lisp essays and got into it for a short while (cooking up an SSR templating engine somewhere in the PHP/ASP/Handlebars sense for Hunchentoot as a starter exercise) was in 2008. Real-world projects lured me away soon enough then and I didn't really miss it tbh. That short episode of first Lisping to me was just "kinda alright" rather than the-most-hackery-experience ever. Then ca. 2011 unleashed the novelties (for me) of WebGL, NodeJS, Golang and more, and those were enough "hackers delight" playgrounds for me for years to come.
But revisiting the essays (by now it might be nostalgia, like re-reading/viewing one's certain personal all-time / youth-time favourite novels, comics, movies once per decade or so, I guess =) I'm once again lured by the promise of "the language at the end of the power spectrum" against which every other one is just some shade of "Blub". Then again, I went into almost every language I ever got into from this sort of promising sense of power potential, including Haskell, C, and even Go (pre-generics) in its own ways of "power through simplicity, and then just code your code-gens for those rare meta-needs". (Zig, too, but though enjoyable, that kept changing itself up frequently enough back then to move me back to more settled grounds.)
You see the one sticky situation I keep ending up in is that I'm, in pg's words, always "painting myself into a corner" all too soon, hacking away iteratively and "dirtily" (in the make-it-work, then make-it-fast, then make-it-pretty/correct/maintainably-architected spirit — but I don't really get to the last part and only some of the 2nd if at all —we're talking green-field personal side projects here—, but anytime I start with the last part, it goes nowhere fast, nay slowly actually). I can paint myself into a corner in QBasic as well as in Haskell and anywhere in between (and lest I totally burn out my natural curiosity toward tech to learn to make things, I have to keep reminding myself that they probably aren't to be blamed as I'm the constant factor in all these experiences). And I keep picking up that "building stuff On Lisp" is maybe The One basis where that's either least possible / likely, or not a particularly impeding problem / hindrance due to "ever molding the tech basis / language itself around and toward the problem you're tackling".
So, what's your hot take on this question, your personal opinion, your experience report? In 2024, some ~30 years after On Lisp and some ~20 years after those essays, all the other languages have kept picking up nearly everything once-cutting-edge about Lisp, other than the "parensy pesky" that pg insists is Lisp's real power (convincingly so, at least from-a-distance, I might add), that whole melange of "sexpr (non)syntax / code-is-data / code-is-the-AST / read-time+compile-time+run-time macros in the same (non)language".
(And then, do we start purity-spiraling in a fever dream of a one-true-Lisp without the "suckages" of the existing and in-widespread-use ones? Probably not, eh?)
At the same time, the state of the art in programming languages has advanced since PG wrote those essays. Even many of the languages which he was presumably referring to as "Blub" are much better now than they were.
A bigger issue is: As one gets better and better at computer programming, at some point the specific implementation language starts to matter less and less. (It never completely ceases to matter; but, less and less.) In one of his essays, PG contrasts "applying Bayesian filtering" with "applying if statements", which describes the matter quite aptly. At some point, language constructs such as "if statements" really do melt away.
For this reason, I reject claims that using a certain programming language will make one "1000 times more productive" (or similar) out of hand. The big problems in software are not at the level of the language at all.
This may sound false to newer programmers who have just discovered a fantastic programming language which allows them to work much faster than they could before. To such ones: I've been in your shoes. I've tried many languages, perhaps even the one you are enamoured with now. The benefits don't scale indefinitely. At some point, as you apply your fantastic new language to bigger problems, you will find yourself wrestling with the same issues as you used to with your old language, perhaps in a different form.