liveBook · Manning

Memory safety

Memory safety is the property that a program accesses memory only in valid ways, respecting bounds, allocation, and lifetime rules.

How 5 Manning books explain it

Rust Servers, Services, and Apps

Memory safety is the property that a program cannot perform invalid accesses, use deallocated values, or otherwise violate memory-access rules.

How it is used
Frames memory safety as a Rust benefit for application backends and software infrastructure.
How deep it goes
Identifies memory safety as a distinct property but does not explain its mechanisms in the supplied discussion.
What you can do after
Evaluate Rust’s backend suitability by recognizing memory safety without a garbage collector as a way to prevent several bug classes.

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

Refactoring to Rust

Memory safety is the property that software accesses memory only in valid ways, preventing errors such as use-after-free, buffer overflows, and invalid pointer dereferences.

How it is used
Motivates incremental Rust refactoring of existing applications, especially safety-critical C and C++ code.
How deep it goes
Explains ownership and compile-time checks, introduces unsafe operations, and defers detailed ownership discussion.
Examples
Uses C and C++ refactoring and raw-pointer dereferencing to illustrate safety concerns.
What you can do after
Evaluate where Rust can improve memory safety and where unsafe code leaves safety obligations with the developer.

Read how Refactoring to Rust explains memory safety →

Memory Safe C++

The property that a program's memory operations do not cause errors such as out-of-bounds access or corruption.

How it is used
Frames memory safety as a concern for all C++ development, with potentially irreversible consequences in safety-critical systems.
How deep it goes
Explains a missing-terminator failure and outlines a layered safety process supported by knowledge, discipline, and culture.
Examples
Uses the CrowdStrike outage and a patient-monitoring sensor label to illustrate out-of-bounds reads.
What you can do after
Evaluate/understand memory risks and recognize why complementary practices are needed to build safer C++ software.

Read how Memory Safe C++ explains memory safety →

Hacking Cryptography

Memory safety is the property that program operations access memory only within valid bounds and lifetimes without invalid aliasing or use-after-release.

How it is used
Frames memory handling as a central secure-implementation concern, especially for cryptographic applications.
How deep it goes
Explains buffer-overflow and overread mechanics, names mitigations, and stops short of full memory-management internals.
Examples
Uses server input overflow, bounded C functions, and the OpenSSL 1.0.1f Heartbleed implementation as concrete examples.
What you can do after
Diagnose buffer-boundary failures and choose bounded APIs, testing, fuzzing, and platform mitigations.

Read how Hacking Cryptography explains memory safety →

Embedded Software with Rust

Memory safety is the property that software accesses memory only in valid ways, preventing errors such as use-after-free and out-of-bounds access.

How it is used
Frames memory safety as a reason to use Rust for firmware operating under tight resource budgets and predictable-timing requirements.
How deep it goes
Explains compile-time enforcement and compares language trade-offs, without detailing Rust’s checking mechanisms.
Examples
Contrasts C and C++ pointer and lifetime failures with Rust, and compares Rust against Go, Zig, and MicroPython.
What you can do after
Evaluate embedded language trade-offs in memory safety, runtime overhead, and timing predictability.

Read how Embedded Software with Rust explains memory safety →

Also covered in

What to know first

Related concepts

Questions about memory safety

What is memory safety?

Memory safety is the property that a program accesses memory only in valid ways, respecting bounds, allocation, and lifetime rules.

Which Manning books explain memory safety?

Rust Servers, Services, and Apps, Refactoring to Rust, Memory Safe C++, Hacking Cryptography and Embedded Software with Rust.

What should I know before learning memory safety?

Manning books that teach memory safety usually introduce garbage collection, Rust, compile time and Java first.

What is the difference between memory safety and garbage collection?

Memory safety is the property that a program accesses memory only in valid ways, respecting bounds, allocation, and lifetime rules. Garbage collection is an automated process that identifies and reclaims or removes memory, data, or other items no longer reachable or needed by a system.

What is memory safety a kind of?

Memory safety is a kind of safety. Safety is the property of avoiding specified harmful, hazardous, invalid, or otherwise forbidden outcomes under relevant conditions.

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.