Nice in depth article on how to run particle simulations using WebGPU. This one has a very life like rendering.

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

If the funding dries up... we'll have another AI winter on our hands indeed.

Another trick in Rust to avoid unwrap() calls. The let-else option is indeed particularly elegant.

Or how the current neural networks obsession is poisoning scientific fields. There was already a reproducibility crisis going on and it looks like it's been getting worse. The incentives are clearly wrong and that shows.

You can't be in the backseat when using those tools. Otherwise you might feel productive by cranking out code but it can't do the essential tasks for you (most notably actual problem solving or architecture thinking). The quality would clearly suffer.

Another way to approach Architecture Decision Records. A different format to try to foster a more collaborative approach.

A quick summary of the different properties you want in tests. In practice you'll likely have to find a tradeoff among them.

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.

Friendly reminder that in C++ that case evolved quite a bit all the way to C++23. Please use the more recent constructs in new code. This definitely leads to better patterns.

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

Or how it's possible to expose an object-oriented like API for a data oriented framework without sacrificing on performances.

Don't throw estimates out of the window. Keep in mind that the more precise they are the more expensive they become.

This is indeed two sides of the same coin. A good reminder that you need to pick the right approach depending on the context.

Interesting point of view. I'm not sure I fully agree with the classification but it gives something to mull over. For sure the less reliable your estimates the more padding is needed to have some predictability.

Rituals are definitely important... if you understand why you're going though them. If you just "go through the moves" they're failing.

This explains quite well how TDD is made of several cycles of different length.

This is a funny setup. It's not very expensive either.

Seriously... Developers should be ashamed to produce such invasive tools.

I find the title misleading. Still, this is a good exploration of how to treat unwrap() and expect() in Rust code.