Rust in Action

Disclaimer: this post includes affiliate links; I may receive compensation if you purchase the book from the different links provided in this post.

I’m pretty much a learning-by-doing kind of guy. However, I tend to get back to documentation after a certain level. Last year, I started to learn the Rust programming language on my own. Then, I felt the need to read some theories.

I have known the “In Action” Manning series for a long time. When I saw Rust in Action, I thought it would be a step in this direction.


  • 12 chapters, $33.59
  • The book’s subtitle is “Systems programming concepts and techniques”. Unlike most subtitles, it does describe the book’s content: I’ll come back to it later.


Chapters are divided into two main sections: Rust language distinctives and Demystifying systems programming. Here’s a quick overview of each chapter:

  1. Introducing Rust. The title says it all. It’s worth mentioning that the author dedicates a section to downsides. For me, it’s essential as it shows intellectual honesty.
  2. Language foundations. The chapter starts to lay out the basics of Rust syntax. It also describes how to compile.
  3. Compound data types. The chapter describes structures and enumerations. The last section also includes how to generate documentation.
  4. Lifetime, ownership, and borrowing. The most important chapter in any Rust book!
  5. Data in depth. The chapter marks the start of the section about system programming. It describes how an operating system models data. Throughout the chapter, the author goes through the concepts via the use-case of building a virtual CPU.
  6. Memory. Stack, heap, pointers, and smart pointers
  7. File and storage: I stopped reading during this chapter.
  8. Networking
  9. Time and timekeeping
  10. Processes, threads and containers
  11. Kernel
  12. Signals, interrupts and exceptions

Pros and cons

Note that as I mentioned above, I stopped reading the book halfway through it. Hence, my view only reflects the parts I read.

The good sides of the book are:

  • The author is objective about the Rust language, mentioning its downsides. It’s pretty rare and deserves to be mentioned.

On the flip side:

  • The order in which themes are described doesn’t always make sense. For example, the author describes cargo in detail in the first chapter, whereas some basics of the Rust syntax come only much later. Likewise, he explains how to generate documentation in the second chapter.
  • Some themes are dispatched in different chapters without any reason I can fathom. The bulk of Rust’s documentation system is described in the second chapter, but then chapter 3 dedicates its last section to creating inline documentation.
  • There’s no use-case across different chapters. Every chapter brings its own, which you need to understand. Some chapters even have different use-cases for each section, requiring a lot of context switching.
  • Last but not least, the book tries to teach two things at once: Rust and system programming. The thing is, it’s not feasible, as it should be one or the other. If you’re already familiar with system programming, then the Rust part should be pretty straightforward; if not, as it’s my case, then it’s too much content.


As I mentioned, I started to learn Rust on my own. Hence, I was very eager to consolidate and complete my understanding by reading a book, such as Rust in Action. Perhaps, for this reason, I was expecting too much. But my opinion is that the book tries to teach too much at once. A whole book could focus on the system programming part only. In its current form, the book tries to cover too much ground.

Even if you are already familiar with system programming, the book is hard to read. The two primary reasons for that are a lack of a unified use case and suboptimal dispatching of themes across the different chapters.

In conclusion, if you’re already familiar with low-level programming and are trying to learn Rust, it might be the right book. If you’re not, it will take a lot of effort to go through all content.

Originally published at A Java Geek on April 10th, 2022




Dev Advocate for Apache APISIX. Former developer and architect. Still teaching, learning and blogging.

Love podcasts or audiobooks? Learn on the go with our new app.

Recommended from Medium

How to Build an API Wrapper in Google Apps Script

Journey To Becoming A Game Dev.

Introduction to Magic Methods in Python

How to Install Dotnet Core on Ubuntu

How to Install Dotnet Core on Ubuntu HostnExtra

Hacking JWT Tokens: Improper Signature Validation

Leetcode Q179. Largest Number (Q172)

Paytm payment gateway integration in Laravel


Porting Games to the Web with WebAssembly

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store
Nicolas Fränkel

Nicolas Fränkel

Dev Advocate for Apache APISIX. Former developer and architect. Still teaching, learning and blogging.

More from Medium

Event-Driven Programming with Rust and RabbitMQ using Crosstown Bus

Demystifying Error Handling in Rust

Rust Techniques For Compiler Engineers

Zero is a good default number of retries