Contrary to popular belief, data races are definitely a reality in Python. Don't be fooled, the Global Interpreter Lock won't prevent them.

Type annotations become quickly complex with Python. This is in part because it's rolled out incrementally on top or existing practices. Here it collides a bit with decorators. Nice to see this hole is getting plugged though. Also nice to discover an alternative to mypy which seems a bit more precise (at least for the time being).

Interesting caveat on how lru_cache is used in Python.

Good explanation of the Python object model and how parameters are passed to functions. This can look rather surprising or confusing if you come from another language. Always keep in mind: mutability and the fact that variable name are just labels play a big role in this. That means you might need to copy explicitly in the case of mutable objects... which makes the performance burden explicit as well (and this means you need to pick between shallow or deep copying).

PS: I really mean "label" here (like in the post), it's a bit different from "pointer" since you don't get the pointer geometry (you can only reassign). From the C++ perspective I'd say it behaves as if all variables were "reassignable non-const references" only, something like that.

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.

Very nice introduction to the bytecode used in CPython.

I think this applies more largely to any evolving language or ecosystem. You rarely can know such a thing in full and if you do it's only at a given point in time for a few given contexts. Only path to expertise in our field is practicing in various contexts and staying up to date as much as humanly possible.

Good reminder on why mypy is an essential mitigation to use when dealing with Python. This avoids some quite common mistakes.

Good summary about string formatting in Python. Clearly helps to decide between f-strings and the fomat function.

This explains quite well why I liked to have type information in my code bases. This also shows a few interesting bits of mypy use.

This could be a game changer for a future Python 4.

Another profiler for Python which looks interesting.

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

Illustration of one of the traps I hate most with Python.

Similar to RR but for Python.

Definitely worth it indeed. Couple of interesting tricks in this article.

Another couple of attempts at supply chain attacks. This time in the Python ecosystem. The skill level of those attempts isn't high though.

Now that finally looks like an interesting approach to make GPU computation more accessible to the public. This seems to do a few things right to lower a bit the complexity while retaining good performances.

A very thorough resource on how the Python import system works. Very convenient to figure out what's broken when something goes wrong.

A nice list of interesting nuggets from the functools python module.