A good example of how you can get bitten by cache coherency algorithms in the CPU.

Interesting selection of options to model data structure with some variability in Rust.

Of course, don't take everything at face value here. Still this gives good ideas on how to combine some design and architectural ideas together. The whole thing is not really Rust specific.

Or why this kind of question never have an absolute answer.

Due to how errors are handled in Rust, designing them is a real concern. Several approaches are presented here, using wrapper types is likely the better trade off.

Not strictly about Rust, still is shows how to approach the conversation about your dependencies. It also gives good ideas on how to try to reduce them.

Interesting post about the options for error handling in Rust. It highlights the tradeoffs to keep in mind when creating structured errors.

It's a very good idea to help C++ developers pickup Rust.

Interesting comparison between C++ and Rust for a given algorithm. The differences are mostly what you would expect, it's nice to confirm them.

Nice deep dive into a bug lurking inside a lock implementation.

Early days but it looks like we got two interesting type checkers coming up for Python. Definitely worth keeping an eye on them.

Indeed, bugs with async/await can be subtle in Rust.

Or why I'm still on the fence regarding async/await. It's rarely the panacea we pretend it to be.

Another trick in Rust to avoid unwrap() calls. The let-else option is indeed particularly elegant.

Apparently this needs pointing out but there's more than async/await out there. Sometimes what you want is a simple event loop. Here illustrated in the Rust ecosystem.

I find the title misleading. Still, this is a good exploration of how to treat unwrap() and expect() in Rust code.

Not a huge fan of the writing style. Still this gives a good idea of what you have to deal with when you're trying to build lock free data structures. Here it's illustrated with Rust, but it's not Rust specific.

There's clearly a tension between security and ease of pulling dependencies. In a way, it's "too easy" with cargo and you very quickly end up having to trust a staggering amount of third party code.

Nice docker recipe indeed for small and secure containers when you just want to ship a statically linked binary.

A nice example which shows the value proposition of Rust is not simply memory safety. Having a stricter type system and properly designed based types help a lot to catch mistakes early.