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.

Nice approach to stub standard types in Rust. The article is a bit confusing the different types of test doubles though.

Didn't know about that clippy feature. This is neat, allows to precisely target some of your project rules.

Wondering what happened at Cloudflare? Here is their postmortem, this is an interesting read.
Now for Rust developers... this is a good illustration of why you should stay clear from unwrap() in production code.

Nice alternative syntax to the good old regular expressions. Gives nice structure to it all. There's a Rust crate to try it out.

Early days but this looks like interesting tooling to inspect and debug programs using Rust channels.

Interesting analysis of the crates ecosystem. It shows quite well some of the challenges and weaknesses. Nothing to worry about yet about the ecosystem health overall. Still, you should probably be careful when picking dependencies.

A good list of code smells to pay attention to in Rust. Also provides patterns to avoid such smells.

This is unfortunately still a bit complicated for my taste. Ideally std::simd should be stabilized, but since it's not the case yet options have to be evaluated.

Indeed, the C++ syntax for closure captures is way superior to the Rust one. Interesting musing on a potential path forward for Rust.

Interesting notes about borrow checking in Rust. Looks like it does a good job exploring the whole space of issues one can encounter with potential solutions.

Indeed it feels like the Rust community has a cultural problem around abstractions. In a way it feels similar to the one Java developed years ago. This can bring lots of complexity and obfuscation you don't want in your project.

An illustration of why C++ can still be a relevant choice in new code. It all depends on the contraints you have for a given problem.