Rust in Action 1st Edition

The author does a great job explaining difficult Rust concepts to beginners in plain English via useful examples. I found it's highly beneficial to combine this book with "Programming Rust". These two books have different styles and are complementary. The publisher Manning also gives you free access to the e-book when you buy a paper book, it's bargain.

This is such an excellent book - well written, concise, crisp, meaningful examples, the quality of the code examples, the level of annotations in code listings and the diagrams, the inclusion of footnotes (especially in the 1st chapter), and summary notes at the end of each chapter.This is a great example of how to write a book.

Rust is complex.Tim does a great job incrementally exposing you to manageable chunks of related features.He tries to "meet you half way" if you're coming from another popular language.One pedantic issue is the pages are thin, so highlighters mark both sides. Zero regrets on this purchase though. Excellent resource.

I started learning Rust one year ago (almost to the day!). "Rust in Action" was the second book in my journey. I started with "the book" (aka, Klabnik and Nichols' excellent text, "The Rust Programming Language") and worked through it over two months. I purchased an early-access copy of "Rust in Action" (in December 2020) to get exposure to systems programming concepts and solidify my understanding of foundational concepts—basically Part 1 of McNamara's book. I spent the next four months working through his book.McNamara does a good job covering the basics of the language; while his presentation is similar to Klabnik and Nichol's, it has its own flavor which helped me better internalize those topics. For example, I found his discussion of trait objects and his "tiny role-playing game" example (section 8.3) both informative and fun.I enjoyed the systems programming chapters; many of those concepts were new to me upon first reading. I am currently re-reading the chapters on memory (chapter 6), kernel (chapter 11), and signals, interrupts, and exceptions (chapter 12) because I realize how much I didn't understand/appreciate when I first read them.I highly recommend re-coding (or cloning) and playing with McNamara's examples. Break things and then fix them; it's a good way to become friends with Rust's compiler.I've since moved on to the 2nd edition of "Programming Rust: Fast, Safe Systems Development" by Blandy, Orendorff and Tindall (which is another excellent text), and an early-access copy of Gjengset's forthcoming "Rust for Rustaceans: Idiomatic Programming for Experienced Developers". All the while I continue to use Rust at work and appreciate the language and the community.

This is a well written book -- there is enough here to get started comfortably in a Rust programming team. In about 450 pages the author expertly covers quite some ground, clearly explaining the programming concepts. Part I is on the language itself, and Part II is on systems programming; so you get two books in one. These two parts are written with care and integrity, Part II strengthening your skills to perform in an enterprise setting.Part I is among best Rust primers that I know of where rust-specific concepts such as ownership and borrow are carefully done. Systems Programming deals with OS/hardware level programming that is traditionally done in C/C++ languages. Now Rust, as a modern language, comes with everything it takes to shine in the Systems area. Its potential is really huge, we got to wait and see. Part II introduces Rust for systems programming. This is helpful and welcome since Rust's own official documentation is quite terse for beginners.

For context, I was moderately familiar with Rust when I picked this book up, but I don't consider myself a systems programmer. This book helped fill in the gaps that appeared when coming to Rust from a high-level language (in my case, Python). Even though I don't intend to do much low-level programming, the book has made me a better Rust programmer in general by familiarizing me with the lower-level details and helping me get a sense of the design choices of Rust language designers.McNamara manages to explain some pretty complex topics without coming across as dry or repetitive. I would recommend this book to people who have been through an introduction to Rust and want to see more, but it would also work as a first Rust book if you're up for a steep initial climb.