You're maybe right with a generic idea of Lisp that includes all of Clojure and most Schemes and random GitHub "lisps", but I think Common Lisp (and its immedia

You're maybe right with a generic idea of Lisp that includes all of Clojure and most Schemes and random GitHub "lisps", but I think Common Lisp (and its immediate predecessors) really does give you that and. "Going faster" or just lower doesn't really require anything like the contortions and sacrifices that something like moving from Python to Cython/RPython does. (As an aside, I recently came across and was amused by the existence of https://pypi.org/project/PeachPy/ https://pypi.org/project/PeachPy/) To take an example from the Lisp machines, here's the method (in the full OOP sense) for receiving UDP packets: https://twitter.com/RainerJoswig/status/1215728406823886854 https://twitter.com/RainerJoswig/status/1215728406823886854 High level code, which you can jump to while the system is running, edit, debug, recompile, but for a fairly low level networking task. With modern SBCL, you get some nice compiled assembly from your code out of the box but you can output your own custom assembly if you want yet still not lose out on interactivity and recoverable errors (way beyond typical exception handling). You also never lose macros, so things like ugly-ish repetitive magic-number-seeming (technically from a datasheet) code poking at bits in status registers can be nicely abstracted. The topic of just GC and precisely managing memory when you need to is more involved, and I'll admit that certain strategies are little different from a C++ style (i.e. allocate a bunch of memory ahead of time and re-use it, rather than calling slow delete/letting the GC work to reclaim it), but even if Lisp isn't where the state of the art is (I'd give that to the JVM ecosystem where you have things like ZGC's average 50 microsecond pause times) the ones you have these days are a lot better than those of the 70s (which seems to be where some people think all GCs are still at) and the subset of low-level programming tasks where it really pays off to mess with a lot continues to get smaller...