If it's too complicated to find a good name, use a comment indeed. As simple as that.

This is a difference which needs to be reminded. Using precise language obviously helps.

A bit old perhaps, but shows quite well the various options to pass a function around in C++.

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.

Wondering how to implement your own inference engine? Here is a nice simple blueprint to get started.

A nice followup which acts as a TL;DR for the previous piece which was fairly long indeed.

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

A long essay but contains a lot of interesting insights. There's definitely more to do design wise to produce software people can really bend to their needs.

An excellent piece which explains well why the current "debate" is rotten to the core. There's no good way to engage with those tools without reinforcing some biases. Once the hype cycle is over we have a chance at proper research on the impacts... unfortunately it's not happening now when it's badly needed.

Or how the workflows are badly designed and we're forcing ourselves to adapt to them.

This is an important piece of advice. You need to try things for yourself and fail to really learn. I'm not talking about failing in production of course. But trying to break something locally to see how it behaves, reading the errors, etc. is part of learning. This is how you will troubleshoot things faster the next time.

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.