🚀 go-pugleaf

Currently, single pass compilers are very popular, due to their speed.  This
speed allows the development cycle to be shortened, sometimes by very
significant amounts.  However, unless I'm very wrong, the speed of the
single pass compiler is gained at the expense of code quality.  One 
immediately obvious solution is a code optimizer, which could be used on a
compiled program once the critical debuggion is done.  However, such a 
code optimizer could also be put to another, and potentially more powerful
use.

The Mac and Amiga worlds are currently in the process of changing from the
68000 processor to the similar, but more powerful 68020.  The 68030 has also
been rumoured to be lurking somewhere on the horizon.  However, regardless of
whether a '000 or a '020 is installed, the same code is used.  Thus, if a 
system is using the more advanced '020, it is using code which was written for
a more primitive, though similar, processor and thus the code does not take
proper advantage of the more advanced features of the more modern processors.
The same agrument applies for the math co-processors, the 68881 and its new
sibling the 68882, which are rapidly becoming more popular on home computers.

The code optimizer, if properly written, could remove the inefficiency of
using primitive code on an advanced processor, simply by modifying the
code to take advantage of the features of the more advanced processor.
Since not everyone has a 68020, it would be left up to the user to decide
whether or not (s)he wants the code of a program modified in such a way.
The optimizer could also be written to rewrite the program code so as
to take advantage of a coprocessor, it one is present.

Is there some fundamental problem with what is described above?  Is anyone
working on such an optimizer?
I welcome your comments and criticisms.

	Johan Larson