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.

There are growing concerns regarding the Rust supply chain. It's still time to address them but it's became important to tackle this area.

More interesting design ideas in uv. Didn't know about the dashmap crate they're using here it looks like a nice one too.

Wondering what's on the mind of people working on an hyperscaler? This podcast and its transcript gives good insights.

Looks like an interesting framework for embedded projects.

Error handling is still not a properly solved problem in my opinion. At least the Rust community discusses the topic quite a bit. This is good inspiration for other ecosystems as well I think.

This is indeed interesting to see how the landscape evolved around error handling. There's clearly a tension between exceptions and the result types we've seen popping up everywhere now.

A bit too unapologetic regarding Rust API choices for my taste. Still, it gives a good idea on how error handling works in Rust.

You assumed you could deserialise in a zero copy fashion? Are you really sure about that? Think twice.

Unsurprisingly, this is mostly not related to the use of Rust. The design choices are what male uv so fast.

Interesting tool and I like the underlying approach. I wish we'd have good equivalent tools for other ecosystems.