liveBook · Manning

Rust

Rust is a statically typed systems programming language designed for performance, concurrency, and memory safety without requiring garbage collection.

How 8 Manning books explain it

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.

Read how Refactoring to Rust explains Rust →

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.

Read how Rust Servers, Services, and Apps explains Rust →

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.

Read how Learn Rust in a Month of Lunches explains Rust →

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.

Read how Code Like a Pro in Rust explains Rust →

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.

Read how Fast by Default explains Rust →

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.

Read how Idiomatic Rust explains Rust →

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.

Read how Embedded Software with Rust explains Rust →

Also covered in

What to know first

Related concepts

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.