This gives a good list of things to try when optimizing (Rust code or otherwise).

Good exploration on how and why async Rust was designed. As usual it's not purely for technical reasons, there's a human and community factor to it.

This is a big deal for the places where Rust could shine.

Another system where it becomes easier to make drivers in Rust.

Keep the downsides in mind. Rust has an ecological niche, but it's not that big.

Nice to see this effort keeps bearing fruits. This is a very needed engine to avoid a monoculture.

More details are surfacing regarding async and Rust... definitely not a match in heaven it seems.

Illustrated with Rust in this case, but definitely one of the big advantages of having type systems. Adding constraints (even runtime ones) to your types make it harder for bugs to hide.

Interesting to see what gets confirmed (slow compiler, nice compiler error messages, code quality) or debunked (steep learning curve, interoperability).

Interesting deep dive in Rust and C++23 string formatting features. This shows the differences quite well. It also does a good job at highlighting the pros and cons for each approach.

Interesting post, highlights why it's better when languages are designed in a more community fashion (make sure to read until the conclusion). At least in term of popularity it seems to help.

Indeed, the story of integrating C and C++ with Rust isn't a simple one right now. It might introduce larger attack surfaces. Some improvements are proposed in this paper.

Nice list of patterns leveraging the Python type hints for richer and safer interfaces.

This is currently a real zoo. I knew about a few of them but not that many. I guess it will slowly converge toward a few major options.

Really nice little tool, this is indeed surprising how little code is needed for something like this. Treesitter is definitely a huge help there.

Very nice milestone and interesting tech for sure. Congrats to them!

This is an interesting move. There are good reasons for it in this article. Also some I'm less inclined to take at face value but still, worth keeping in mind.

Nice walk through for a use of PyO3 to make some Python code much faster. Nice to see how useful py-spy turn out to be in such scenarii as well.

People tend to be fixated on the "unsafe" keyword and assuming not using it will make their code devoid of memory safety bugs. Well, it's a bit more subtle than this. It helps you know where such bugs can hide but it can't completely prevent them all the way down the stack.

Not earth shattering benchmark, kind of confirms what we can expect on the concurrency and REST side of things: Rust, Go > .NET > JVM