His conclusion there is, I think, fundamentally pessimistic- basically that we’ve hit the point of diminishing returns (at least for popular languages like C++, Fortran, and Java), and that the future of compiler optimizations is going to focus on a small segment of special users- High Performance Computing- and leave everyone else out to dry.

Which is yet another interesting aspect of Supero- he’s not focusing on “high dollar value” customers. I mean, his basic benchmark is word count. That’s about as plebian as it gets.

The dirty little secret of the “popular” languages are that optimization doesn’t help you much. Something I forgot to mention is Proebstring’s Law: that increases in compiler optimization double program speed every 18 years. That’s compared to the common misquoting of Moore’s law that has CPU speed doubling every 18 months.

And I think Proebstring’s law misrepresents the situation, to the benefit of making the optimization improvements look better that they really are. The justification for Proebstring’s law is that after 36 years of progress, programs are about 4x faster. But the vast bulk of that improvement was the low hanging fruit- a small selection of “simple” optimizations- peephole optimizers, register allocation, strength reduction, inlining- gives an easy 2x speed improvement, and were well known 36 years ago (1971). Which means over the last 36 years, compilers have only doubled the performance of programs- or about a 2% gain per year.

Parenthetically, this is why Ocaml can still be “speedy” and not have complicated, expensive optimizations- the complicated, expensive optimizations simply don’t buy you that much. It does the simple optimizations which net a lot of performance gain for (comparatively) little pain, but doesn’t bother with the optimizations which are lots of pain for little gain.

Then wham- out of left field comes a grad student and an optimization speeding code up by 10% to three fold. That’s like 5 years to 55 years worth of compiler optimization development at current rates, all at one shot. And he’s not done- there are probably (almost certainly) improvements to that to be made.

This is pretty cool that it’s being applied so widely, but I kinda expected this out of functional languages. So much is known at compile-time that I’d expect huge gains — in fact, I guess I was implicitly thinking that this was happening in OCaml, which is part of the reason it’s so speedy.