liveBook · Manning

Heap

A heap is a runtime memory region from which dynamically allocated data is obtained and whose allocation and lifetime are managed separately from function call frames.

How 11 Manning books explain it

100 Go Mistakes and How to Avoid Them

A memory heap is a region of runtime memory shared by goroutines for objects whose lifetimes cannot be confined to a stack frame.

How it is used
Uses heap allocation to explain Go performance costs and allocation-reduction decisions.
How deep it goes
Traces stack frames and escape-analysis cases, then introduces garbage collection and compiler diagnostics.
Examples
Compares returning a sum by value or pointer, with allocation benchmarks and compiler escape output.
What you can do after
Diagnose heap allocation decisions with Go compiler escape diagnostics and allocation benchmarks.

Read how 100 Go Mistakes and How to Avoid Them explains heap →

High Performance Unity Game Development

A region of runtime memory used for dynamically allocated data whose lifetime is managed separately from function call frames.

How it is used
Frames heap allocation as a layout and lifetime decision for long-lived Unity game data.
How deep it goes
Explains allocation placement, locality, and delayed reuse with examples, while deferring fuller garbage-collection and fragmentation treatment.
Examples
Uses enemy-data arrays, a string-bearing struct, destroyed GameObjects, and temporary arrays inspected in the Unity Profiler.
What you can do after
Evaluate/understand heap-related locality and allocation costs when choosing C# data layouts for Unity gameplay.

Read how High Performance Unity Game Development explains heap →

Embedded Software with Rust

A heap is a region of dynamically managed memory used for runtime allocation.

How it is used
Uses the heap for embedded data whose size or lifetime cannot be known at compile time.
How deep it goes
Explains allocator setup, allocation failure, and alternatives, without detailing allocator internals.
Examples
Illustrates a fixed array replacing Vec and identifies sensor-dependent buffers and growing client lists as heap candidates.
What you can do after
Operate/configure a no_std heap by selecting a global allocator and reserving RAM, or choose a fixed-capacity alternative.

Read how Embedded Software with Rust explains heap →

Rust in Action: Systems programming concepts and techniques

The heap is a region of memory used for dynamically allocated data whose lifetime and size are not determined solely by the call stack.

How it is used
Uses heap memory to explain allocation choices and their performance trade-offs.
How deep it goes
Explains pointer access and allocation through Box examples, while deferring a fuller memory model to virtual memory.
Examples
Illustrates boxed integers, explicit dropping, and a warehouse analogy for allocation.
What you can do after
Apply heap allocation via Rust’s Box and dereference boxed values in simple programs.

Read how Rust in Action: Systems programming concepts and techniques explains heap →

.NET in Action, Second Edition

A heap is a runtime memory region from which programs dynamically allocate contiguous chunks of memory.

How it is used
Explains runtime-sized allocation as the memory-management context for understanding .NET garbage collection.
How deep it goes
Contrasts heap allocation with stack frames and fixed-size arrays, then outlines collection and compaction without detailing collector internals.
Examples
Uses C++ and C# functions that read integers into runtime-sized arrays.
What you can do after
Evaluate/understand it by distinguishing runtime-sized heap allocation from fixed-size stack allocation and recognizing garbage collection’s role.

Read how .NET in Action, Second Edition explains heap →

Latency

A heap is a dynamically sized memory region used for storage whose allocation changes during program execution.

How it is used
Uses heap management to examine runtime allocation and its effect on application latency.
How deep it goes
Explains free-list allocation and a generational collection approach, while noting that production allocators add further layers and optimizations.
Examples
Illustrates a Rust Person allocated with Box::new and a free list containing allocated and available blocks.
What you can do after
Evaluate how heap allocation and garbage collection affect latency, and distinguish heap storage from stack frames.

Read how Latency explains heap →

Refactoring to Rust

A heap is a dynamically managed memory region for data whose size or lifetime is not confined to a function call.

How it is used
Explains where runtime data such as strings and arrays resides when its size or lifetime is not confined to a function call.
How deep it goes
Defines heap memory, contrasts it with the stack, and explains allocation and cleanup without descending into implementation internals.
Examples
Uses arrays, strings, a visitor-name program, and contrasting placements of manual cleanup.
What you can do after
Evaluate whether data needs dynamically managed memory and identify the allocation and cleanup stages.

Read how Refactoring to Rust explains heap →

JavaScript in Depth

A region of memory used for dynamic allocation of objects and other data whose size or lifetime is not fixed at compile time.

How it is used
Explains where JavaScript objects reside and why allocation patterns influence garbage-collection frequency and cost.
How deep it goes
Descends from heap definition to pages, generations, promotion, and large-object placement, while deferring detailed memory-management internals.
Examples
Uses strings, server-rendering object trees, closures, callbacks, pages, semi-spaces, and large-object allocation as concrete cases.
What you can do after
Evaluate how object size, reachability, survival, and allocation rate affect V8 heap placement and collection behavior.

Read how JavaScript in Depth explains heap →

100 Java Mistakes and How to Avoid Them

The heap is the runtime memory area from which dynamically allocated objects and data structures are allocated.

How it is used
Uses heap-backed collections to preserve recursive state when call depth may exceed practical stack limits.
How deep it goes
Contrasts recursive stack usage with iterative heap storage and stops short of general heap-management internals.
Examples
Demonstrates deep string processing, tail-recursion conversion, and iterative search through a named tree.
What you can do after
Apply it via ArrayDeque to refactor recursive traversals that may exceed stack capacity.

Read how 100 Java Mistakes and How to Avoid Them explains heap →

Learn Rust in a Month of Lunches

The heap is a region of memory used for dynamically allocated data whose size or lifetime is not limited to a call frame.

How it is used
Explains how Rust stores data whose size is unknown at compile time and connects that choice to pointers and memory access.
How deep it goes
Defines heap memory, contrasts its speed and sizing with the stack, and stops short of describing allocation internals.
Examples
Uses i32 versus unknown-sized data, a pointer-following analogy, and a small embedded device without heap access.
What you can do after
Understand when data moves to heap memory and how a stack pointer leads to it.

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

Systems Programming with Zig

Heap memory is dynamically managed storage requested during program execution for data whose size or lifetime is not fixed by a function call.

How it is used
Provides storage for data of unknown size without relying on the limited stack.
How deep it goes
Defines heap requests, allocator-managed blocks, system calls, and freeing for reuse without detailing allocation algorithms.
Examples
Uses huge arrays as an example of stack overflow and contrasts runtime allocation in C with explicit allocation in Zig.
What you can do after
Apply allocators to request memory and free it for reuse.

Read how Systems Programming with Zig explains heap →

Also covered in

What to know first

Related concepts

Questions about heap

What is heap?

A heap is a runtime memory region from which dynamically allocated data is obtained and whose allocation and lifetime are managed separately from function call frames.

Which Manning books explain heap?

100 Go Mistakes and How to Avoid Them, High Performance Unity Game Development, Embedded Software with Rust, Rust in Action: Systems programming concepts and techniques, .NET in Action, Second Edition, Latency, Refactoring to Rust, JavaScript in Depth and 3 more.

What should I know before learning heap?

Manning books that teach heap usually introduce garbage collection, memory, string and Box first.

What is the difference between heap and call stack?

A heap is a runtime memory region from which dynamically allocated data is obtained and whose allocation and lifetime are managed separately from function call frames. A call stack is a runtime LIFO structure that tracks active function or method calls, including their execution contexts and return information.

What are the parts of heap?

Heap includes Large Object Space and page.

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.