Rust
Rust is a statically typed systems programming language designed for performance, concurrency, and memory safety without requiring garbage collection.
Refactoring to Rust
A statically typed systems programming language focused on memory safety, performance, and concurrency without a garbage collector.
- How it is used
- Uses Rust to incrementally improve existing applications’ performance, memory safety, and maintainability without a wholesale rewrite.
- How deep it goes
- Works through ownership rules, compiler errors, integration, and verification, with deeper memory-safety discussion reserved for later.
- Examples
- Compares Python and Rust CSV aggregation, demonstrates moved ownership with artwork, and parses JSON into a struct using Serde.
- What you can do after
- Apply Rust incrementally to existing applications, comparing behavior with tests and evaluating performance with benchmarks.
Rust in Action: Systems programming concepts and techniques
Rust is a compiled systems programming language designed for memory safety, concurrency, and performance without relying on garbage collection.
- How it is used
- Introduces Rust as a general-purpose systems language for practical programming and understanding how computers work.
- How deep it goes
- Explains language goals and compiler behavior through short programs, while deferring advanced concepts and fuller ownership explanations.
- Examples
- Uses multilingual greetings, CSV processing, and compiler errors from moved values and attempted concurrent mutation.
- What you can do after
- Build it from scratch by creating and running a small Rust program with Cargo.
Read how Rust in Action: Systems programming concepts and techniques explains Rust →
Rust Servers, Services, and Apps
Rust is a statically typed systems programming language designed for memory safety, concurrency, and low-level control without a garbage collector.
- How it is used
- Uses Rust to develop distributed backend services and software infrastructure, then a server-rendered web application.
- How deep it goes
- Works from standard-library TCP and HTTP implementations toward asynchronous framework and database code, without making the initial server production-ready.
- Examples
- Builds a TCP client, an HTTP server serving pages and JSON, and a tutor-course storefront backed by Postgres.
- What you can do after
- Build it from scratch with the Rust standard library, then apply it via Actix Web and SQLx to a database-backed service.
Learn Rust in a Month of Lunches
Rust is a compiled systems programming language emphasizing memory safety, performance, and explicit control over low-level data representation.
- How it is used
- Introduces Rust through basic syntax and compiler feedback, then situates it in systems and small tools.
- How deep it goes
- Works through basic types and compiler corrections, while deferring fuller explanations of traits and printing.
- Examples
- Uses a string-editing program and compiler diagnostics to demonstrate corrections, including a mutability error.
- What you can do after
- Diagnose/debug basic Rust code by reading compiler suggestions and correcting types, syntax, and mutability.
Code Like a Pro in Rust
Rust is a systems programming language designed to provide memory safety and concurrency safety without garbage collection.
- How it is used
- Positions Rust for safety- and performance-critical systems, concurrent programs, embedded applications, and WebAssembly.
- How deep it goes
- Explains borrow-checking rules and primitive arithmetic with examples, while stopping short of an exhaustive language reference.
- Examples
- Demonstrates checked integer division and identifies bindings for integrating Rust with Python and other languages.
- What you can do after
- Evaluate/understand Rust’s safety, performance, and productivity trade-offs when choosing where to use it.
Fast by Default
Rust is a compiled systems programming language designed for memory safety, concurrency, and high performance.
- How it is used
- Places Rust in cross-platform core business logic for native desktop applications.
- How deep it goes
- Mentions Rust as a compilable core-logic language without teaching its syntax, memory model, or tooling.
- Examples
- Uses native desktop applications with separate Windows and macOS interface code as the operating scenario.
- What you can do after
- Evaluate/understand Rust's role as a portable core-logic option within a native desktop architecture.
Idiomatic Rust
Rust is a systems programming language designed to provide memory safety and concurrency without relying on garbage collection.
- How it is used
- Uses Rust as the setting for choosing software-design patterns, shaping APIs, and judging antipatterns.
- How deep it goes
- Discusses design tradeoffs around memory, lifetimes, mutability, and safety without detailing compiler internals.
- Examples
- Uses Vec’s mutability, comparisons with C, and unsafe blocks to illustrate practical tradeoffs.
- What you can do after
- Evaluate/understand when to adapt a Rust pattern, opt into mutability, or make an exception to an antipattern warning.
Embedded Software with Rust
Rust is a systems programming language designed for memory safety, concurrency, and low-level control without requiring garbage collection.
- How it is used
- Uses Rust to build dependable firmware under memory, power, and timing constraints.
- How deep it goes
- Explains compile-time safety and language trade-offs, then connects Rust to startup, memory-mapped I/O, unsafe access, and hardware abstractions.
- Examples
- Illustrates direct register access with a C SysTick initialization example before discussing Rust’s unsafe boundary.
- What you can do after
- Builds no_std firmware for emulators and hardware, configuring startup and memory layouts and interacting with peripherals through drivers and abstractions.
Also covered in
- Rust Web Development
- Writing for Developers: Blogs that get read
- Server-Side WebAssembly
- Grokking Simplicity
- Latency
- Go in Practice, Second Edition
What to know first
- garbage collectionGarbage collection is an automated process that identifies and reclaims or removes memory, data, or other items no longer reachable or needed by a system.
- WebAssemblyWebAssembly is a portable, low-level binary instruction format and execution environment for safely and efficiently running compiled code across browsers and other hosts.
- C++C++ is a statically typed, general-purpose programming language that supports procedural, object-oriented, generic, and low-level systems programming.
- concurrencyConcurrency is the structuring or execution of multiple computational activities so their progress overlaps in time, whether or not they run simultaneously.
Related concepts
- programming languagekind of · A programming language is a formal language with defined syntax and semantics for expressing computations and instructions that a computer can execute, interpret, or translate.
- compileruses · A compiler is software that translates source code into another representation, such as machine code, bytecode, or an intermediate form.
- memory safetyuses · Memory safety is the property that a program accesses memory only in valid ways, respecting bounds, allocation, and lifetime rules.
- WebAssemblyuses · WebAssembly is a portable, low-level binary instruction format and execution environment for safely and efficiently running compiled code across browsers and other hosts.
Questions about Rust
What is Rust?
Rust is a statically typed systems programming language designed for performance, concurrency, and memory safety without requiring garbage collection.
Which Manning books explain Rust?
Refactoring to Rust, Rust in Action: Systems programming concepts and techniques, Rust Servers, Services, and Apps, Learn Rust in a Month of Lunches, Code Like a Pro in Rust, Fast by Default, Idiomatic Rust and Embedded Software with Rust.
What should I know before learning Rust?
Manning books that teach Rust usually introduce garbage collection, WebAssembly, C++ and concurrency first.
What is Rust a kind of?
Rust is a kind of systems programming language. A systems programming language is designed for software that requires close interaction with computer resources and control over memory or program execution.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.







