liveBook · Manning

Error propagation

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

How 4 Manning books explain it

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 →

Related concepts

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.