rust-learning VS nomicon

Personally I like this one. It has little curation, so I wouldn't recommend it to a beginner, but it's a really great collection of awesome resources which a more experienced person can recommend entries from.

This is the repository I was referring to: https://github.com/ctjhoa/rust-learning. It has been maintained for over 6 years.

rust-learning (A broader listing that includes links to sites like Are we game yet? among other things)

Finally, there's also the Little Book of Rust Books where you could look for tutorial materials or things like like Rust Design Patterns, Rust API Guidelines, and The Rust Performance Book. (See also rust-learning)

If you want to learn Rust, here are a list of resources https://github.com/ctjhoa/rust-learning

The best repo on github to learn RUST is https://github.com/ctjhoa/rust-learning. There is a collection of links to blog posts, articles, videos, and other resources for learning Rust. Another interesting repo https://github.com/cis198-2016s/homework.

it’s even written by the same person that wrote the Nomicon (the guide to the dark arts of unsafe)

If you want to dive deeper you can always have other options but now there are concrete cases, if you want to do low level thing https://doc.rust-lang.org/nomicon/ while if you want multi thread/concurrency stuff https://marabos.nl/atomics/ . There are many many books so you will have to point yourself to what you want

Nice video! Glad I could help out. This stuff is hard, and I'm still learning a lot about it myself even years later. The Rustonomicon is a great read if you haven't already.

Have you got a moment to read through the good book , after reading through this perhaps try the Rustonomicon.

However, this is a wide topic out of scope for a Reddit comment, so maybe just read the Rustonomicon. It explains everything about data handling in Rust.

The ownership model & borrow checker makes rust a bit of an awkward language in which to write complex data structures like trees and graphs. It can be done - since you can always use raw pointers & unsafe code when you absolutely need to to treat rust like C. But the language fights you, and the community can get a bit moralistic about this sort of thing. The rust nomicon is a fantastic resource for learning the limits of the borrow checker, and where and how to use unsafe code correctly. You will need unsafe less than you think you will, but sometimes you will have no choice.

That's a really good point that I feel like isn't talked about enough. Unsafe rust is a lot harder to write correctly than bog standard C, because you have to uphold the invariants to avoid undefined behavior (1). It's why there's a whole ebook about it (2).

That doesn't mean it's impossible to write correct unsafe code, it's just not as obvious as "trust me bro I know better than borrowck." You can't actually elide the invariants Rust upholds, you just have to take over from the compiler when it can't prove them.

(1) https://doc.rust-lang.org/reference/behavior-considered-unde...

(2) https://doc.rust-lang.org/nomicon/

If you are interested in the theoretical stuff that doesn't have much overlap with C++, give the Nomicon a try, or even Learn Rust the Dangerous Way.

There's also cbindgen for automating the generation of C headers once you've got your code in the right shape and you'll also want to read the Rustonomicon.