Programming Rust: Fast, Safe Systems Development 1st Edition, Kindle Edition

I've just begun reading this book. It's quite readable (for a serious programming language book), by a couple of people with a depth of history with Rust and with a long history in other serious systems programming projects.

Earlier today I went looking for my first "Rust book", as Rust is at the top of my list as the next computer language that I want to learn. I started back in the 1970's with FORTRAN on CDC servers, and then with C inside Bell Labs on PDP 8's and 11's. Kernighan and Ritchie's original 1978 "C Programming Language" is the oldest "classic" language book on my shelf, which, like this Rust book, I purchased shortly after it was published.

Hopefully I will remember to return to this review, once I have gotten further into it. But so far, it's looking like a potential "classic."

Update #1: I've gotten a quarter of the way into the book. It's most excellent so far, combining a rare mix of a readable, conversational style with a coherent organization and meticulous accuracy both in the detail and in the conceptual, by a couple of authors who know their stuff, both Rust and systems programming. Unless the authors are the 1 in a 1000 who write polished prose in the first draft, there's the mark of some dang good editing here too.

Update #2: This book (at least the Kindle version I'm reading) lacks a Table of Contents, which I miss. The book is quite well organized, by chapter and subchapter, so I'm not sure why there is no Table of Contents. Perhaps the hardcopy edition will have such, but the "location" rather than "page number" positioning of a Kindle book makes a Table of Contents more difficult?

Update #3: Oops - sorry - there is a table of contents in the Kindle version. It doesn't appear as part of the inline text such as after the title and copyright pages, before the Introduction. Rather it's a special Kindle accessible table of contents (look for the 3 horizontal bar menu pull down icon, near the upper left), which you can access from any "page" in the book.

Update #4: Unlike Kernighan and Ritchie's original 1978 "C Programming Language" book, and unlike David Beazley's essential Python Essential Reference, Blandy's Programming Rust book is not the primary and essential language reference. In particular, the Index of Blandy's book is only about 15 pages, and I often find that a particular keyword for which I am looking is not in Blandy's Index. Beazley's far more thorough index is about 77 pages, for a similar sized book, of around 600 pages each. This reflects our changing times ... the world is online now, or at least Rust is. For example, over the last day, I was frustrated by my limited newbie understanding of the various string types in Rust (a rich and carefully thought out area of Rust), until I realized that searching in the online Rust documentation, doc.rust-lang.org for the language, library and tools, and in particular, for my particular questions of the moment, doc.rust-lang.org/std for Rust's standard library, was a much more rewarding way to learn what I needed to know next. (Yes, a 200 page book in 1978 could be a far more complete reference than a 600 page book today; the Rust of today is a far larger language than C was back in 1978.)

O'Reilly has a reputation for putting out substantially higher-quality books than most other publishers in this genre, and this book is a shining example. The text is comprehensive without being exhaustive. The examples are well-designed, and the concepts they embody carefully explained. There's just enough humor to make an engaging read cover-to-cover, while maintaining a high level of rigor and professionalism.

It's important to note that this is *not* a book for the novice programmer. It's a book for someone who knows one or more *other* languages well, and wants to start using Rust to build applications. Since Rust is designed for systems programmers, many of the comparisons are to other systems languages such as C, C++, and Java.

Compared to languages like Go or Python, Rust can be a bit adversarial for the beginner -- what experienced rusaceans refer to as "fighting with the type checker". Most of the reference material available online either assumes familiarity with Rust's checks, or explains it using formal rules. Neither approach is particularly helpful when you're fighting. Jim and Jason explain type and borrow checking from a practical perspective, highlighting a few common design patterns and how they are implemented in Rust (or why they are difficult to implement in rust).

I've been hacking away in Rust for a year or so now, writing toys and fiddling with Rust features, but only having finished this book do I feel like I could successfully design and build a large application in Rust.

This book gives the reader a broad overview of Rust’s concepts and has plenty of good code examples. This is not for beginners; you need significant experience in programming in order to understand the book, and preferably some C/C++ experience. But for an experienced, professional programmer interested in Rust, this is probably the best place to start.

This is a must read for anyone intersted in Rust. The code examples are clear without being silly. The writing is deep without being overly technical.

The book does assume basic knowledge of C/C++ programming and system programming, or at least this will help you get the most out of it.

The book is also insightful, answering all those "what if" questions you'll have as you read sections. Finally, the authors are clearly experts, giving tips, and notes about best practices, and insight into Rust that can only come from experience.

I have read the Rust Book before this one. But this book has added a whole new dimensiom of knowledge I don't know I was missing.