Don't underestimate performance of the generated code when a JIT is in the picture. Very good example with the JVM just there.
Don't bank it all on faster hardware, make sure your software isn't slow first. Otherwise it'll bring quite some hidden costs.
Interesting deep dive on how sets and dicts are implemented in CPython. There are a couple of interesting tricks in there.
Interesting take about how performance optimizations can sometimes leverage even more performance gains than you would expect.
Interesting food for thought. Not necessarily easy to see it used in as many fields as the article claims. Maybe a bit too much on the techno solutionist side at times. Still, that sounds like an interesting guideline and path to explore.
What the title said, there's nothing fancy about optimizations. It's mostly well known knowledge, doesn't change much over time or on different stacks... still it's very satisfying.
Good reminder that "premature" doesn't mean "early". Poor Knuth is so often badly quoted in the context of optimization that it's really sad. The number of times I see "early pessimisation" on the pretense of avoiding "premature optimization". Such a waste...
Let's put this quote back in its context, shall we?
And this is why you likely need to optimize your data pipelines at some point. There are plenty of levers available.
Excellent deepdive about pipes, on the path to optimization we see how perf is used, how memory is managed by the kernel etc. Very thorough.
Really cool optimizations for B-Trees. Once the layout is reworked this is a neat way to use SIMD as well.
This is a good way to get into how Javascript engines try to optimize the code thrown at them. It's definitely not an easy job with Javascript...
Interesting set of SQL optimizations. Also shows PostgreSQL still had (has?) some room for improvement.
Long and nice article about collaborative editing algorithms and their implementation. The problem space is tough, benchmarking is hard, profiling as well and optimizing even more so. Very thorough.
Interesting use of Rust to optimize an otherwise completely Python base code. This is properly done, first profiling the problematic system finding where the bottleneck is, evaluating other options first, then finally biting the bullet. Leads to a dramatic improvement by just replacing a few lines of Python. This is far from the "let's rewrite everything in Rust" which is a good thing.
Interesting take on optimisation and complexity... Indeed it's probably best to not use the latter to achieve the former otherwise that complexity can never be removed anymore.