I was also surprised they picked "Programming Rust" over "The Rust Programming Language" book.

> This is one of the books which I will gladly buy once more when it is updated.

Agreed, Programming Rust is really nice and I read a dozen of Rust books already. I'll be buying 2nd edition as soon as it's available.

Just a friendly reminder the you can get the Programming Rust book for only $15 along with a bunch of other good books for 3 more days at the Humble Bundle Functional Programming Bundle. I've been working my way through it and learned a lot so far about Rust.

Seconded. I read Programming Rust and it was excellent. Too bad there is no second part. I didn't get too far in the Rust book though.

I completely agree and I did the same thing. I own dead tree variants of both and TRPL approach immensely helped grokking the language whereas the Programming Rust book feels more like a reference book for dives into concepts.

You’re not alone. I found the Rust book very hard going, whereas Programming Rust was just the right amount of rigor and interesting examples for me.

I think Steve Klabnik could clarify this, but the book at that link is in the process of being rewritten. I think it might be good to wait until it is. I personally found it slightly difficult to follow compared to other options like the soon to be published Programming Rust.

I read v1 of The Book and then Programming Rust, and I found the latter to be better suited to the way I absorb things.

Both are great and I still refer to The Book (and Programming Rust) from time to time.

I'd be really keen to pick up v2 of Programming Rust.

I've really enjoyed Programming Rust by Jason Orendorff and Jim Blandy as a good overview of Rust for an intermediate level programmer with experience in other languages.

Herlihy and Shavit's The Art of Multiprocessor Programming was fantastic for learning about parallel/concurrent algorithm and data structure design

I have been reading it as well. For my taste, it is a bit too verbose.

I like to see something along the lines of the K&R book or the GoPL book. I was hoping that "Programming Rust" is such a book, but I was disappointed. And (may be it is just me) I like to see exercises in Programming books.

Best part of Rust in 2017 for me is all the new books:
2nd edition of The Book,
Programming Rust,
Learning Rust,
Mastering Rust

Programming Rust by O'Reilly, haha.

Programming Rust is the exact book I am referring. I am facing issues getting my head around the concepts as I was brainwashed by Java, Python, Scala and JavaScript. But it gets easier.

Programming Rust by O'Reilly is in early release and I recommend it.

+1 Rust, but be warned: the learning curve is high.
I work with similar language to you and Rust not only sheds light on low level concerns and safety, but also has an excellent type system. Programming Rust by Blandy and Orendorff, the online Rust Book, and the Rust By Example website are all good resources.

Rust is a lot more verbose than a language like Elixir so it might feel like wading through mud for a while.

I'm also throwing out the suggestion of a Lisp. Homoiconic macros are interesting and difficult. I'm currently reading Let Over Lambda by Doug Hoyte and it's like there's a whole world of technique I had no idea existed.

From personal experience, invest in good (for you) resources to learn the language. I had two attempts, and it wasn't until I took "learning" seriously and purchased a book did Rust stick. My first attempt that has worked for all other languages, mostly by just reading docs and programming, was a massive headache.

That was years ago though, perhaps it's better now. All I know is after reading Programming Rust, I picked Rust up and it's been amazing. I love the language.

>the borrowing/ownership semantics of rust (at the time I looked at it) felt needlessly over complicated.

Taking a wild guess here, but it sounds like you maybe referring to issues addressed by Non-Lexical Lifetimes (NLL)?

Reference: https://github.com/rust-lang/rfcs/blob/master/text/2094-nll....

NLL are a part of Rust 2018 Edition.

Three complementary books are the best resources:

- The Official book: https://doc.rust-lang.org/book/

- The Rust By Example book : https://doc.rust-lang.org/rust-by-example/

- Programming Rust (O'Reilly) : https://www.amazon.com/Programming-Rust-Fast-Systems-Develop...

You can read Programming Rust online if you have Safari Books or their free trial, I started reading the book on my free trial and certainly loved it. I intend to buy this bundle to keep reading it. The book expects the reader to have previous programming knowledge, so it might seem a little bit too fast in the beginning, but it has plenty of explanations and code about the subjects being shown, if the book wasn't so expensive in my country, I would definitely get a real copy of it.

> I know everyone says how good Rust's documentation is but I tried learning Rust with The Rust Book and found it frustrating: too long and wordy on the easy bits and without useful insight on the hard bits. I ended up buying Programming Rust by Jim Blandy [0] on a recommendation from HN comments and found it must easier to learn from. I'm already familiar with several other languages, which that book assumes, so your milage may vary.

> [0] https://www.amazon.co.uk/Programming-Rust-Jim-Blandy/dp/1491....

Thanks for tip, the Rust Book is working well for me so far but it's good to know of other good options.

Agree completely. For a bit of my own story, a year+ ago I had the option to write a project in Rust and evaluated it vs Go. Long story short, I tried rust, and it was a massive headache and I failed. We used Go (as I had been for ~4 years).

Fast forward to ~2 months ago, a work project dictated tight control over memory which, while possible in Go, had me looking at alternatives. I decided to give Rust another try. This time it wasn't just an evaluation, it was needed to work so I bought and Rust book and spent some after hours time learning/etc.

This time, Rust has been an absolute joy. I have no understanding why last time was so painful, and this time it's been so amazing. Maybe it was the book[1]? Maybe it was just a 2nd round of learning based on my previous experience? Regardless, it's been great.

There's just so many mental overheads like what is concurrent safe, what is non-null, etc that are just great to not think about anymore. On top of that, the formatter and LSP are just great. It highlights in my text editor (Kakoune) what variable caused an error, where it gets moved incorrectly, etc. So much just works, it's great.

My only complaint these days is:

1. I find it odd that some things like slice reads can still panic by default. Yes, I can use `foo.get(1)` to avoid panics, but still - it's a bit odd to me.
2. I'm anxiously awaiting async/await. It's quite difficult to be patient.

[1]: Programming Rust: Fast, Safe Systems Development

I come from C. What got me started was the O'Reilly book, Programming Rust by Blandy & Orendorff. (It cultivates the your sense of snobbery too. Imagine code examples using lists of "murderous Renaissance artists".)

Off-topic, but I'll just ask, is the book Programming Rust: Fast, Safe Systems Development 1st Edition [1] still relevant / worth reading (given the book is based on an older, although stable? version of Rust)?
If it isn't, does anyone know maybe if a 2nd, updated edition can be expected?

[1] https://www.amazon.com/Programming-Rust-Fast-Systems-Develop...

I've read many articles explaining Rust async and I think the best one is the async chapter of Programming Rust (2nd edition). It's not too daunting for someone new to async concepts, and yet comprehensive enough for someone curious about how Rust async works (future, waker, pinning).

Amazon link: https://www.amazon.com/dp/1492052590

Direct link to the chapter (if you subscribe to O'Reilly/Safari): https://learning.oreilly.com/library/view/programming-rust-2...

I know everyone says how good Rust's documentation is but I tried learning Rust with The Rust Book and found it frustrating: too long and wordy on the easy bits and without useful insight on the hard bits. I ended up buying Programming Rust by Jim Blandy [0] on a recommendation from HN comments and found it must easier to learn from. I'm already familiar with several other languages, which that book assumes, so your milage may vary.

[0] https://www.amazon.co.uk/Programming-Rust-Jim-Blandy/dp/1491...

I'm learning rust myself this year, I have to say the book - The Rust Programming Language - is not very well written, in comparison, from what I've read, The C book and C++ book and Go book are way better, and unfortunately the other two books I found - Programming Rust and Rust in Action - are not updated yet, for the 2018 edition, to be clear.

Read the rust book and actually build something with it. There's a lot of stuff in Rust that you just never have to consider in Python so there's no easy way other than diving in. Actually, Programming Rust might be better, but it's not free.

https://doc.rust-lang.org/book/second-edition/

http://shop.oreilly.com/product/0636920040385.do

A pre-release copy of Programming Rust, by Jason Orendorff and Jim Blandy.

Programming Rust has 21 chapters and is 583 pages long. I’ve read it, and I’ve also read the online Rust Book (both several times). Most chapters are in the order of 20 to 30 pages long. Programming Rust is one of the best programming books I’ve ever read, and I’ve been coding professionally since 1997. If you want to get an A+ in Rust read Programming Rust a few times. You can see the entire Contents section of the book on Amazon. Below is a list of chapter titles from Programming Rust that get little to zero coverage in this Learning Rust website.

Ownership. References. Expressions. Error Handling. Enums & Patterns. Operator Overloading. Closures. Iterators. Collections. Strings & Text. Input & Output. Concurrency. Macros. Unsafe Code/FFI - the coolest part, they show you how to create a safe wrapper around libgit2.