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.

Interesting post which gives plenty of insights on how async Rust is designed and behaves.

Just a little dive in the Rust standard library. It gives a good idea on how they pile layers to ensure safety while providing a nice API on top.

Of course I agree with this. We should fight undue complexity at every step. This beast tends to creep up very quickly and we're all guilty of it at times. This is indeed particularly obvious in otherwise rich languages like C++ or Rust. Those tend to push people to try to be clever and show off, often for "performance reasons". This is rarely a good idea, think twice.

I would have titled the "defer refactoring" section differently though. Probably "defer abstracting" would have fit the bill better.

A good explanation of why you likely don't want a centralised package manager for your ecosystem.

Bad actors will go to great length to try to compromise your supply chain.

Need a refresher on how to write a parser? This is a good one. Also gives a few ideas of Rust libraries you can use to make the task easier.

This is not an easy case, even with the support of PyO3. This short article gives a nice blueprint to share a reference between Rust and Python.

Nice bag of tricks for better Rust performance at low level. The compiler is indeed helping quite a bit here.