The Rust systems programming language combines this control with a modern type system that detects broad categories of common errors, from memory management errors to interthread data executions.
With this guide, experienced systems programmers will learn how to successfully bridge the gap between performance and security using Rust. Jim Blandy, Jason Orendorff, and Leonora Tindall show how Rust's capabilities allow programmers to control memory consumption and CPU utilization by combining predictable performance with memory security and reliable concurrency.
You will learn:
- Fundamental data types of Rust and basic concepts of ownership and loan
- Basics of the language, including error handling, checkout and forms, structures and enumerations
- How to write flexible and efficient code with lines and generics
- The main tools of Rust: stops, iterators and asynchronous programming
- Collections, strings and text, inputs and outputs, concurrency, macros, malicious code, and interfacing with external functions
Rust is a system programming language.
This deserves some explanation these days, as system programming is unfamiliar to most active programmers. Yet it is the basis of everything we do.
Close your laptop. The operating system detects it, suspends all running programs, turns off the screen, and puts the computer to sleep. After that, open the laptop - the screen and other components turn on again, and each program is able to pick up where it left off. We take it for granted. But system programmers have written a lot of code to make it happen.
In short, system programming is resource-limited programming. Program when every byte and every CPU cycle count.
The amount of system code involved in supporting a core application is staggering.
This book will not teach you how to program the system. In fact, this book covers many details of memory management that might seem unnecessarily obscure at first, if you haven't already done some system programming yourself.
But if you're a seasoned systems programmer, you'll find Rust to be something great: a new tool that eliminates the big, well-understood problems that have plagued an entire industry for decades.
Who should read this book
However, you don't just have to learn Rust. To get the most out of the language, you should also gain some experience with system programming. We recommend that you read this book when implementing system programming side projects in Rust. Create something you've never built before, something that leverages Rust's speed, competition, and security. The list of topics at the beginning of the book's preface should give you some ideas.
We decided to write the book we wish we had when we started studying Rust. Our goal was to tackle the great and new concepts of Rust head-on, presenting them clearly and in depth to minimize learning by trial and error.
About the author
Jim Blandy has been programming since 1981 and has been writing free software since 1990. He was the maintainer of GNU Emacs and GNU Guile, and a maintainer of GDB, the GNU debugger. He is one of the original designers of Subversion's version control system. Jim now works for Mozilla on Firefox Web Development Tools.
Leonora Tindall is passionate about type system and software engineer.
Programming Rust fast safe systems development book reviews
Programming Rust review by Wayne Tanner
It covers language and is based on concepts in a way that made sense to me. One of the best technical books I've read in a long time.
Programming Rust review by Serkan Özel
The book is informative and good. I ordered in Turkey. The packaging was too plain and weak, so the book has some minor flaws.
Programming Rust review by oprs
It is difficult to talk about this book without mentioning its direct "competitor", whose text (available online) is often presented as being THE reference in language.
"Programming Rust" keeps its promise: a dense and well-written book, which speaks above all about language, and which does not try at all costs to take you by the hand, to become friends with you, or to feign wonder in front of each functionality or paradigm borrowed from other languages (which quickly made me reading "The Rust Programming Language" unbearable, I did not finish it besides).
The format is now classic: an initial chapter "tour of the track", comprising several examples intended to illustrate the main characteristics of the language, which are then explored in depth over the chapters.
The style is pragmatic. The authors start from the principle that the reader is already "fluent" in other languages, and do not hesitate to underline the similarities which are essential ("such form corresponds to a static method in C ++ or in Java", "a Enum in Rust corresponds to a typical sum in ML or Haskell ", etc ...). It evokes concrete knowledge, and it allows a first intuitive approach before going into detail.
Where many works are content to refer the reader to later chapters, by abusing the "for the time being, let's just assume that ...", the authors here have obviously taken care to synthesize each new concept in a few lines , so as to precisely delimit its perimeter, without disturbing the thread of the reading. A form of courtesy that has become rare, and in any case very appreciable.
The text contains many examples, and reads very well despite the almost 700 pages of this second edition. In short, you get what you pay for.
I therefore recommend it without hesitation to those who have the curiosity (or the need) to learn to program EN Rust, rather than learning to program (comma) with Rust.