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.

Really smart SIMD trick which packs a punch.

Which means simpler models: and this is fine for most use! It's also easier to have more ethical options with the smaller and more specialised models. Let's not forget they exist even though the big industrial complex would like people to forget.

There is clearly a sweet spot around 60 fps. Beyond this... You quickly end up in cargo cult territory.

A good illustration that you can beat classical algorithms by taking into account how modern CPUs are designed.

There's a whole swat of solutions for very lean services. You can go a long way reducing complexity as much as possible. Less infrastructure bills are definitely welcome.

Interesting article which goes deep in comparing joins vs denormalised big tables. The conclusion is in the title, bit it's worth a read for the other insights.

Looks like an interesting tool to check your SQL queries on the CI.

Looks like an important Wine 11. Well done to them!

A very good talk which walks you through how to move from object-oriented design to data-oriented design. Shows quite well how you must shift your thinking and the difficulties you might encounter with data-oriented designs. I appreciate a lot that it's not just throwing object-oriented design out of the window, indeed you have to pick and choose depending on the problem space. Also it's interesting to see how C++26 reflection might make some of this easier.

Not all CPUs are born equal in term of branch prediction. Interesting little benchmark.

These are good rules. Take inspiration from them.

Interesting read on how the CPython JIT effort has been saved.

Here are the main levers to make Python code faster. Tries also to distinguish the effort level of each approach.

We got options beyond poll() nowadays.

Interesting approach to provide more fairness to client requests.