LISPs all seem tremendously resilient.

I wonder what intrinsic quality makes a language long lived, rather than blame communities and whatnot.

Another stalwart is Pure Data, the DSP language I am very fond of. It's based on atomic principles. Indeed the primitive processing elements are called Atoms, being irreducible ops like multiply, add, sin and cos. There really isn't much that can change. For C as for LISP, especially Scheme, it's hard to break them down any further, yet they are high enough level to be useful for programming. There's some sweet-spot to be found.

Ha, I just wanted to bring up Pure Data as example. It takes backwards compatibility very seriously. Patches written 20 years ago should run just fine on any recent Pd version. In fact, Miller Puckette strives for at least 50 years of support. Pd just had its 25th anniversary, so there are at least 25 more years to go :-)

Run a forty-year-old FORTRAN program on your mainfram... oh, you already are?

This isn’t entirely true about Clojure, because there are things that have broken as new Java versions have come out (especially with modules and exports etc). Obviously you can still run Java 8 if you want though.

This can happen, but it's not very common in my experience. E.g., I tried an early version of Clojure (1.0, I think) on Java 13 and it ran just fine, although I didn't seriously test it

Sure, I wouldn't expect clojure.core to break ever. Maybe we'll get some future version based on Project Loom and that'll require some thought.

But I've had to work out weird command line incantations for various libraries that touch crypto or JavaFX namespaces. And things like Quil are still in a weird state on modern JVMs.

I would love some concrete data on this! Has anyone done any studies?