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.

Looks like an interesting ORM which brings advantages of the Django one without all the bagage. It's still young, let's see how it evolves.

Interesting look at Zig's comptime feature. It's not a purely Zig post though, does a good job of explaining parametricity and the implications of loosing it.

Looks like an interesting approach to lift some of the limitations around the Rust trait system. The learning curve doesn't look too great though, clearly requires effort to get into.

Yes, Rust like C++ comes with zero cost abstractions. Still they can get in the way of some compiler optimisations. This is an interesting case preventing vectorisation.

Short explanation of why you want to make invalid state impossible to represent. This leads to nice properties in your code, the price to pay is introducing more types to encode the invariants of course.

Looking at several languages and their reflection features. What's coming with C++26 is really something of another class than anything else. I just have concerned about its readability though.

This is indeed an important cultural trait in the Rust community. This can bring challenge when integrating Rust code into a context with more ambiguity.