Want to better understand the JIT approach introduced in Python 3.13, this is a good little article. This JIT is a first step towards more optimizations.

Interesting trick even though I always cringe at such difference of behavior between runtime and "compile" time.

Overview of the differences in behavior between the two most popular ORMs in the Python ecosystem. This shows interesting different design options for such things.

Very interesting musing about undefined behaviors and language constraints. This is a bit Rust focused for obvious reasons but is also looking at what other languages have been doing.

This is unsurprisingly highly depend on the actual code, not only on the hardware.

Nice illustration on how pattern matching can simplify code and make it easier to write.

The fact that they felt the need to write such a letter is troubling. What's going on in the Python Software Foundation really? Something needs to be fixed it seems.

If you wonder what's happening on the JIT front in CPython land, here is a talk explaining what's coming in 3.13.

Since quite a lot of Python code will be impacted by this, better get ready.

Won't be easy to get rid of the GIL in the Python ecosystem. There are notable differences of behavior between implementations and even versions of the same implementation... Lots of user code will unwillingly depend on a specific set of guarantees.

Nice to see the same optimizations than in a previous article play out in Python. By leveraging Numpy and Numba it goes a long way already.

A few good things went unnoticed. The performances are still not there.

Nice improvements coming to the Python typing system. Especially interesting in the case of kwargs.

There's still some work to secure the Python supply chain. It's clearly suffering from fragmentation and ambiguous data.

Definitely a clever combination of two Python constructs.

Nice summary of everything you can do with operators overload in Python.

OK, this could be big for Python. Let's see how they execute this plan. It carries some risks as well, but they seem well aware of them.

A little article which serves as a good introduction to the pytest fixtures. They are indeed very useful I think.

Unsurprisingly, it's not as simple as it sounds. Type hints in Python can be used for various reasons but performances is rarely the main motives. It'd need other adjustments to the runtime. People are working on it, and this article is an interesting dive on how things work under the hood.

Good set of advises for Python APIs. Some applies more generally though.