The main idea presented in this text is that the semantics of a programming language can be readily expressed in a programming language. The idea is fairly obvious and has been around in various guises for almost as long as programming languages. As usual, however, the devil is in the details.
The method outlined in this text has evolved over a period of eight years. It has been applied to various small language subsets as well as to one fairly complex language (Slim). It seems easiest to use on functional languages - languages with unrestricted gotos and pointers (like C) are perhaps more difficult to handle with this method than with translational semantics.
At the moment, compilers constructed with this method essentially amount to executable specifications. I would thus recommend the method for use in rapid prototyping of new languages and for constructing language standards. While it is ultimately a matter of taste and preference, I unhesitatingly recommend that this method be used instead of other formal approaches.
The use of partial evaluation as a means to turn an executable specification into a production compiler still has to be explored further. Work is underway to turn the Slim semantics into a full scale partial evaluator. Preliminary results appear promising., but the bulk of the work still has to be done.
If the Slim compiler can be made clever enough, other compilers
can ride on its back and the rather immodest claim in the introduction,
that the work required to produce a compiler has been reduced
to the absolute minimum, may well be justified.