Another book I found very helpful is Programming Rust [1], it expands on many concepts in the Rust book, the chapters on closures, iterators, collections, concurrency and async have very good explanations on how things work.
I highly recommend this book. I like "the book", but I did not find it was enough to write code in the real world. This book is longer, but more thorough.
Is it adequate to learn systems programming concepts? I already know the concepts of Rust, so I'd rather learn the former. It's fine if the book teaches both, though.
First: sadly, as common practice in the Rust books world, the book devotes 1/4th of the content to an utterly useless Rust guide. This is a marketing device (it's scammy for me, but it's arguable) to illude readers that they can read a book on learning Rust _and_ apply it in a certain context - but it's not possible to meaningfully learn Rust in 100 pages (not even in 400...). Those 100 pages would have been much better spent on-topic.
Rust language sections are also added to various chapters, which again, are redundant. Chapter 10 is entirely dedicated to multithreaded Rust programming, which is not systems programming.
Ultimately, it depends on what one exactly wants to learn and what they intend to do with it:
- if one wants to learn O/S programming, this is definitely not an O/S programming book; just the last two chapters are.
- if one wants to learn interfacing with system components (e.g. the network stack), especially with the intention of just reading without actually applying, this can be a fun book.
I personally don't think that the latter is systems programming, and I find the book misleading.
Author here, I hope that you have fun along your journey of learning Rust and systems programming. I recommend reading the free chapter to get a feel for Rust in Action.
It's intentionally different than most other text books. That means that each book in the Rust ecosystem complements the others. It's full of large worked examples from different domains. For example, you implement an NTP client, a database and a CPU emulator. It sacrifices idiomatic Rust for ease of learning. For example, it largely avoids higher-order programming to be accessible to as many people as possible.
Its role is primarily intended to teach you Rust, and to bring you up to speed with the jargon and concepts used in systems programming so that you can tackle dedicated material.
Let me know if you have any follow-up questions :)
I bought it when there was a kind of 2-for-1 deal with Rust in Motion a while back. I haven't spent too much time reading it though. From what I've browsed it seems competently written. It seems to cover the topics of typical interest in systems programming.
The other resources I would point you towards are Rust by Example:
Though the cookbook is kind of out-of-date. I'm actually in the process of updating / expanding it, but that effort is far from ready for presentation.
Please ignore all the gatekeeping marketing on that front page - it's very counterproductive and not at all accurate. IMHO all of this material should just be included in the standard Rust book, especially the sections about ownership and implementing Vec.
The Nomicon is an extremely useful resource because it "desugars" all the magic that is happening when you write Rust, so you are left with a competent understanding of what the compiler is doing on any piece of code you are looking at or writing.
Valuable reading for people wanting to build real systems in Rust, IMHO.
eh. no different than looking at a physical copy in book store and putting it back on the shelf or purchasing it. Delete it if you don't like it, buy it if you do. Morality != Legal system, although there is a little overlap but not a whole lot
I'm mostly a back-end engineer, but I've read the Rust Book[2] and I'd like to learn more about systems programming.
[1]: https://www.manning.com/books/rust-in-action
[2]: https://doc.rust-lang.org/book/