Eager evaluation
Eager evaluation is an execution strategy that computes expressions or performs operations immediately rather than deferring them until their results are needed.
Deep Learning with R, Third Edition
Eager execution is an execution mode in which operations run immediately and produce results without first constructing a deferred computation graph.
- How it is used
- Runs TensorFlow, PyTorch, and JAX operations immediately to support interactive development and straightforward debugging.
- How deep it goes
- Explains immediate execution, debugging benefits, and performance costs, then contrasts eager operation with compilation.
- Examples
- Uses TensorFlow tensor operations and nested gradient tapes, plus PyTorch linear models and training steps, as concrete eager examples.
- What you can do after
- Diagnose/debug tensor code interactively, then choose whether TensorFlow or PyTorch compilation is worth its performance and reliability costs.
Read how Deep Learning with R, Third Edition explains eager evaluation →
Functional Programming in Scala, Second Edition
Strict code evaluates an argument or expression before the surrounding computation proceeds, rather than delaying evaluation until its value is needed.
- How it is used
- Contrasts default strict computation with nonstrict techniques for controlling when expressions are evaluated.
- How deep it goes
- Defines strict argument evaluation and demonstrates its timing, but defers broader implementation details to nonstrictness and laziness.
- Examples
- Uses square, sys.error, conditional branches, short-circuiting operators, and LazyList construction to expose evaluation timing.
- What you can do after
- Evaluate Scala calls by predicting which arguments run before function bodies and which expressions can be skipped.
Read how Functional Programming in Scala, Second Edition explains eager evaluation →
Deep Learning with PyTorch, Second Edition
An execution model in which operations run immediately rather than being first built into a static graph.
- How it is used
- Runs PyTorch operations immediately throughout model development, training, evaluation, and deployment workflows.
- How deep it goes
- Explains execution through the Python interpreter and C++ or CUDA backends, while deferring detailed deployment capabilities to later treatment.
- Examples
- Uses PyTorch tensor instructions and a project flow spanning data loading, training, model export, and deployment.
- What you can do after
- Apply it via PyTorch by reasoning about each tensor operation as it executes and by relating computation to deployment choices.
Read how Deep Learning with PyTorch, Second Edition explains eager evaluation →
Functional Programming in JavaScript
- How it is used
- Explains why JavaScript may perform unnecessary work before a dependent operation can limit the result.
- How deep it goes
- Defines immediate expression evaluation and contrasts it with deferred execution, without detailing language-runtime internals.
- Examples
- Uses range with take, a Maybe fallback, conditional control flow, and a Lodash map-filter-take chain.
- What you can do after
- Apply conditional control flow or Lodash shortcut fusion to avoid unnecessary function calls and large intermediate results.
Read how Functional Programming in JavaScript explains eager evaluation →
Fast Python: High performance techniques for large datasets
- How it is used
- Contrasts immediate pandas and NumPy computation with deferred Dask execution and frames choices as performance trade-offs.
- How deep it goes
- Explains execution timing, memory, wasted work, repeated traversal, and measured performance, but does not detail runtime internals.
- Examples
- Uses range timing, generator-based temperature parsing, list conversion, and a Dask property-tax computation.
- What you can do after
- Evaluate eager and lazy alternatives using memory considerations, workload needs, and IPython timing measurements.
Read how Fast Python: High performance techniques for large datasets explains eager evaluation →
Related concepts
- lazy evaluationcontrasts with · Lazy evaluation is an evaluation strategy that defers computing an expression or value until its result is needed, potentially avoiding the computation entirely.
- PyTorchused by · PyTorch is an open-source machine-learning framework for Python that provides tensor computation, automatic differentiation, and tools for building and training neural networks.
- applicative applyused by · Applicative apply is an operation that applies a function within an applicative context to a value within a compatible context while combining their effects.
- schedulingused by · Scheduling is the planning and coordination of when and in what order activities or computational work occur, potentially assigning them to available resources subject to constraints.
- code compilationcontrasts with · Code compilation is the translation of source code or another formal representation into an executable, intermediate, or lower-level representation.
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.