Heap
A runtime memory region from which dynamically allocated data is obtained and whose storage is managed independently of individual function call frames.
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 memory costs and guide allocation-focused optimization.
- How deep it goes
- Works through stack-frame lifetimes, escape decisions, measured allocations, and GC behavior; treats escape cases as non-exhaustive.
- Examples
- Contrasts value and pointer returns, benchmark allocation results, and compiler escape output.
- What you can do after
- Diagnose/debug heap escapes with go build -gcflags "-m=2" and assess their allocation cost with benchmarks.
Read how 100 Go Mistakes and How to Avoid Them 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
- Frames memory placement as a performance and footprint choice in Rust programs.
- How deep it goes
- Explains pointer access and Box allocation with worked code, while deferring a fuller account of the heap to virtual memory.
- Examples
- Works through boxed-integer arithmetic and a sequence of Box allocations with an explicit drop.
- What you can do after
- Apply it via Box<T> to allocate a value, access it through a pointer, and explicitly release an allocation with drop.
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.
Latency
A heap is a dynamically sized memory region used for storage whose allocation changes during program execution.
- How it is used
- Defines the runtime storage region used to explain allocation work and its latency costs.
- How deep it goes
- Works through a simplified freelist allocator and a garbage-collected allocation scheme, while noting that production allocators have further layers.
- Examples
- Uses a Rust `Box` allocation, an allocator with 8- and 16-byte blocks, and diagrams of free blocks and address-space sections.
- What you can do after
- Evaluate/understand how heap allocation and garbage collection can introduce variable work and tail latency.
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.
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.
Related concepts
- memory allocatoruses · A software component or interface that manages the allocation and release of memory for program use.
- execution context stackcontrasts with · An execution context stack is a runtime last-in-first-out structure that records active function or method calls and their execution state and return information.
- classused by · A class is a programming-language construct that defines a type’s structure or behavior and provides a basis for creating or representing objects.
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.