On the other hand, increasing performance by 0.5% at their scale is big savings. Certain kinds of optimizations can save over 10% in runtime performance, easily. That means less compute, less engineering time spent optimizing with other approaches, snappier performance compared to the competition, and so on.

Yeah, pay the "business" person better who decided, wisely, to fund these kinds of projects. But in my experience, it's a lot easier to find a strategic thinker who can understand my previous paragraph than it is to find an engineer who can accomplish it. It's especially hard to find engineers who can see that opportunity, explain it well enough to get funded, and bootstrap the project until it shows enough promise to justify itself.

You're not wrong, though, that network effects and so on are a much bigger determinant in competitive advantage at a large scale. But "business strategies" can and do include ideas like "don't buy extra data centers".

1% on HHVM is a number I can’t say more about than no one would believe it.

Compilers are why we can write in C++ instead of assembly. The related fields of interpreters and language runtimes are why we can write in Python.

The optimising part makes languages that are faster to develop in run fast enough that they can actually be used to build useful things.

Bugs introduced in that stack are horrendous to run down, easy to introduce and broad in fallout.

Rather a lot of our modern tech world is built on compilers. It's a great example of where compromising on engineering capability scatters costs and breakage all the way through the system.

While you are not wrong, it isn't the full picture. For most projects we don't need more language/compiler performance. Most web sights are served with a handful of servers, likely shared servers on AWS or something (so that you can get full data center failure redundancy - which is probably overkill). The total cost to run the servers isn't all that much on the bottom line and so you shouldn't pay more for compiler optimization.

Of course google, facebook, and other large companies should be paying for optimization as it will pay off, but the vast majority of systems don't run at that scale. For most optimization is about ensuring response time is acceptable, and that is generally more about optimizing your code not your compiler.

Its not even that you’re wrong in any meaningful way that makes this endlessly looping class of argument get under my skin.

I think it’s maybe more like: we need an HN where it’s unanimous that the computer side of optimization is life-and-death, and an HN where winning and losing is about other things, any language or database or algorithm is fine: we’re playing a different game that pays off just as much if not more.

People routinely make more money than they can carry on like node.js or whatever, it’s not a “better”/“worse” thing. But some people are looking for edge on gritty nuts and bolts of computing stuff, and some people are laughing all the way to the bank on this whole other category of thing that I can’t even do justice to in summary.

Trying to weld together an unspoken (except by idiots like me) consensus on how to stack rank these very different activities just seems to piss everyone off.

This only works because you already have access to an optimising compiler and high level language implementations, likely both available for free, because other people and organisations have already paid for them to exist.

Nobody said they're not important.

Try building FB or Google without technology, and then you come back and say that the business strategy is all you need.

Sure but that isn't what I said. Big data, cloud services smart tech people definitely needs to be paid as much as the smart business people. Compilers, meh.

You’ve got a point, which is that kickass compiler people often love PL so much that they’ll do it at a deep discount.

I’ve found this on average to more true of “niche” languages: Julia, Haskell, etc.

C++ compiler people much less often fuck around on their comp.

In my experience.

To the GP, not the parent (who is dead on), can I watch?

I agree that there are better examples than LLVM optimization paths. I was making a lame joke about the Mozilla open source documentary: not your bad it was so obscure.

Everything is math now. Google et al played a this-far successful strategy where they made the “know your shit” engineer TC 1MM so the hackers wouldn’t rebel and take the whole cake, like they could.