I think that different elements of the language call for a different approach. I believe that everything related to mutable shared state calls for a very conservative compilation approach, because the potential benefits seem to me rather tiny while the potential drawbacks seem very large (since when it comes to race conditions, runtime testing is at its weakest when trying to find bugs in the code generated after a compiler upgrade.) To me it doesn&#x27;t make sense economically. But this is not the case with a whole lot of other optimizations. I think that making this distinction is my modest attempt at being on the right side on this issue :-)<p>(So I agree that the original quote taken literally and out of the original context does become a nice talking point contradicted by reality; I think however that it&#x27;s much more sensible in its original context - and the context of this discussion - this context being optimizing code working with mutable shared state.)