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.

A good reminder that it's not all rosy with Python type-hints. There's definitely room for improvements.

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

Interesting use of Rust behind a Python API. This is IMO an interesting niche for the language.

Nice list of lesser known tricks with Python formatted string literals.

This completes the article about why the GIL doesn't prevent data races. It explains in a bit more detail how the incrementation was creating the data race.