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.

Debatable "feature", bad implementation, dubious community handling... Clearly not a good example to follow from the Go space.

This looks like a very interesting tracing tool for debugging and profiling purposes.

That looks like a very interesting tool for larger Python based projects. Definitely need a way to profile memory use in there.

Oh this is really neat! This is a good way to visualize how it evolved over time, I find the period starting in 2005 especially interesting.

Really cool optimizations for B-Trees. Once the layout is reworked this is a neat way to use SIMD as well.

Interesting use of WebAssembly for fast and very portable code. Also especially interesting is the care in the move to the new software architecture.

Interesting tips for potential bottlenecks in your queries.

Not necessarily unknown paths to squeeze more performance out of Python. Still it's nice to have those options measured and listed in the same post.

Good reminder that CORS can have an impact regarding the performance of your application.

Good reminder on how a shared atomic can become a huge bottleneck in multi-CPU setups.

Mostly about the general approach on how to profile this kind of things. Still a couple of interesting pytest specific tips in here.

Interesting exploration and workaround for the Postgres query planner.

This looks like an interesting full system profiler.

Interesting piece covering: how a memory allocator works, why it can be slow, how to use it the best way possible and how to pick an allocator for your project.

This is a very interesting deep dive in how branch predictors work. Also comparing timing profiles between different families of CPUs.

Excellent reminder about where the limit is for the compiler to optimize things. Nowadays it's mostly about the memory accesses and then it means that the design matters a lot. Object-oriented designs being far from optimal here. Data-oriented designs fare much better but are definitely less friendly for human brains to reason about them.

Very thorough analysis on the kind of web frontend performances you can expect for most people on mobile. Since we basically need to reduce the footprint of such frontends to make this sustainable again this is a very welcome article.

Obviously didn't read it all but this is a very large knowledge repository of practices from many companies one can get inspired by to work on Site Reliability Engineering. It is especially comprehensive since it's not only about technical tips but also deals with hiring, team building and culture (which is almost as important if not more).