What do you think?
Rate this book
Rust in Action
Rust in Action introduces the Rust programming language by exploring numerous systems programming concepts and techniques.You'll be learning Rust by delving into how computers work under the hood. You'll find yourself playing with persistent storage, memory, networking and even tinkering with CPU instructions. The book takes you through using Rust to extend other applications and teaches you tricks to write blindingly fast code. You'll also discover parallel and concurrent programming. Filled to the brim with real-life use-cases and scenarios, you'll go beyond the Rust syntax and see what Rust has to offer in real-world use cases.
Unknown Binding
125 people are currently reading
378 people want to read
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 30 of 31 reviews
Read
February 6, 2022I wanted to love this book, but it didn't work out. That doesn't mean it's bad - I just prefer slightly different kind of tech books.
OK, so what's the issue?
Rust's features are presented very practically, while the author tries to build something (each chapter is a separate "project"); that's generally a great idea, but: Rust is a relatively complex language, so presenting all the richness of the language this way felt a bit chaotic AND "projects" are close to system programming, which means that they are built on low-level abstractions, which makes them actually harder to grok through (in highly abstract scenarios you can skip whatever you want, in lower-level scenario you need a certain level of completeness).
Any other comments? Sure, here's one more: the author put a lot of effort in the book - it is very clearly visible. E.g. there are some creative attempts of visual depiction. TBH not all of them are truly helpful :) but the further (in the book), the better.
In the end: no star rating. I guess this book and myself weren't compatible :) Fortunately I didn't struggled that much, maybe because I wasn't learning from scratch, but reminding the practical aspect of the language I already knew.
OK, so what's the issue?
Rust's features are presented very practically, while the author tries to build something (each chapter is a separate "project"); that's generally a great idea, but: Rust is a relatively complex language, so presenting all the richness of the language this way felt a bit chaotic AND "projects" are close to system programming, which means that they are built on low-level abstractions, which makes them actually harder to grok through (in highly abstract scenarios you can skip whatever you want, in lower-level scenario you need a certain level of completeness).
Any other comments? Sure, here's one more: the author put a lot of effort in the book - it is very clearly visible. E.g. there are some creative attempts of visual depiction. TBH not all of them are truly helpful :) but the further (in the book), the better.
In the end: no star rating. I guess this book and myself weren't compatible :) Fortunately I didn't struggled that much, maybe because I wasn't learning from scratch, but reminding the practical aspect of the language I already knew.
August 12, 2021
It's difficult to review one's own book with any sort of objectivity. But, as I set out to write a book that I would have wanted to own when I was starting with Rust, I'm going to try my best at reviewing it anyway.
If I were buying Rust in Action for past myself, I would have been happy. It's easy to get the syntax of Rust online, but what I really wanted was projects to work on. I wanted the chance to be able to expand my own knowledge by making things. Just as importantly though, I wanted to be able to feel like an equal within the Rust community. As someone who had primarily programmed in Python, I did know know what the terms stack, heap, memory allocation, reference, dereference, monomorphization, or many others actually meant. Nor did I know where to find them.
I'm tremendously proud of the book that's been produced. It gives you a lot of the context that the Rust community expects you to know. Its examples it reward curiosity. It aims to empower everyone who wishes to write safe, efficient software.
If I were buying Rust in Action for past myself, I would have been happy. It's easy to get the syntax of Rust online, but what I really wanted was projects to work on. I wanted the chance to be able to expand my own knowledge by making things. Just as importantly though, I wanted to be able to feel like an equal within the Rust community. As someone who had primarily programmed in Python, I did know know what the terms stack, heap, memory allocation, reference, dereference, monomorphization, or many others actually meant. Nor did I know where to find them.
I'm tremendously proud of the book that's been produced. It gives you a lot of the context that the Rust community expects you to know. Its examples it reward curiosity. It aims to empower everyone who wishes to write safe, efficient software.
May 12, 2020
(The version of this book I got is not the final version, it's part of Manning Early Access Program, which allows people to read and participate in "constructing" a book. A lot of things may change in the final version, so be aware of this.)
I have to say, I don't buy the "introduces the Rust programming language" part of the description. A few points seem related to people that already have some knowledge about the language, and jumping straight to some non-trivial problem appears to skip a few "introduction" points, in my opinion.
One have to ask what "in Action" means. Sure, you'll write your one RFC 754 for dealing with floating points, so you can understand why some floating values get to 6.000000000001, and while you won't ever write your own floating point processor, you have to ask yourself: What is being explained about Rust here? Sometimes, the problems feel more like "I want to solve this" than "I want to explain this feature of the language", while it should be the other way around.
Another confusing point: The output of a program appears before its code. While not that weird, you end up with some sections showing the output, explaining a bit and then, way later, you get the code what actually produces that output. I remember reading a bit about the output and some discussion about it and I got really confused about what was producing that output.
The Rust part seems a bit out-of-date, too. There are some extern crate, which is optional at this point. Updating the code to reflect the latest version of the language (the syntax, that is) would be better.
On the other hand, I have to give the author the props for managing to explain things really well. Why you should use something, how can you apply different things to the same data and so on. That's the book greatest strength.
So, is it a bad book? Not at all. It has some quirks, but overall is well explained and, if you keep an eye on the language from outside, it answers a lot of stuff that you won't figure out anywhere else.
I have to say, I don't buy the "introduces the Rust programming language" part of the description. A few points seem related to people that already have some knowledge about the language, and jumping straight to some non-trivial problem appears to skip a few "introduction" points, in my opinion.
One have to ask what "in Action" means. Sure, you'll write your one RFC 754 for dealing with floating points, so you can understand why some floating values get to 6.000000000001, and while you won't ever write your own floating point processor, you have to ask yourself: What is being explained about Rust here? Sometimes, the problems feel more like "I want to solve this" than "I want to explain this feature of the language", while it should be the other way around.
Another confusing point: The output of a program appears before its code. While not that weird, you end up with some sections showing the output, explaining a bit and then, way later, you get the code what actually produces that output. I remember reading a bit about the output and some discussion about it and I got really confused about what was producing that output.
The Rust part seems a bit out-of-date, too. There are some extern crate, which is optional at this point. Updating the code to reflect the latest version of the language (the syntax, that is) would be better.
On the other hand, I have to give the author the props for managing to explain things really well. Why you should use something, how can you apply different things to the same data and so on. That's the book greatest strength.
So, is it a bad book? Not at all. It has some quirks, but overall is well explained and, if you keep an eye on the language from outside, it answers a lot of stuff that you won't figure out anywhere else.
July 26, 2021
This book is a great introduction to both Rust and several system programming core concepts that are explained in such a clear, concise and fun way. I really really enjoyed it.
Only a couple of negative points:
- I would have liked more contents in the chapter about objects lifetime. Explicit lifetime declaration is just not covered while the chapter only explains the basics of borrow checking.
- The kindle version of this book is unreadable, at least on a 7 inches tablet screen, due to very broken code formatting.
Only a couple of negative points:
- I would have liked more contents in the chapter about objects lifetime. Explicit lifetime declaration is just not covered while the chapter only explains the basics of borrow checking.
- The kindle version of this book is unreadable, at least on a 7 inches tablet screen, due to very broken code formatting.
January 16, 2022
Honestly, this book is a huge disappointment. I have read a few of Manning's publications. Some of them were quite good, some were excellent. I bought this one with confidence and high expectations that it'll be a nice read and I'd finally be able to jump onto the Rust hype train.
The more I read the more disconnection I felt. Somehow the book introduces concepts in a way that is impossible to understand. It shows you some new syntax and doesn't really explain what it is. While reading I wasn't sure if the book expects me to already know some Rust topics or am I just dumb.
Fortunately, I have quite quickly realized that there is a free book on the Rust's website - https://doc.rust-lang.org/book/. To anyone thinking about getting Rst in Action for a beginner - don't. Just read the wonderful book at Rust's site. Honestly, that book is what I expected to find in Rust in Action.
The book wasn't cheap and I actually feel a bit cheated and I will surely be more cautious when buying some next Manning book.
Just to add, the book has quite a few mistakes in it, both in code and the text itself.
The more I read the more disconnection I felt. Somehow the book introduces concepts in a way that is impossible to understand. It shows you some new syntax and doesn't really explain what it is. While reading I wasn't sure if the book expects me to already know some Rust topics or am I just dumb.
Fortunately, I have quite quickly realized that there is a free book on the Rust's website - https://doc.rust-lang.org/book/. To anyone thinking about getting Rst in Action for a beginner - don't. Just read the wonderful book at Rust's site. Honestly, that book is what I expected to find in Rust in Action.
The book wasn't cheap and I actually feel a bit cheated and I will surely be more cautious when buying some next Manning book.
Just to add, the book has quite a few mistakes in it, both in code and the text itself.
December 17, 2021
Trying to introduce too many things, and somehow it doesn't introduce system programming nor Rust too successfully.
March 1, 2024
Rust in action teaches the Rust programming language using projects like a Mandelbrot console renderer, CPU emulator and so on. I personally prefer to learn a language and it's concepts using simple terminology and code that is made for teaching. The toy projects may seem cool but in the end I just want to learn Rust, I don't care about floating point numbers and how to write a CPU emulator, once I learn Rust I'll study by myself how to write the emulator for example.
Edit: I initially rated the book 2 stars but then it became unreadable. I really wanted to learn more about Rust not random stuff.
Edit: I initially rated the book 2 stars but then it became unreadable. I really wanted to learn more about Rust not random stuff.
April 9, 2024
This is a very ambitious book, because the author uses relatively big projects to teach both Rust and systems programming. Unfortunately, the consequence is that a lot of concepts or language features are not explained very well, often too superficially. Some language features are casually introduced when used in a code example, without giving any proper explanation at all. This wasn't a problem for me, because I used the book to refresh my knowledge on Rust, so I was already mostly familiar with those concepts. However, if you are relatively new to Rust and want to gain a deeper understanding of it, this may not be the right book for you.
October 12, 2022
Serviceable content for intermediate Rust, but nothing inspiring.
May 22, 2021
This book provides excellent coverage of both the Rust language itself, and systems programming.
What really makes this book stand out is that it teaches systems programming using Rust. Pretty much every other resource out there geared towards people interested in doing systems programming in Rust assumes the reader has already learned a lot on the subject of systems programming using C or C++.
If Rust really wants to compete in the systems programming space, it needs more resources like this book.
What really makes this book stand out is that it teaches systems programming using Rust. Pretty much every other resource out there geared towards people interested in doing systems programming in Rust assumes the reader has already learned a lot on the subject of systems programming using C or C++.
If Rust really wants to compete in the systems programming space, it needs more resources like this book.
March 2, 2021
It's a fun book that invites you to try out rust-lang in different contexts. It keeps things on a lower-level side of things (networking, storage, hardware emulation) and gives you a taste of how easy and convenient rust is even in complex environments. If you're coming from a more high-level software development background this book is a treat.
I wouldn't recommend this book to learn rust or as first thing to read on rust. The first part does introduce the language, but it should be used more as a refresher, from my perspective. I can recommend it as a companion to the rust-book, to see the practical side of things.
Note: I had a grumpy negative review of an early edition (MEAP v10). That's not applicable to the current version and doesn't do justice. So I removed it
I wouldn't recommend this book to learn rust or as first thing to read on rust. The first part does introduce the language, but it should be used more as a refresher, from my perspective. I can recommend it as a companion to the rust-book, to see the practical side of things.
Note: I had a grumpy negative review of an early edition (MEAP v10). That's not applicable to the current version and doesn't do justice. So I removed it
April 27, 2023
Coming from an exclusively python background, this was my first foray into systems programming of any kind (although I was reading this concurrently with The Rust Programming Language, the latter is focused entirely on Rust the language itself).
There's a ton of technical knowledge in here and I learned a lot, but I think it could have been more focused, ordered and presented better.
By "it could have been more focused", I mean that the text isn't very effective unless you already know Rust to a decent degree (I was helped immensely by working my way through The Rust Book at the same time while also having someone fairly experienced with the language as a reading partner), and so, part 1 of the book, which tries to give you a crash course of Rust while also introducing you to some systems programming concepts, didn't succeed very well at either.
I also think that the way things were presented (within chapters) were ordered in an unnecessarily haphazard way. You would semi-frequently be presented with something alien in-use without much (or any) groundwork, and then have a not always adequate explanation a few pages down line (seemingly out of nowhere again). This resulted in what seemed like completely avoidable friction.
That being said, there's great insight in here (and a lot of interesting teaching aids; I loved the types of Pointers card game concept a lot) and I'm glad I decided to "jump off the deep end" with it. I look forward to going through it again when a 2nd edition comes, and after I have some more Rust under my belt.
Things I think could greatly improve the reading experience of a second/revised edition:
- More time spent explaining the motivations behind each project and why Rust is the tool for it
- Introducing never-before-seen things before implementing them
- Just a bit more time spent exploring everything in general, for more depth; this book yearns to be ~200 pages longer in my opinion.
There's a ton of technical knowledge in here and I learned a lot, but I think it could have been more focused, ordered and presented better.
By "it could have been more focused", I mean that the text isn't very effective unless you already know Rust to a decent degree (I was helped immensely by working my way through The Rust Book at the same time while also having someone fairly experienced with the language as a reading partner), and so, part 1 of the book, which tries to give you a crash course of Rust while also introducing you to some systems programming concepts, didn't succeed very well at either.
I also think that the way things were presented (within chapters) were ordered in an unnecessarily haphazard way. You would semi-frequently be presented with something alien in-use without much (or any) groundwork, and then have a not always adequate explanation a few pages down line (seemingly out of nowhere again). This resulted in what seemed like completely avoidable friction.
That being said, there's great insight in here (and a lot of interesting teaching aids; I loved the types of Pointers card game concept a lot) and I'm glad I decided to "jump off the deep end" with it. I look forward to going through it again when a 2nd edition comes, and after I have some more Rust under my belt.
Things I think could greatly improve the reading experience of a second/revised edition:
- More time spent explaining the motivations behind each project and why Rust is the tool for it
- Introducing never-before-seen things before implementing them
- Just a bit more time spent exploring everything in general, for more depth; this book yearns to be ~200 pages longer in my opinion.
August 2, 2022
I enjoyed parts of the is book, and I really wanted to love the whole of it. I really love the meandering rabbit-hole filled discussion of technical topics, and I don’t have a systems programming background so I was excited to learn more than just Rust here.
Unfortunately, I feel like some of the chapters and their projects landed much better than others. Building a chip8 emulator was really strong and the topics covered felt like the projects really nailed home some low level systems topics. But others like the clocks and timing chapter missed for me, and I’m not sure I understand NTP or time-keeping or any better than I did to start. I think chapters like the latter teach you to work with a specific framework or library implementation, and so the details talked about and hinted at but never shown actually take away from learning the core Rust features of the chapter (and those features would benefit from a more direct discussion as a result)
There are a handful of creative diagrams, illustrations, and figures and like the other content these help sometimes and end up a nonsensical distraction other times.
I’d have trouble recommending this whole book, but I’d definitely encourage folks to read bits and pieces that interest them alongside deeper discussion of Rust topics elsewhere.
Unfortunately, I feel like some of the chapters and their projects landed much better than others. Building a chip8 emulator was really strong and the topics covered felt like the projects really nailed home some low level systems topics. But others like the clocks and timing chapter missed for me, and I’m not sure I understand NTP or time-keeping or any better than I did to start. I think chapters like the latter teach you to work with a specific framework or library implementation, and so the details talked about and hinted at but never shown actually take away from learning the core Rust features of the chapter (and those features would benefit from a more direct discussion as a result)
There are a handful of creative diagrams, illustrations, and figures and like the other content these help sometimes and end up a nonsensical distraction other times.
I’d have trouble recommending this whole book, but I’d definitely encourage folks to read bits and pieces that interest them alongside deeper discussion of Rust topics elsewhere.
June 3, 2022
Many essential concepts are not covered in-depth, plus lots of irrelevant info that is not essential to Rust fill paragraph after paragraph.
The formatting for code examples is sucks. It does not use the whole width of the pages and contains descriptions inside boxes in the middle of code like child books. This makes reading code examples difficult.
The official Rust book that you can read freely online is ten times better than this book:
https://doc.rust-lang.org/book/
If you want a printed copy
The Rust Programming Language
For the best non-free Rust book, look at
Programming Rust: Fast, Safe Systems Development
The formatting for code examples is sucks. It does not use the whole width of the pages and contains descriptions inside boxes in the middle of code like child books. This makes reading code examples difficult.
The official Rust book that you can read freely online is ten times better than this book:
https://doc.rust-lang.org/book/
If you want a printed copy
The Rust Programming Language
For the best non-free Rust book, look at
Programming Rust: Fast, Safe Systems Development
April 4, 2023
I really wish I could say it's a great book. The idea of teaching Rust with practical systems programming examples is very cool. It's also really ambitious in how much ground it tries to cover. Unfortunately it lacks on editing, proofreading and effort to realize its ideas.
The source code has many bugs and lacks a scrupulous pre-print review. With the sources being available on GitHub (but not under an open source license) that should give an opportunity to actually refine it but there are very few updates past the book coming out and no community contributions are accepted "because copyrights". This is a pity because the whole book is built around those practical projects.
It still has a potential become a great book in a new edition.
P.S. Repeating the instructions on how to checkout and build the code for every single example, and also listing repeating multiple times, was very annoying.
The source code has many bugs and lacks a scrupulous pre-print review. With the sources being available on GitHub (but not under an open source license) that should give an opportunity to actually refine it but there are very few updates past the book coming out and no community contributions are accepted "because copyrights". This is a pity because the whole book is built around those practical projects.
It still has a potential become a great book in a new edition.
P.S. Repeating the instructions on how to checkout and build the code for every single example, and also listing repeating multiple times, was very annoying.
February 6, 2022
To be honest, I had higher expectations from this book. This book neither teach you Rust nor System Programming, does not matter if you already have experience with it or completely new and System Programming concepts are very shallow. There is lot of unnecessary code snippets and extra theory, it seems like the sole purpose of that is to increase the length of the book but it does not add much. In the beginning author states that this books is targeted to the people who already have exposure to Rust, but then write the steps as if he is writing for beginners.
If you had read *The Rust Programming language* I bet you already know more Rust than this book teach you.
But this books really introduce you how to write a CPU emulator and OS but that's not a big deal the same thing you can learn by reading 1 or 2 blogs. Does not justify reading a book for that much details.
If you had read *The Rust Programming language* I bet you already know more Rust than this book teach you.
But this books really introduce you how to write a CPU emulator and OS but that's not a big deal the same thing you can learn by reading 1 or 2 blogs. Does not justify reading a book for that much details.
July 3, 2023
Great followup to the Rust Book with some practical code examples and more in-depth coverage of important concepts like how Rust manages memory and ownership, along with systems programming concepts that are useful subjects for all developers to have at least a fundamental understanding of.
Some of the code examples can seem a bit tough to follow as the ordering isn't always intuitive. I'm on an Apple Silicon device as well, so a couple didn't work or required a workaround from the Github Issues for the source code. That's the main reason this is a 4 for me. Otherwise, it was a really nice read, and I feel more confident that I did previously.
Some of the code examples can seem a bit tough to follow as the ordering isn't always intuitive. I'm on an Apple Silicon device as well, so a couple didn't work or required a workaround from the Github Issues for the source code. That's the main reason this is a 4 for me. Otherwise, it was a really nice read, and I feel more confident that I did previously.
November 15, 2021
I really liked this book. Especially the later chapters on lower level concepts like kernels, interrupts, and signals were nice. In general this book builds short but interesting example programs all the while teaching you Rust. This isn't a reference book, this is for people wanting to learn by doing examples. There are lots of reference type books out there so this is a refreshing take on a programming book.
January 19, 2023
this is an awesome book to extend your Rust and programming knowledge by doing real world applications that will not only teach you Rust but also learn to be a good programmer .
Different topics with different applications it never gets boring and you learn real world skills while learning Rust.
Author's detailed descriptions, teaching and existance in social media will make feel that you are learning with a community.
Awesome book. Thank you Tim :)
Different topics with different applications it never gets boring and you learn real world skills while learning Rust.
Author's detailed descriptions, teaching and existance in social media will make feel that you are learning with a community.
Awesome book. Thank you Tim :)
December 30, 2024
I have a problem with this book.
On the one hand, it covers all the essential aspects and provides a lot of good information on how to write idiomatic code in Rust.
On the other hand, it contains many low-level, system-level examples - which is a use case for this language, but it's not the broadest and most common audience interested in reading this book.
Long story short: you can start with this book, but if you are interested in writing long-running servers and microservice applications, do not stop there.
On the one hand, it covers all the essential aspects and provides a lot of good information on how to write idiomatic code in Rust.
On the other hand, it contains many low-level, system-level examples - which is a use case for this language, but it's not the broadest and most common audience interested in reading this book.
Long story short: you can start with this book, but if you are interested in writing long-running servers and microservice applications, do not stop there.
March 11, 2025
Somehow the book didn’t click with me. The first part was fine, but it felt like it jumped too early into systems programming, and then tried to cram too much of that into a rust book. If the book would have been called “Systems Programming using Rust”, probably would have been better.
I do have to acknowledge that the author did write a lot of example code, more than I expected, so that is a plus. But overall, I’d give a 3.5, but not more.
I do have to acknowledge that the author did write a lot of example code, more than I expected, so that is a plus. But overall, I’d give a 3.5, but not more.
September 14, 2019
I read an early access version, which consisted of chapters 1-7,9,12. I learned quite a lot, even though I've already had a pretty good intro to rust through reading the Rust Programming Language (RPL), and working through the Rustlings course. I hope the final version includes async/await and the code all runs on Rust Stable, whenever the book is actually published.
April 3, 2022
I'm giving up. There is no good Rust book for beginners. This one is a disappointment. I'm amazed that people think it's ok to write programming books without exercises in them. This is essentially a collection of smaller projects explained in a bad and boring way. I can't shake the feeling that this book was written just so the author can brag that he wrote a book.
June 27, 2022
This book is a great approach to applying Rust to systems engineering, but doesn't stand alone in a vacuum. It's impact is due to filling a niche, while leaving introductory syntax or other applicational uses to other books. I'd advise reading rust for rustaceans first if you are new to the language. My page tabs are on 118, 142, 158, 177, 207 & 331.
June 19, 2023
This book is good to read after The Book (and maybe Rust by Example + Rustlings). For me, it wasn't the best in explaining Rust concepts, but it had a few great exercises (writing an OS), and it explained some (basic) computer concepts, like network connection and system memory.
May 18, 2020
Read MEAP 12, It's a very clear and concise book, not for beginners but the examples are really good
July 9, 2021
It's a good intro to systems programming using Rust. It doesn't bring much to the table if you already use Rust for a few years, however there were some nice tricks in there.
March 8, 2022
It's a good intro, though I didn't feel like I was getting much out of it, still I would recommend reading it
January 5, 2023
Everything about it is amazing.
September 8, 2021
This book is good at introducing Rust Language but spent far less time on actual system level programming than I would like to see.
Displaying 1 - 30 of 31 reviews