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.

This is definitely a useful idiom. A bit like the immediately invoked lambdas in C++ but less verbose. This is nice to control intermediate variables locality and mutability like this.

Definitely quite some nice resources in the Rust world for people interested by development for embedded systems.

There are indeed options for managing dependencies in more complex Rust codebases. It needs to be planned properly when doing the software architecture of your components though.

I admit I like CRDTs as well. They really are the foundation of cool use cases. Of course it raises questions related to security to broker properly the sessions between users. Still, it's nice to see them more and more used.

Very Rust focused, still it's an interesting debate. It gives a good overview of the different types of lock behaviors in case of failures. It's very much advocating for the poisoning approach which is indeed an interesting one (coming with its own tradeoffs of course).

Shows that you don't always need to put stuff in Box to get dynamic dispatch.

Another illustration of how to use a new type to declare intent for display of values.

A bit of a shameless plug toward the end. That said the explanations of why Cloudflare is banking on Rust so much or how the recent downtime could have been avoided are spot on.