Metamodular is Robert Strandh's site on Common Lisp, covering the SICL implementation, fast generic dispatch, and Lisp operating system designs.
HN links it for Lisp OS specifications and CLOS dispatch papers, and commenters discuss them in terms of Lisp machines and Lisp performance.
A growing group of us are implementing Clasp (https://github.com/clasp-developers/clasp) - a new Common Lisp that uses Robert Strandh's Cleavir compiler, interoperates with C++ and uses LLVM as the backend. Clasp is the foundation of Cando - a programming environment for the development of molecular devices (https://www.youtube.com/watch?v=mbdXeRBbgDM&feature=youtu.be). Robert Strandh is an exceptionally clear thinker and a fantastic programmer. I can't count the times that Robert has implemented changes to the Cleavir compiler source code and without him being able to test it (long story) passed it to me and it ran flawlessly in Clasp. I implemented his fast generic function solution within Clasp based on another of his papers (http://metamodular.com/generic-dispatch.pdf). Edit: Basically - if Robert writes it up in a paper - I want to have the implementation.
Once we develop molecular robots - they are going to implement LispOS. :-)
CLOS is currently slower, but there are some cool ideas floating around to greatly speed it up. The roadblock has been CLOS's dynamism: everything needs to be redefinable at run time, even the classes. But it's possible for an implementation to get high efficiency even with that, using separate code snippets that are reached by a single branch (although I don't know if any CL implementation does this yet):
http://metamodular.com/SICL/call-site-optimization.pdf
(I think a modern version of Common Lisp would take this idea and run with it, making most or all built-in functions generic.)
CLOS really shines when it comes to problems that benefit from method combination, which allows one to decompose computations into reusable nuggets that can be reassembled using multiple inheritance.
Macro expansion is done in the host environment, not the target environment. You can compile the macro definition to a function taking a form and an environment. This would be something you arrange for within your compiler.
CLTL2 specifies a function `parse-macro ` which is available in most implementations. Portably you can call it using the `trivial-cltl2` package:
https://github.com/Zulu-Inuoe/trivial-cltl2
Robert Strandh has written both papers and code for handling environments:
http://metamodular.com/SICL/environments.pdf
http://metamodular.com/clostrum.pdf
Features like generic dispatch in Common Lisp result in similar amounts of dynamism; methods and classes can be defined and redefined at any time so a lot of work goes into making that fast; see for example http://metamodular.com/generic-dispatch.pdf
Also similar to Kernel#set_trace_func, CL has TRACE (http://www.lispworks.com/documentation/lw61/CLHS/Body/m_tracec.htm) but unlike generic dispatch, that's not expected to be fast.
Maybe not applicable for the XR platform here, but you could add introspection capabilities not present in Linux, a la Genera letting the developer hotpatch driver-level code, or get all processes running on a shared address space which lets processes pass pointers around instead of the Unix model of serializing/deserializing data for communication (http://metamodular.com/Common-Lisp/lispos.html)
Python is not call-by-reference. If it were, we would expect 2 to be printed below, but it is not:
>>> def f(x):
... x = 2
>>> x = 1
>>> f(x)
>>> x
1
One might refer to r as being referentially transparent, or immutable (I don't know if it is--I am assuming). I would refer to python as using uniform reference semantics - http://metamodular.com/common-lisp-semantics.html