Todd Proebsting

> this describes compilers for all modern languages Yes, this is the current trend. And the results don't really justify the cost: http://www.complang.tuwien.ac.at/kps2015/proceedings/KPS_2015_submissi… http://proebsting.cs.arizona.edu/law.html Which is why I (roughly) agree with Daniel Bernstein's polemic "The Death of Optimizing Compilers" https://cr.yp.to/talks/2015.04.16/slides-djb-20150416-a4.pdf (I frequently make code 10x to 1000x or more faster, and compilers' contributions to that total tend to be fairly minimal, though larger than zero and usually worthwhile. But not worth the current shenanigans and not worth having no idea how the code is going to turn out)

Can't answer your question, but here's the law (I was curious myself): > I claim the following simple experiment supports this depressing claim. Run your favorite set of benchmarks with your favorite state-of-the-art optimizing compiler. Run the benchmarks both with and without optimizations enabled. The ratio of of those numbers represents the entirety of the contribution of compiler optimizations to speeding up those benchmarks. Let's assume that this ratio is about 4X for typical real-world applications, and let's further assume that compiler optimization work has been going on for about 36 years. These assumptions lead to the conclusion that compiler optimization advances double computing power every 18 years. QED. > This means that while hardware computing horsepower increases at roughly 60%/year, compiler optimizations contribute only 4%. Basically, compiler optimization work makes only marginal contributions. > Perhaps this means Programming Language Research should be concentrating on something other than optimizations. Perhaps programmer productivity is a more fruitful arena. https://proebsting.cs.arizona.edu/law.html

in the "closing thoughts" [1] of the OP article there's a pointer to "Proebstrings law" [2] which got me to a benchmark [3] how LLVM has improved over 10 years from 2.7 to 11 which leaves me with the strong intuition that indeed what mit benefit more from a rethink is not optimizers but focus on programmer productivity > Perhaps this means Programming Language Research should be concentrating on something other than optimizations. Perhaps programmer productivity is a more fruitful arena. [1] https://typesanitizer.com/blog/rethink-optimizers.html#closing-thought… [2] https://proebsting.cs.arizona.edu/law.html [3] https://zeux.io/2022/01/08/on-proebstings-law/

Proebsting's Law comes to mind: https://proebsting.cs.arizona.edu/law.html

The ability of compilers to make code faster is 12 (twelve) times slower than Moore's law: they double the program's speed in 18 years [1]. [1] https://proebsting.cs.arizona.edu/law.html This might seem discouraging, but it is not - one can still reap the benefits of code optimization twelve times as long after Moore's law stops working.

At least Proebsting's Law doesn't look so depressing anymore, by comparison: https://proebsting.cs.arizona.edu/law.html

There’s this example of your point, which claims that “Compiler Advances Double Computing Power Every 18 Years” http://proebsting.cs.arizona.edu/law.html

> We're driving around in electric cars, carrying around cell phones that are orders of magnitude faster than desktop PCs from 1996, and communication technology I'd argue that these are primarily hardware innovations, not software innovations. The OP mentions software, not technology in general. See also Moore's law (hardware upgrades double computing speed every ~2 years) vs Proebsting's Law [1] (compiler upgrades double computing speed every ~18 years). [1] http://proebsting.cs.arizona.edu/law.html

The derivation of that law is very suspect: http://proebsting.cs.arizona.edu/law.html (go on, it's just a paragraph.) The key issue that this ignores in my opinion, is that a compiler optimization will rarely make last year's program faster, but it will make next year's program faster. Why? Because if the compiler can't make an optimization, programmers will do it by hand, even if it makes the code worse in some way. For instance, if your C compiler can't inline small functions, you would use a macro instead. When it finally starts learns to inline, your program won't get any faster, but the next version will be able to use functions in places where macros are a bad fit. Pile up enough of these optimizations, and eventually it starts to feel as if you're coding in a higher-level language than before, even though the syntax that's accepted by the compiler never changed.

The earliest Wayback Machine archive of that link is from August 2000: https://web.archive.org/web/20000824013718/http://research.microsoft.c… Looks like in December 2008 (between https://web.archive.org/web/20081204015038/http://research.microsoft.c… which works, and the next snapshot on Dec 30) it started redirecting to a new URL (https://web.archive.org/web/20090224224249/http://research.microsoft.c… which was still working as of 2012-03 (https://web.archive.org/web/20120307142916/http://research.microsoft.c… Meanwhile, https://proebsting.cs.arizona.edu/ says that Todd Proebsting joined the University of Arizona in August 2012 after leaving Microsoft, so presumably that's when the link stopped working. He still has it up at his new site: https://proebsting.cs.arizona.edu/law.html