Niklaus Wirth is widely known as the creator of several
      programming languages.

      What is less well known is that he also personally wrote several
      compilers, including

      the first single-pass compiler for Modula-2 that later evolved
      into the initial

      compiler for Oberon5. These compilers distinguished themselves by
      their

      particularly simple design – they didn’t aspire to tickle the last
      possible bit of

      achievable performance out of a piece of code, but aimed to
      provide adequate code

      quality at a price-point of reasonable compilation speed and
      compiler size. At the

      time, this was in stark contrast to almost all other research in
      compilers, which

      generally had been characterized by an enormous and
      ever-increasing complexity of

      optimizations to the detriment of compilation speed and overall
      compiler size.

      

      In order to find the optimal cost/benefit ratio, Wirth used a
      highly intuitive

      metric, the origin of which is unknown to me but that may very
      well be Wirth’s own

      invention. He used the compiler’s self-compilation speed as a
      measure of the

      compiler’s quality. Considering that Wirth’s compilers were
      written in the languages

      they compiled, and that compilers are substantial and non-trivial
      pieces of software

      in their own right, this introduced a highly practical benchmark
      that directly

      contested a compiler's complexity against its performance. Under
      the self-

      compilation speed benchmark, only those optimizations were allowed
      to be

      incorporated into a compiler that accelerated it by so much that
      the intrinsic cost of

      the new code addition was fully compensated.

      

      Found through The Computer Language Benchmarks Game site:

      http://shootout.alioth.debian.org/dont-jump-to-conclusions.php

      

      Original paper: