I don't agree with the previous poster. There's nothing wrong with diving in and figuring things out as you go, especially if that's a way that you commonly like to learn. Everyone has different learning styles, and Rust can fit all those styles.

The main thing to understand is you shouldn't let compilation errors discourage you. You will get a lot of compilation errors. And I mean A LOT. That's okay, it's normal, and it doesn't mean you're dumb or that Rust is an excessively difficult language. It generally just means that there's some new piece of the language for you to learn before you can take your next step.

When you run into compilation errors, just read the error message carefully and see if you can understand what the problem is. Often the error itself will tell you how to fix it, but you should take the opportunity to understand why the fix is necessary. In every case there's a reason that the language is putting limitations on what you're doing. It's to protect you from bad habits that other languages used to let you get away with. So understand what's bad about what you were doing and you'll rapidly grow as a developer.

If you can't figure out what's wrong from the compilation error alone, that's when it makes sense to turn to the book. The error messages will generally include a reference code which you can use to get more details on the nature of the error. Googling that will lead you to online discussions and maybe entries in the Rust book. Otherwise there isn't a real need to read through the book from front to back unless that's a way you like to learn.

If you like hands on learning, check out rustlings. It's an interactive tutorial.

Rust async has quite a lot of footguns that other async runtimes don't have. There are some listed here:

• https://www.qovery.com/blog/common-mistakes-with-rust-async/
• https://google.github.io/comprehensive-rust/concurrency/async-pitfalls.html
• https://bitbashing.io/async-rust.html
• https://carllerche.com/2021/06/17/six-ways-to-make-async-rust-easier/

Honestly if you're using an async Rust web framework (which they pretty much all are) it may be the path of least resistance to still use async. But in general I would strongly prefer scoped threads, channels, rayon etc.

many simultaneous requests

Unlikely to be so many that threads would be an issue.

@Ephera ah, the fediverse, what can't it make slightly broken? 🤣

Re: programming dot dev, that makes more sense - I didn't look around much but as a reddit-a-like it surely has links to "nearby" content hanging out around the main body of the page, and whatever logic in Mastodon (or my client?) that seeks an image to embed must've reached a bit far.