Interesting post which gives plenty of insights on how async Rust is designed and behaves.

Just a little dive in the Rust standard library. It gives a good idea on how they pile layers to ensure safety while providing a nice API on top.

Of course I agree with this. We should fight undue complexity at every step. This beast tends to creep up very quickly and we're all guilty of it at times. This is indeed particularly obvious in otherwise rich languages like C++ or Rust. Those tend to push people to try to be clever and show off, often for "performance reasons". This is rarely a good idea, think twice.

I would have titled the "defer refactoring" section differently though. Probably "defer abstracting" would have fit the bill better.

A good explanation of why you likely don't want a centralised package manager for your ecosystem.

Bad actors will go to great length to try to compromise your supply chain.

Need a refresher on how to write a parser? This is a good one. Also gives a few ideas of Rust libraries you can use to make the task easier.

This is not an easy case, even with the support of PyO3. This short article gives a nice blueprint to share a reference between Rust and Python.

Nice bag of tricks for better Rust performance at low level. The compiler is indeed helping quite a bit here.

This is indeed a welcome improvement in my opinion. It's nice to get a glimpse of the process of adding such features in Rust.

Nice chapter to better understand Rust dyn traits (also called trait objects).

Due to the strict type system this kind of conversion is not necessarily a given. There are ways though, and you can even keep it performing well.

It's indeed a nice little pattern to use when the type system allows for exhaustiveness checks of destructure operations. Allows to gracefully handle extension of structs in the future.

Interesting talk. The tools presented can indeed go a long way helping people figure out what's wrong with a piece of code or learning some of the harder parts of a language.

Clearly the error handling landscape still evolves in Rust and that's a good thing. The current solutions are too fragmented at the moment.

No good tricks to optimize your code, but knowing the tooling knobs sometimes help.

Indeed, is it that the language itself has a steep learning curve? Or that the emphasis is on the wrong things in the public discourse? I like the emphasis on the Aliasing Xor Mutability, it looks like a good way to approach the language.

This is a nice summary of the Send and Sync traits semantic in Rust.

Interesting point, fairly logical but didn't sit to think it through before. Indeed, using arenas to get back features of manual memory management won't lead to the same security issues than outside of a memory safe language.

Very interesting pattern. The article is really in-depth and gets all the way to language lawyer level. It's not for everyone I guess.

Dealing with temporaries is always complicated it seems, whatever the language.