Friendly reminder that the answer is "no". You don't want to just rewrite everything, it's not just a syntactical translation, it's a long project and at best you tackle critical components.

Sounds obvious to me, but I guess it's worth repeating. It illustrates well the type of issues you still have to deal with in multi-threaded Rust.

This is an excellent exercise to understand a language and its ecosystem better. This time it is about Rust.

Indeed, skipping the centralized package manager might be better in the long run.

Interesting take on why CVEs are reported differently for C/C++ and Rust libraries. The responsibility for API misuse is treated differently because the abilities to express contracts is treated differently.

Wondering how those are implemented and the challenges behind them? This is a good exploration of the idea.

Some of the examples lean on macro trickery. Still this gives a good example of the flexibility you get with the trait system.

The writing isn't perfect, but it covers quite a few important topics in Rust. Seems to be a nice resource even though it's still work in progress.

Nice suggestions on how to structure larger Rust code bases. The proposed error handling is particularly neat and tidy. This is doable in other languages but tends to be more verbose.

As usual with this author it feels a bit too much like advertising toward the end. Still this is an important post, it shows quite well why you can't limit yourself at only the language used when picking a stack. You definitely need to look at the standard library and the wider ecosystem as well. Rust is no different there and has its own issues.

Straight from the uutils rewrite. This is interesting both for the class of bugs which made it (very system integration oriented, unsurprisingly) and the ones which didn't appear at all (anything to do with memory).

Indeed, the memory layout of your structs can matter. Be it Rust or not, but in the case of Rust the use of Option might give the wrong feel about the resulting layout.

Finer grained borrowing is still something people need in Rust. Here is a potential solution to get them today.

When possible it's nice to nest your error types, this allows better investigation when something fails.

This bears repeating of course. I still wish our industry would run less on hype. It's not specific to Rust of course.

Can crates.io make things easier to secure? I do think so. But this post is right that we shouldn't forget the social aspect of the whole supply chain security conversation.

Indeed, the current supply chain model of Rust could be better. While we wait for improvements (with no sign of them coming), there are ways to try to avoid some of the common pitfalls.

Good guidelines for Rust code indeed.

Interesting proposal for rust borrow checker. I wonder if it'll get any traction.

Good explanation of where WebAssembly is going and why the current initiatives are important to its success.