Too often people mistake the algorithmic complexity theory for the real performances you would get. This can't be further from the truth. The memory layout trumps all. As usual you need to measure.
A reminder that web frontend work isn't as easy as it sounds. It brings quite some caveats and his difficult to do well. Otherwise you wonder why things stutter or render badly.
When more concurrency might not help. Illustration with the case of database queries.
Careful how you use DISTINCT or ORDER BY on very large tables. You might want to reevaluate (after checking if there's a problem of course).
They're definitely handling this part right, they seem well ahead everyone else.
Nice post on how to approach problems suitable for SIMD.
This is too often forgotten. If you can avoid the "if" and your CPU will thank you for it.
Excellent piece diving deep into the opportunities to optimise an algorithm. The final speed up is impressive.
Interesting trick to detect table scans with SQLite. I can see that useful in development to optimize systems.
Or how to properly paginate results when you have a database.
More latency exploration on Linux for games. The results are interesting. Unsurprisingly the X11 vs Wayland difference is much less dramatic than what people make of it.
There are ways to have a lighter web. It leads to interesting techniques too.
Interesting Rust options to limit the amount of heap allocations if you're constrained by memory or for performance reasons.
Unsurprisingly cache locality is a very important factor. What's interesting here is that it still applies to a language like Javascript where you'd expect to not have enough control on the memory layout to reap any benefits.
Interesting article applying data oriented design to parsing tasks. This is really a good approach for performance.
Interesting experiment on how to totally break the performance of memory accesses. This gives good insights on the whole chain works.
This is just the beginning in a way, but it'll be a game changer for Java. The value classes will allow for better memory density.
A long but very interesting piece starting all the way from early typing on machines to more modern input systems. It's very focused on Apple machines towards the end, but there are good design lessons to draw from the long perspective.
It's definitely easier not having to scale at all. Which is what you get when you design for local first / client side.
Interesting read, this is really tricky to measure such latency. It looks like we might have room for improvements on latency still. Curious to see if the proposed fixes will make it in kwin.