Execution context stack
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.
Rust in Action: Systems programming concepts and techniques
A call stack is the runtime structure that records active function calls, their local data, and the points to which control returns.
- How it is used
- Tracks return points for nested function calls and clarifies how normal returns differ from unwinding or nonlocal control transfer.
- How deep it goes
- Works through a fixed-size stack, stack pointer, and call-and-return methods; does not develop a general stack-frame layout.
- Examples
- Uses a Rust CPU emulator with call() and ret(), plus a recursive program that prints its changing call depth.
- What you can do after
- Build it from scratch in a small CPU emulator and use call depth to understand nested returns.
100 Go Mistakes and How to Avoid Them
A call stack is the runtime-ordered sequence of active function calls through which control returns during execution.
- How it is used
- Uses active Go function calls to explain stack-frame lifetimes and allocation choices during performance work.
- How deep it goes
- Traces frame creation and return in a worked call, then explains when escape analysis places variables on the heap.
- Examples
- Traces main calling sumValue, contrasts a returned pointer in sumPtr, and shows benchmark and compiler escape output.
- What you can do after
- Diagnose/debug with it by tracing frame lifetimes and checking suspected heap escapes with go build -gcflags "-m=2".
Read how 100 Go Mistakes and How to Avoid Them explains execution context stack →
Go in Practice, Second Edition
A call stack is the runtime structure that records active function invocations and their execution contexts.
- How it is used
- Uses goroutine-local stacks to explain concurrent request handling and the boundary required for panic recovery.
- How deep it goes
- Explains stack creation, unwinding, and recovery boundaries, but stops short of runtime implementation details.
- Examples
- Demonstrates an echo server, a panicky response, an HTTP handler, and a reusable goroutine recovery wrapper.
- What you can do after
- Diagnose goroutine crashes and add deferred recovery at the correct function-stack boundary.
Read how Go in Practice, Second Edition explains execution context stack →
Grokking Algorithms, Second Edition
A call stack is a runtime stack that stores information for active function calls, including their execution state and local data.
- How it is used
- Tracks active function calls and preserves paused execution while functions call other functions or recurse.
- How deep it goes
- Explains push, pop, saved variables, recursive growth, and stack-height costs, but defers tail recursion.
- Examples
- Uses sticky-note tasks, nested greetings, recursive factorial, recursive search, and quicksort pivot choices.
- What you can do after
- Diagnose/debug with it: trace nested calls, identify paused execution, and recognize excessive stack growth.
Read how Grokking Algorithms, Second Edition explains execution context stack →
Functional Programming in JavaScript
A stack of execution-context frames used by JavaScript to manage nested function calls and their associated execution state.
- How it is used
- Explains how JavaScript manages function calls and analyzes performance costs from nested execution.
- How deep it goes
- Explains LIFO behavior, frame contents, memory growth, and nested-call costs without detailing the complete runtime specification.
- Examples
- Uses logger invocation, curried addition, unbounded recursion, and recursive longest-string search to illustrate stack behavior.
- What you can do after
- Diagnose stack-related performance problems by relating nested calls, currying, and recursion to execution-frame growth.
Read how Functional Programming in JavaScript explains execution context stack →
Secrets of the JavaScript Ninja, Second Edition
A stack-like runtime structure that records active execution contexts for nested calls and returns.
- How it is used
- Tracks active and waiting JavaScript execution contexts as nested calls pause and resume.
- How deep it goes
- Defines stack behavior and traces nested calls through returns without detailing execution-context internals.
- Examples
- Traces skulk calling report, followed by separate skulk calls with Kuma and Yoshi.
- What you can do after
- Understand which execution context is active as function calls nest and return.
Read how Secrets of the JavaScript Ninja, Second Edition explains execution context stack →
Python How-To
A call stack is a runtime structure that records active and underlying function or method calls in execution order.
- How it is used
- Uses the execution context stack to explain traceback generation and locate the operation that causes an exception.
- How deep it goes
- Explains call order and traceback reading, but stops short of runtime frame internals or stack-memory implementation.
- Examples
- Uses a Task method typo to trace an AttributeError from update_urgency to the invalid update_db call.
- What you can do after
- Diagnose/debug with it by reading the final traceback call, locating the faulty line, correcting the definition, and rerunning the script.
Build a Frontend Web Framework (From Scratch)
The runtime stack of active JavaScript execution contexts used to track currently executing calls.
- How it is used
- Coordinates synchronous calls and queued callbacks while scheduling component lifecycle hooks.
- How deep it goes
- Defines push and pop behavior and explains stack emptiness, but limits event-loop treatment to simplified browser steps.
- Examples
- Uses mountDOM(), onMounted(), fetch(), async/await, promise callbacks, and the browser event-loop cycle.
- What you can do after
- Evaluate when synchronous code, lifecycle callbacks, tasks, and microtasks execute during browser scheduling.
Read how Build a Frontend Web Framework (From Scratch) explains execution context stack →
Related concepts
- stackkind of · A stack is a data structure that adds and removes elements at one end, following last-in, first-out order.
- stack traceused by · A stack trace is a diagnostic record of active or recently unwound function or method calls at an execution point, often including source locations.
- drop frameused by · A debugger operation that returns execution to an earlier point in the call stack and re-runs a method from that point.
- first-in-last-out structureuses · A first-in-last-out structure follows an ordering rule in which the most recently added item is the first retrieved, processed, or removed.
- heapcontrasts with · A runtime memory region from which dynamically allocated data is obtained and whose storage is managed independently of individual function call frames.
- recursionused by · Recursion is a computational technique in which a definition or procedure refers to or invokes the same definition or procedure, directly or indirectly.
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.