There's one thing I always wanted to understand about working with image-based system (like a lisp-machine o smalltalk VMs): when you change a class or a function, how do you manage the mismatch between the code you have just written and an already running version. For example: you change the definition of a function on a live system, and then you go home for the weekend. Monday morning you notice a background process running that uses that function; how do you check if the version used is the old one or the new one?

You check the stacktrace of the background process and see which function got called. How you do that depends on the implementation. If you have some handle to the called function, you can check that against the current definition. Functions are 'objects' and you can compare them for identity. In real implementations there also will be some id.

Did the function object have a reference to the source object, so that it would be possible to read the original source until it is garbage collected?

I never used Smalltalk, but I've read they had migration function to analyse impacts and correct them before applying changes.

scsh hackers might enjoy using geiser-scsh:

https://github.com/rmloveland/geiser-scsh

Very cool! I'm not a Scheme fan (Common Lisp all the way!), but it looks like some nifty stuff. Nicely done.

Another Racket friendly Emacs major mode is Greg Hendershot's racket-mode.

https://github.com/greghendershott/racket-mode

I don't think the Lisp Machine actually ran Scheme, did it?

No, the two branches (Symbolics and Lisp Machines) ran their own Lisp Machine Lisp which was a fairly complex melange of MacLisp-derived CommonLisp-precursor constructs.

Plus it had its own object system (Flavors).

No, but you could ran 'Pseudo Scheme' on it.

http://mumble.net/~jar/pseudoscheme/

The native languages though were Lisp Machine Lisp and then also versions of Common Lisp, for example Symbolics Common Lisp.

No, but that's really not the point of the analogy.