OK, the writing is sometimes a bit biased in my opinion (didn't you know Python is superior to any other language?). That being said, this is an interesting resource to get ideas on how the GoF proposed set of design patterns apply in the Python world. I like this kind of "how do things relate" resources.

Interesting examples where the Python type hints are used. This still needs improvements but it's clearly improving.

This is good news, this provide more venues for improving performances in Python modules next to switching to compiled Rust with something like PyO3. There's clearly a case to be more for not having to rewrite when the codebase was already mostly Python.

This has some interesting promises in terms of performance using Python. Looks a bit like a CUDA for Python... to be seen how it fares in practice.

Python is making progress regarding portable binaries and it is welcome.

Still controversial in the Python community, this post shows a balanced view on where it makes sense and where it doesn't.

Interesting points in there, indeed we rarely see things presented along an advantage in productivity for Rust when it's compared to Python.

Very early times but this could become interesting. Maybe worth keeping an eye on.

Wow, this is a very good exploration of the performances of several common languages and runtimes. This is one of the most thorough I've seen. A good resource for deciding what to pick.

The developing type system in Python is really having some nice properties now. Well used, it can help quite a bit with checking an API is properly called by user code. This is nothing new to languages with stricter type systems of course.

Polars looks like an interesting alternative to Pandas in the industrialization phase of a data processing pipeline. The performance difference are really notable with larger volumes. I'd be interested to see how much of it is lost when using its Python API though.

Interesting paper about the gradual typing experiments done around Static Python. Shows a few interesting properties. I wonder if some or most of it will find its way back to CPython.

OK, this looks like an interesting release, next to the performance improvements there are quite a few neat new features as well.

Good set of advices around dicts. This is Python centric but some of it applies to other languages as well. Mind the lack of anti-corruption layer.

A couple of good advises in there for a Django project inception.

And this is why you likely need to optimize your data pipelines at some point. There are plenty of levers available.

Excellent collection of surprising behaviors in Python. If stuck or wondering why something works in a surprising way to you, it's a good place to look.

Looks like a very interesting toolkit for low level network related or security related operations.

It was only a matter of time until this kind of things would be doable through webassembly. I'm wondering about the size of the payloads the browser needs to download though.

Looks like it's still in the very early days but the overall approach looks interesting.