liveBook · Manning

Error propagation

Error propagation is the transmission or spread of an error condition or its effects from an originating operation or stage to dependent operations, components, or results.

How 5 Manning books explain it

JavaScript in Depth

The movement of a thrown error through nested execution contexts until a handler intercepts it or the runtime reports it as uncaught.

How it is used
Uses propagation to explain recovery, cleanup, debugging, control flow, and asynchronous failure handling.
How deep it goes
Explains synchronous unwinding, finally interference, stack boundaries, and host handlers, but does not develop streaming-model behavior.
Examples
Uses nested functions, transaction rollback, finally suppression, forEach search, setTimeout, browser events, and Node.js process handlers.
What you can do after
Diagnose/debug failures by tracing stack boundaries, preserving causes, avoiding suppression, and selecting browser or Node.js handlers.

Read how JavaScript in Depth explains error propagation →

Rust Servers, Services, and Apps

Error propagation is the technique of passing an operation's failure result to a caller so that a higher-level component can handle it.

How it is used
Routes database failures from course retrieval to an HTTP handler for production-oriented request handling.
How deep it goes
Contrasts unwrap() with ?, then applies Result signatures and error conversions without detailing Rust error internals.
Examples
Uses tutor course retrieval, SQLx queries, EzyTutorError conversions, curl requests, and handler tests.
What you can do after
Apply error propagation via Rust's question mark operator and custom From implementations in an Actix web service.

Read how Rust Servers, Services, and Apps explains error propagation →

Learn Go with Pocket-Sized Projects

Error propagation is the practice of passing an error to an upper program layer when the current layer cannot resolve it.

How it is used
Uses wrapped errors to move unresolved validation failures from helper functions to callers that can choose the response.
How deep it goes
Explains immediate error checks, contextual wrapping, caller behavior, and unit verification, stopping short of broader error-taxonomy design.
Examples
Demonstrates a word-length validator, a wrapped `fmt.Errorf` return, terminal error reporting, and `errors.Is` tests.
What you can do after
Build error-aware Go call chains that wrap unresolved failures, preserve their identity, and let callers respond appropriately.

Read how Learn Go with Pocket-Sized Projects explains error propagation →

Machine Learning Platform Engineering

Error propagation analysis identifies how failures introduced at one processing stage affect subsequent stages and final outputs.

How it is used
Separates failures across retrieval, context assembly, and generation to improve reliability in multistep LLM systems.
How deep it goes
Locates breakdowns across reasoning stages and traces tokens and branches, but does not specify recovery implementations.
Examples
Uses vacation-policy retrieval, indexed document chunks, and Langfuse spans across retrieval, augmentation, and generation.
What you can do after
Diagnose/debug with Langfuse by locating failures in retrieval, context assembly, or generation traces.

Read how Machine Learning Platform Engineering explains error propagation →

Kotlin in Action, 2E

Error propagation is the transmission of an error or exception from the computation where it occurs to an enclosing or related computation.

How it is used
Handles uncaught failures across coroutine hierarchies and provides a basis for controlling errors in coroutines and flows.
How deep it goes
Explains child-to-parent propagation and await() rethrowing, while deferring broader parent-handling strategies.
Examples
Uses async with await(), launch with try/catch, and UnsupportedOperationException examples.
What you can do after
Diagnose/debug with it by locating the parent responsible for an uncaught coroutine exception and choosing where to catch it.

Read how Kotlin in Action, 2E explains error propagation →

Also covered in

What to know first

Related concepts

Questions about error propagation

What is error propagation?

Error propagation is the transmission or spread of an error condition or its effects from an originating operation or stage to dependent operations, components, or results.

Which Manning books explain error propagation?

JavaScript in Depth, Rust Servers, Services, and Apps, Learn Go with Pocket-Sized Projects, Machine Learning Platform Engineering and Kotlin in Action, 2E.

What should I know before learning error propagation?

Manning books that teach error propagation usually introduce call stack, language model and mean first.

What is the difference between error propagation and pipe?

Error propagation is the transmission or spread of an error condition or its effects from an originating operation or stage to dependent operations, components, or results. A Node.js stream method that connects a readable stream to a writable stream while coordinating flow control.

What is error propagation a kind of?

Error propagation is a kind of propagation. Propagation is the transmission or spreading of information, state, results, or changes to dependent components or elements.

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.