The latter one I point to often is the problem of efficiently compiling a dynamic language, where (for example) the offsets of slots in objects can be changed at run time, or (another example) where the set of methods for a generic function can change at run time.
See Robert Strandh's paper in https://european-lisp-symposium.org/static/proceedings/2021.... (page 72)
https://clasp-developers.github.io
"Clasp is a new Common Lisp implementation that seamlessly interoperates with C++ libraries and programs using LLVM for compilation to native code. This allows Clasp to take advantage of a vast array of preexisting libraries and programs, such as out of the scientific computing ecosystem. Embedding them in a Common Lisp environment allows you to make use of rapid prototyping, incremental development, and other capabilities that make it a powerful language."
There doesn't seem to be any way to feed C++ headers into clasp and get out template instantiations accessible to lisp. It looks like SWIG or pybind but you write the shims yourself, and it's function pointer based so templates are wrapped one instantiation at a time.
Garbage collection in the docs is a one paragraph stub which suggests you're on your own for lifetime management across the languages.
Cool thing to exist. Seamless interoperation is either overselling it or the docs are out of date.
Hissp just released version 0.4.0. It compiles Python tuples to Python expressions and has multiple readers with different characteristics, not all of which are based on S-expressions.
Common lisp is flexible enough that it's reasonable for projects to stay within the immutable standard, so only library progress happens.
Scheme has given up on the minimal side to the design and become over-obsessed with complicated macros and static compilation. I suppose that's change, if not progress.
Clojure I can't say much about. I like the hashed trie and do not consider the JVM connection a feature. Maybe that is still changing over time.
Racket is still doing its thing, but the current push (Rhombus) seems to mostly be about removing S expressions.
Kernel is a different lisp. Tragically we lost the author too young. Kernel deletes most of the limitations and cruft of _scheme_. It would benefit from a sbcl-level of development effort which doesn't seem to be happening.
I'm interested anything else strange from the lisp world if people have references.
Innovating in the C derivatives continues at pace of course.