This looks like a really fun workshop. Been wanting to run one for a long time now. Somehow I never had the chance.

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.

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.

Nice illustration on how you can hunt down complexity in your codebases. It is obviously a slow process but comes with nice benefits.

A good reminder that it is sometimes better to use lookup tables.

Interesting comparison between C++ and Rust for a given algorithm. The differences are mostly what you would expect, it's nice to confirm 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.

Nice trick for numbers formatting as strings in Python.

A bit dated perhaps, and yet most of the lessons in here are still valid. If performance and parallelism matter, you better keep an eye on how the cache is used.

An honest attempt at "vibe coding"... but once again the conclusion is "when it grows to non-trivial size, I'm glad my experience allowed me to finish the thing myself".

For studying it makes sense. But don't shun other's work away only because of trust or ego issues.

Good reminder that refactoring isn't necessarily the end of a cycle. It can also be before you add a feature.

This is indeed an excellent way to understand all the roles and the work behind creating a game.

Nice approach, especially useful if you need to split work to distribute it to threads.

Somehow not surprising... There's an area where it works OK. That said, I think we don't have the right UX to exploit it safely and productively. The right practices still need to be found. This isn't helped by all the hype and crazy announcements.

There are options indeed. Some of them can be maybe surprising. It of course depends the type of game you're making.

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.