A good reminder that "push it to the GPU and it'll be faster" isn't true. If you move a workload to the GPU you likely have to rethink quite a bit how it's done.

We can expect this to be a game changer for the C++ ecosystem. A couple of examples are presented in this article.

What is premature optimization really? If you look at the full paper it might not be what you think. In any case we get back to: do the math and benchmark.

I'd like to see the equivalent for Europe. Clearly in the US things aren't always great for Internet access. The latency is likely higher than you think, and the bandwidth lower.

Or why this kind of question never have an absolute answer.

The memory models for GPU programming are complex. This isn't easy to squeeze more performance without introducing subtle bugs.

Interesting comparison between C++ and Rust for a given algorithm. The differences are mostly what you would expect, it's nice to confirm them.

Looks like Linux is now the best operating system for gaming on the go.

A bit dated perhaps, and yet most of the lessons in here are still valid. If performance and parallelism matter, you better keep an eye on how the cache is used.

Or why it's hard to truly evaluate performance in complex systems. We often test things in the optimistic case.

Or how it's possible to expose an object-oriented like API for a data oriented framework without sacrificing on performances.

Interesting trick in Java internals which is especially improving map lookups.

Nice little article. It's a good way to point out that aiming for the lowest Big-O approach is often not what you want in terms of performance. Always keep the context in mind, and in doubt measure.

This is indeed a nice tool to explore and check the memory layout of data structures.

Nice little comparison of raw loops and ranges in C++. As always, measure before making assumptions... Unsurprisingly it ends up on the usual readability vs performance debate.

Looks like a nice resource to get better at finding the root cause of performance regressions and optimising code.

Interesting reasons to let go of Rust, some spaces indeed can have a safety vs performance tradeoff which would justify using good old C.

Nice performance comparison of file handling in multithreaded context. It's surprising how slow MacOS seems to be there.

It could be so much better indeed. Unfortunately in great part this is about UX design and carrying heavyweight frontend frameworks though...

Looks like an interesting DSL to write high performance Python code.