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 …
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.
Rust is the perfect language for systems programming. It delivers the low-level power of C along with rock-solid safety features that let you code fearlessly. Ideal for applications requiring concurrency, Rust programs are compact, readable, and blazingly fast. Best of all, Rust’s famously smart compiler helps you avoid even subtle coding errors.
Rust in Action is a hands-on guide to systems programming with Rust. Written for inquisitive programmers, it presents real-world use cases that go far beyond syntax and structure. You’ll explore Rust implementations for file manipulation, networking, and kernel-level programming and discover awesome techniques for parallelism and concurrency. Along the way, you’ll master Rust’s unique borrow checker model for memory management without a garbage collector.
For intermediate programmers. No previous experience with Rust required.
Tim McNamara uses Rust to build data processing pipelines and generative art. He is an expert in natural language processing and data engineering.
Engaging writing style and crisp, easy-to-grasp examples help the reader get off the ground in no time.Chapter 1. Introducing Rust
Chapter 1. A taste of the language
Chapter 1. What does Rust look and feel like?
Chapter 1. Goal of Rust: Safety
Chapter 1. Rust’s big features
Chapter 1. Where does Rust fit best?
Part 1 Rust language distinctives
Chapter 2. Language Foundations
Chapter 2. Numbers
Chapter 2. Floating-point hazards
Chapter 2. Flow control
Chapter 2. Defining functions
Chapter 2. Creating grep-lite
Chapter 2. Making lists of things with arrays, slices, and vectors
Chapter 2. Including third-party code
Chapter 3. Compound data types
Chapter 3. Adding methods to a struct with impl
Chapter 3. Making use of the Result return type
Chapter 3. Implementing std::fmt::Display for your own types
Chapter 4. Lifetimes, ownership, and borrowing
Chapter 4. What is an owner? Does it have any responsibilities?
Chapter 4. Duplicate the value
Part 2 Demystifying systems programming
Chapter 5. Data in depth
Chapter 5. Understanding endianness
Chapter 5. Isolating the exponent
Chapter 5. Fixed-point number formats
Chapter 5. Implementing a CPU to establish that functions are also data
Chapter 5. CPU RIA/3: The Caller
Chapter 6. Memory
Chapter 6. Exploring Rust’s reference and pointer types
Chapter 6. Rust’s pointer ecosystem
Chapter 6. The stack
Chapter 6. The heap
Chapter 6. What is dynamic memory allocation?
Chapter 6. Virtual memory
Chapter 6. Translating virtual addresses to physical addresses
Chapter 7. Files and storage
Chapter 7. File operations in Rust
Chapter 7. Actionkv v1: The front-end code
Chapter 7. Validating I/O errors with checksums
Chapter 7. Creating a HashMap and populating it with values
Chapter 8. Networking
Chapter 8. Trait objects
Chapter 8. TCP
Chapter 8. Ergonomic error handling for libraries
Chapter 8. MAC addresses
Chapter 9. Time and timekeeping
Chapter 9. Encoding time
Chapter 9. clock v0.1.2: Setting the time
Chapter 9. clock v0.1.3: Resolving differences between clocks with the Network Time Protocol (NTP)
Chapter 10. Processes, threads, and containers
Chapter 10. Reproducing the results
Chapter 10. Single-threaded render-hex overview
Chapter 10. Using a thread pool and task queue
Chapter 10. Concurrency and task virtualization
Chapter 11. Kernel
Chapter 11. Source code listings
Chapter 11. Writing to the screen with VGA-compatible text mode
Chapter 11. fledgeos-3: Text output
Chapter 12. Signals, interrupts, and exceptions
Chapter 12. Signal handling
Chapter 12. Global variables in Rust
Chapter 12. Shutting down from deeply nested call stacks
Chapter 12. Casting a pointer to another type