I was happy to read this... it seems to me that adding a compiler optimization that in turns makes the compiler significantly faster must be some kind of thrill in itself.
I am told that Niklaus Wirth only allowed for compiler optimizations in which the optimizations paid for themselves in speed, when compiling the compiler. This is said to be the reason for the Oberon compiler's speed. [1]
I have only skimmed Dybvig's paper on Chez Scheme, but I think it would be interesting to compare the speed of a compiler that uses Dybvig's nanopass framework [2], and a compiler optimized according to Wirth (using only a single pass).
It was a fascinating read of evolving a system from 8-bit to 32-bit to 64-bit with many rational or clever development choices. I like how they kept improving performance while keeping quality as high as can be. The willingness to rewrite or toss what was necessary to keep the whole thing sensible is quite a contrast to other legacy systems that force people to work around crud forever. They also learn from the past better than most in that a solution to an 8-bit problem in version 1 ended up solving a similar problem in the last, 64-bit version. Shows value of keeping those old tricks and papers stashed somewhere just in case.
Definitely adding it to my collection as there might be lessons for a Racket reimplementation or a certified LISP project in the future. Hell, their low-level stuff might even be useful in a LISP processor or hardware/software architecture. Who knows. Thanks for the good read, though.
