- Paperback: 622 pages
- Publisher: O'Reilly Media; 1 edition (December 21, 2017)
- Language: English
- ISBN-10: 1491927283
- ISBN-13: 978-1491927281
- Product Dimensions: 6.9 x 0.9 x 9.2 inches
- Shipping Weight: 2.1 pounds (View shipping rates and policies)
- Average Customer Review: 23 customer reviews
- Amazon Best Sellers Rank: #77,057 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Programming Rust: Fast, Safe Systems Development 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
The Amazon Book Review
Author interviews, book reviews, editors picks, and more. Read it now
Frequently bought together
Customers who bought this item also bought
Customers who viewed this item also viewed
From the Publisher
From the Preface
Rust is a language for systems programming.
This bears some explanation these days, as systems programming is unfamiliar to most working programmers. Yet it underlies everything we do.
You close your laptop. The operating system detects this, suspends all the running programs, turns off the screen, and puts the computer to sleep. Later, you open the laptop: the screen and other components are powered up again, and each program is able to pick up where it left off. We take this for granted. But systems programmers wrote a lot of code to make that happen.
This book will not teach you systems programming. In fact, this book covers many details of memory management that might seem unnecessarily abstruse at first, if you haven’t already done some systems programming on your own. But if you are a seasoned systems programmer, you’ll find that Rust is something exceptional: a new tool that eliminates major, well-understood problems that have plagued a whole industry for decades.
Who should read this book
If you’re already a systems programmer, and you’re ready for an alternative to C++, this book is for you.
Systems programming is for:
- operating systems
- device drivers of all kinds
- media codecs
- media processing
- memory management
- text rendering
- virtualization and software containers
- scientific simulations
About the Author
Jim Blandy has been programming since 1981, and writing Free software since 1990. He has been the maintainer of GNU Emacs and GNU Guile, and a maintainer of GDB, the GNU Debugger. He is one of the original designers of the Subversion version control system. Jim now works on Firefox’s web developer tools for Mozilla.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
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.
The chapter on concurrency, which really showcases the power of Rust's memory safety semantics, was probably the most illuminating. I remember the "ahah" moment I had learning about Elixir's concurrent data pipelines with channels, yet Rust supports this just as easily - and several other concurrency models to boot.
Just about my only criticism is that I thought the chapter on Generics could have used more and simpler examples, to build a better mental model of how they work. I still feel a bit weak on some of the more complex generic type definitions, and will have to read a bit more about this. This and a few other areas lead me to believe that this book is probably better approached by someone with an extensive background in systems programming (particularly with C++), which I do not really have (have only used C++ at a basic level years ago).
Highly recommended to anyone making a serious attempt at learning Rust - a seriously impressive language that has a lot of promise at modernizing systems programming.
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.