Another illustration of how to use a new type to declare intent for display of values.

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

This is indeed a welcome improvement in my opinion. It's nice to get a glimpse of the process of adding such features in Rust.

It's indeed a nice little pattern to use when the type system allows for exhaustiveness checks of destructure operations. Allows to gracefully handle extension of structs in the future.

Nice pattern to workaround limitations of the Rust trait system preventing blanket implementations.

Yes, tests can follow patterns as well... and antipatterns too. It's good to name those antipatterns, let's avoid them shall we?

The Adaptive Model is a lesser known design pattern. Like any other pattern make sure you are in the right context to introduce it. Especially this one as it can get really verbose. This article shows a refactoring path for moving from imperative logic to adaptive model.

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.

Good explanation of an important design pattern as soon as you have remote calls.

There are clearly more to know. But this is a good list already.

One of my favorite of the traditional design patterns in object oriented languages. Now obviously when you get pattern matching in your language... you don't need the visitor pattern anymore.

A paper listing patterns to reduce latency as much as possible. There are lesser known tricks in there.

A nice pattern to separate decision from actions in complex algorithms.

Nice illustration on how pattern matching can simplify code and make it easier to write.

A nice pattern to know and master in my opinion. At least I turn to it on a regular basis.