Learning Rust in 2020

That is, the advice "the best way to learn Rust is to read the book" came from when the book was a different one; it's still repeated (perhaps by people who learned from the old book), but it might no longer be as valid.

Just for fun, I've been re-reading the book (that is: reading the new book), and it's much more tiring than I remember the old book being (but I've learned a new trick or two, things that didn't exist back in the Rust 1.0 days when I first learned through reading the book).

I think the hard part of just reading the book is that unless you have some problem you’re trying to solve, it’s hard to get motivated to read it.

It’d be nice if there was a book that’s a bit less dry —- something like Learn You A Haskell or Why’s poignant guide to Ruby.

This weekend I read most of the Rust book without much effort and found it really helpful for getting up to speed with the language, especially the more novel bits around safety. It took me to the point where I was able to explore and evaluate the bits of the language I needed with only library docs. I know that the remaining chapters are there for when I am ready for them.

My experience with the Rust book as made me more likely to consider starting with a book when approaching programming languages in the future.

Reading other comments, I recognize that I was fortunate to have a project in mind that motivated my reading of the book and just happened to be an excellent fit for Rust.

Well done!

Yes, is may not really fit in the book but then there should be a official place for this. Preferably with different OSes and IDEs covered.

I started off reading your book, and I found it really helpful, even though I didn't make it all the way through. I feel like there are a lot of resources cropping up that are good supplemental material (the "half hour to learn Rust" blog post linked in this document being one of those) which can quickly get people up to speed, but the details in the book are still valuable.

Reading through (most of) the book was really helpful when I went to Exercism (another fine resource recommended by the post linked here), and I still use it as a reference when I am fuzzy on a concept.

Thanks for writing it!

[1]: https://doc.rust-lang.org/rust-by-example/

https://github.com/mre/idiomatic-rust https://speakerdeck.com/mre/idiomatic-rust-writing-concise-a... < fun basic idiom examples (don't necessarily take the use of the failure crate as idiomatic, but the rest of the methodology seems to be)

As far as loops vs maps, I've found that your use case typically guides this. I think this is the same with other languages like Python. You aren't going to want to write a ton of complex logic in deeply nested maps and filters. But if you just need to do something more simple it might make more sense to do it in a map one-liner.

Edit: The presentation linked to in the other reply appears to confirm this process of starting with dirty compiling code and then refactoring out the possible failure modes. It covers a lot more things like using match and handling errors from other libraries.

Your feedback as a beginner is very valuable! If you have some structured feedback for Rustlings please consider opening an issue on the repo. Also, the official Rust Discord Server is very beginner-friendly and has a #beginners channel, if you're struggling with anything don't be afraid to join and ask your question. The invite for the server is here https://discord.com/invite/rust-lang

Learning the hard concepts in Rust is the best part, but The Book isn't going to teach you those. The Book, by design, is a very broad but shallow overview of the entire language. It'll never teach you, for example, why you can't write a self-referential struct in Rust. That's a lesson every Rustacean has to learn the hard way: by programming in Rust. And that's what I hope to encourage more Rust beginners to do: learn the hard lessons by actively programming in Rust.