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
- Replaces selected components of existing applications to address measured performance problems, memory safety, or maintainability without a wholesale rewrite.
- How deep it goes
- Develops ownership through a compile-error example and types through comparisons, then extends to integration and verification rather than a full language reference.
- Examples
- Compares Python and Rust CSV aggregation, demonstrates a moved-value compiler error, and parses JSON into a typed struct.
- What you can do after
- Practice/perform incremental Rust refactoring by selecting a component, matching its behavior, integrating it, testing both paths, and planning rollout.
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
- Deploys Rust for systems programming and quick-starting, low-memory command-line utilities that are easy to distribute.
- How deep it goes
- Works through introductory syntax and compiler errors, while deferring advanced language concepts and fuller concurrency treatment.
- Examples
- Uses multilingual greetings and CSV-like penguin records to demonstrate iteration, strings, methods, closures, and program output.
- What you can do after
- Build it from scratch: create and run a multilingual greeting program with cargo, then read a small data-processing program.
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
- Uses Rust to introduce small programs and compiler-guided correction, while noting its use in small tools and larger software.
- How deep it goes
- Works through types, printing, variables, and compiler errors, while deferring fuller treatment of traits and printing.
- Examples
- Shows a string program corrected through compiler messages and strings whose byte lengths differ from their character counts.
- What you can do after
- Practice/perform it: write small Rust programs and use compiler suggestions to correct type, formatting, and mutability errors.
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 as a choice for safety- and performance-critical systems and components, including concurrent and embedded work.
- How deep it goes
- Explains borrow-checker rules and selected arithmetic and testing consequences, without attempting an exhaustive language reference.
- Examples
- Uses integer literals, checked division, divide-by-zero behavior, and a bindings table for cross-language integration.
- What you can do after
- Evaluate/understand when Rust’s safety and performance justify its development costs and how to add Rust components to existing applications.
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.
Related concepts
- programming languagekind of · A programming language is a formal language with defined syntax and semantics for expressing computations and instructions that computers can execute or interpret.
- memory safetyuses · Memory safety is the property that a program accesses and manages memory according to valid bounds, lifetimes, and access rules, avoiding invalid accesses and related errors.
- WebAssemblyuses · WebAssembly is a portable, compact binary instruction format and execution environment for safely and efficiently running compiled code in browsers and other hosts.
- resource acquisition is initializationuses · Resource acquisition is initialization (RAII) is a resource-management pattern that ties resource ownership and release to the lifetime of an object or scope.
- Qdrantused by · Qdrant is an open-source vector database and similarity-search engine for storing, indexing, and querying vectors, with support for filtering by associated metadata.
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.