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.

Nice pattern to workaround limitations of the Rust trait system preventing blanket implementations.

There are indeed other options beyond the model with "one enum with all the errors".

Nice new tool to investigate code generated by macros in Rust. Indeed you can quickly add lots of lines to the compiled code without even realizing, in large code bases it's worth keeping in check.