Nice exploration which shows the many levers one can use to impact Rust compilation times. They all have their own tradeoffs of course, so don't use this just for the sake of reducing time.

I like this kind of oddities in languages. This is nice to see such a list for Rust at a single place.

This piece is a bit too much written as Rust zealotry for my taste. That being said, there's in my opinion an interesting core truth hidden in there: for now it seems to better foster "expert generalists" when investing in it. Now it might be just for now and might stop later... time will tell.

They both have their niches and it's welcome in my opinion. Now there are questions about the long term viability of Zig's ecosystem... the niche being smaller it's more at risk.

Nice move. It doesn't have to be about rewriting everything in Rust. Still there are some areas where we can benefit from the language and sandboxing.

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.