Rust Systems Programming: Build Memory-Safe, Concurrent Software with Ownership and Low-Level Control (Paperback) (ISBN-13: 9798177855783)

What if you could work close to the machine without making memory safety someone else's problem?

Systems software demands control.

You may need to decide exactly who owns a buffer, when a file handle is released, how data moves between threads, whether I/O should block, how an external C library is wrapped, or whether an allocation on a hot path is actually costing performance.

Traditionally, that level of control has come with serious responsibility: dangling pointers, use-after-free bugs, invalid aliasing, data races, resource leaks, and subtle lifetime mistakes.

Rust Systems Programming shows you how Rust changes that tradeoff.

Rather than treating ownership, borrowing, and lifetimes as compiler obstacles to memorize, this practical guide teaches you to use them as engineering tools for expressing resource responsibility, access, invariants, concurrency, and safety.

Inside, you'll learn how to:

• Develop a practical mental model for ownership, borrowing, and lifetimes
• Understand how Rust manages resources without relying on a tracing garbage collector
• Choose deliberately between references, Box, Rc, Arc, channels, locks, and atomics
• Design APIs whose signatures communicate ownership and responsibility clearly
• Build stronger data models with enums, newtypes, invariants, and explicit states
• Reason about stack, heap, memory layout, alignment, padding, allocation, and cache locality
• Use traits and generics to create reusable abstractions without giving up predictable performance
• Design thread-safe systems using Send, Sync, shared state, message passing, scoped threads, and atomics
• Understand why deadlocks, starvation, contention, and logical races still require engineering judgment
• Work with async functions, futures, executors, wakers, task ownership, cancellation, bounded concurrency, and backpressure
• Build network and I/O software around buffers, streams, framing, partial progress, serialization, and protocol boundaries
• Use unsafe as a small, explicit proof boundary rather than spreading unchecked assumptions throughout a codebase
• Integrate Rust with C and other native systems through FFI and carefully designed safe wrappers
• Profile allocations, copying, contention, cache behavior, and hot paths before optimizing
• Test critical invariants with property testing, fuzzing, and concurrency-focused verification
• Build observability with useful logs, metrics, tracing, and capacity signals
• Strengthen dependency and software-supply-chain practices
• Structure larger projects with Cargo workspaces, features, lockfiles, build profiles, linting, and reproducible builds
• Design production processes around initialization, supervision, graceful shutdown, configuration, deployment, and stable crate boundaries
• Introduce Rust incrementally into existing systems rather than assuming everything must be rewritten

The book makes an important distinction: memory safety is not the same thing as logical correctness or operational reliability. Rust can prevent major classes of unsafe memory behavior, but applications can still deadlock, implement the wrong protocol, exhaust resources, retry incorrectly, or fail operationally. Rust Systems Programming

Whether you're a Rust developer, backend engineer, systems programmer, infrastructure engineer, network programmer, embedded developer, C/C++ programmer, performance engineer, or experienced developer exploring memory-safe systems software, this book will help you understand not only how Rust works, but how to make sound engineering decisions with it.

Don't fight the compiler until the code builds. Learn to design systems whose ownership, safety, concurrency, and resource boundaries are clear enough for the compiler to help you prove them.