Early days but this could help better use lazy imports in Python. It's not exactly a transparent process.

Probably more than you think in this setup. And even more in C++ with the STL having years of smart tricks behind it.

Interesting way to deal with deprecation in Python. Indeed sometimes it doesn't hurt to keep the not so ideal old name... but you want to push user code to know they miss an opportunity in readability by using the old name.

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 not of a long introduction with generalities about APIs and ABIs. It really gets interesting when it covers the CPython specifics and the challenge they had keeping compatibility at the ABI level. This gives a good idea of the complexities needed to build wheels for Python packages.

Another type checker for Python gets stabilised. So many options and fragmentation in this space. This is odd.

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

Looks like an interesting ORM which brings advantages of the Django one without all the bagage. It's still young, let's see how it evolves.

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

Interesting new tricks with the introspection of Python type annotations.

Of course it's a question of the amount of allocations you need.

Looks surprisingly easy to profile the Django startup. Probably makes sense to profile other parts of your application but this is likely a bit more involved.

Looking at several languages and their reflection features. What's coming with C++26 is really something of another class than anything else. I just have concerned about its readability though.

Nice improvement in Python for waiting the end of a subprocess. Explains nicely the underlying options and available syscall if you need to do the same in your code.

Neat little Python trick for testing exceptions.

OK, this is definitely a very cool hack. It can definitely help to debug locally.

A very comprehensive view of Python memory consumption and the speed of common operations. Some of the numbers are higher than I expected.

The situation about file locking is really complicated in the Unix systems family.

Unsurprisingly, this is mostly not related to the use of Rust. The design choices are what male uv so fast.

This is definitely an exciting new option for Python development.