I live in the U.S. and got my copy around Jan 4th via Amazon. So far, I’ve gotten to chapter 16. I’ll probably share a more complete review once I finish.
My literal first impressions of “Programming Rust” is that it’s physically thicker than I expected for a first edition. In terms of actual content, I’m really enjoying it right now. The book does a good job at comprehensively introducing each feature of the language. For instance, the chapter on Iterator walks through almost all of the adapters and shows examples of each one at work. Speaking of examples, this book has a lot of diagrams and pictures in it! Probably my favorite things about it that I couldn’t get out of TRPL are the pictures of data structures (roughly) laid out in memory. The book is very visual and detailed, as a result I’ve been enjoying finding out about details of the language that I probably should know, but just never ended up learning. Best example of this would be the Utility Trait chapter that goes through all the weird traits that seem to be implemented for everything, but don’t obviously belong to the api of a well known std module like
sync. Traits like
Deref, etc. It walks through them all and explains why they’re useful. I also found the chapter on closures pretty helpful as it gives a good walk-through of
I’m somewhere between a beginner and an intermediate with Rust and I found this book to be a good review of the language for someone looking to call themselves an Intermediate. Much of it was stuff I already learned via either programming Rust on my own, reading parts of TRPL, and reading Stack Overflow answers. But even then, it filled a lot of holes in my understanding. Much of Rust’s online documentation is designed non-linearly around hyperlinks in some way, shape, or form, making it easy to casually perused, but unlikely to provide 100% coverage in understanding. It’s easy to get distracted and miss something. Programming Rust reveled many details about the language I just never got around to learning that I probably should have learned sooner. Stuff like the From and Into trait. It really helps that I’m actively working on a project right now, because every detail that the book teaches me is not so much a pedantic summary of a language feature, but more of a “Did You Know” discussion of the language - and I found myself discovering a lot of odd things that had clear practical value to my code in the immediate future.
The book is also quite funny and breaks up the long expanses of exposition with humorous examples and asides. As someone who doesn’t find reading textbooks to be the most electrifying form of reading, I found the timbre and tone of the book to be quite pleasant. The book was a cozy companion to my curiosity during the snow storm that hit the east coast early January.
The one thing it’s missing that other books of its ilk tend to include are mini-projects and exercises. Programming Rust has some cool projects at the beginning of the book, most notably the Mandelbrot set rendering program, but past that the book sticks to short code examples, tables, and diagrams. I’m not complaining (I love the diagrams!), but I felt I should point this out in case you find the utility of exercises important and/or like understanding concepts by tinkering with the code of a self-contained program. This is not the O’Reilly edition of Rust by Example.
Overall, I like this book a lot so far and would definitely recommend it to any beginner whose already written a fair amount of Rust code and is looking for a comprehensive and concrete walk-through of the Rust programming language.