liveBook · Manning

Determinism

Also called Deterministic

Determinism is the property that the same relevant inputs, state, and conditions uniquely determine the same outcome or behavior.

How 12 Manning books explain it

Data-Oriented Programming in Java

A deterministic function is a computation whose output is completely determined by its inputs and remains consistent for repeated evaluations with those inputs.

How it is used
Separates domain transformations from environmental effects to organize implementations around a deterministic core.
How deep it goes
Defines deterministic and pure functions, refactors Java methods, and derives testing and architectural consequences without purity enforcement.
Examples
Uses increment, status-to-color mapping, due-date calculation, parallel logging, invoice rules, CSV parsing, and lookup tables.
What you can do after
Apply it by refactoring environmental dependencies into inputs and testing domain logic through direct input-output assertions.

Read how Data-Oriented Programming in Java explains determinism →

Functional Design and Architecture: Examples in Haskell

Determinism is the property that the same inputs and conditions produce a predictable, uniquely determined result.

How it is used
Supports predictable functional code and helps reason about testing and concurrency.
How deep it goes
Explains pure-function composition and contrasts it with shared-state races in parallel tests.
Examples
Illustrates pure calculation with an average and maximum, and a race between tests sharing an IORef.
What you can do after
Apply it to testing by isolating effects and avoiding dependencies between tests.

Read how Functional Design and Architecture: Examples in Haskell explains determinism →

Learn AI-Assisted Python Programming, Second Edition

Determinism is the property that fixed inputs and conditions produce a fixed outcome.

How it is used
Contrasts predictable programming-language behavior with variable AI-generated responses.
How deep it goes
Defines determinism and explains its practical effect on trust, but does not examine implementation internals.
Examples
Uses compiler output, Python code, machine code, and Copilot prompt-to-program generation as examples.
What you can do after
Evaluate generated code skeptically instead of assuming that an AI response is correct or reproducible.

Read how Learn AI-Assisted Python Programming, Second Edition explains determinism →

Optimization Algorithms: AI techniques for design, planning, and control problems

A deterministic model is a model in which each action and current state uniquely determine the resulting state or outcome.

How it is used
Distinguishes repeatable search procedures from stochastic methods and frames planning assumptions about predictable outcomes.
How deep it goes
Defines repeatability from a fixed starting point and names algorithm families, but does not develop their implementations.
Examples
Uses A* commute routes and contrasts deterministic travel times with probabilistic train and traffic delays.
What you can do after
Evaluate whether predictable transitions support deterministic planning or whether uncertainty calls for stochastic planning.

Read how Optimization Algorithms: AI techniques for design, planning, and control problems explains determinism →

Machine Learning System Design

Deterministic behavior is behavior in which the same relevant inputs and state produce the same output.

How it is used
Makes API behavior predictable and predictions reproducible by exposing inputs that affect outputs.
How deep it goes
Demonstrates random seeds and current time as output-affecting inputs through predict-function examples.
Examples
Uses prediction functions with implicit or parameterized time and seeds, and notes temperature-sampled text generation.
What you can do after
Apply it via API design by exposing time and random seeds when callers need reproducible predictions.

Read how Machine Learning System Design explains determinism →

Deep Learning with R, Third Edition

Determinism is the property that identical inputs and explicit state produce identical computational results.

How it is used
Uses explicit random state to make random operations repeatable in stateless JAX code.
How deep it goes
Demonstrates repeatable random calls and key splitting, without detailing PRNG internals.
Examples
Shows JAX normal samples generated with the same key and with a split key.
What you can do after
Apply JAX PRNG keys to reproduce random values or generate new ones by splitting keys.

Read how Deep Learning with R, Third Edition explains determinism →

Causal AI

Determinism is the philosophical view that a system's complete state and governing laws uniquely determine its future state.

How it is used
Frames probabilistic causal modeling by distinguishing uncertainty about a process from randomness within the process.
How deep it goes
Defines deterministic generation through fixed causes and initial conditions, while acknowledging systems that may contain stochastic elements.
Examples
Uses a die roll and Laplace’s demon to contrast apparent randomness with outcomes determined by complete physical causes.
What you can do after
Understand how probability can represent incomplete knowledge even when a modeled data-generating process is deterministic.

Read how Causal AI explains determinism →

Data-Oriented Programming: Reduce software complexity

Determinism is the property that the same causes produce the same effects, such as the same function arguments producing the same return value.

How it is used
Frames predictable function results as a practical aid for debugging programs.
How deep it goes
Defines causes and effects, then stops short of side effects and isolates changing program state.
Examples
Uses elevator predictability and functions receiving identical arguments as concrete examples.
What you can do after
Evaluate whether immutable-data modules return consistent values for identical arguments during debugging.

Read how Data-Oriented Programming: Reduce software complexity explains determinism →

Statistics Every Programmer Needs

A deterministic model produces the same result whenever its inputs and conditions are the same, without representing random variation.

How it is used
Contrasts fixed-input predictions with simulations that represent input variability.
How deep it goes
Defines fixed-input, single-point estimates but does not detail deterministic model implementation.
Examples
Uses project duration estimates and call-center staffing to illustrate the limits of fixed-input predictions.
What you can do after
Evaluate when a single-point prediction may conceal uncertainty represented by Monte Carlo scenarios.

Read how Statistics Every Programmer Needs explains determinism →

Advanced Algorithms and Data Structures

A deterministic algorithm produces the same processing sequence and results for the same input and starting conditions, apart from unspecified tie handling.

How it is used
Frames repeatability as an algorithm property in clustering and as a constraint that heuristics may relax for hard optimization problems.
How deep it goes
Defines repeatability through processing order or starting point, while allowing unspecified ties in OPTICS reachability distances.
Examples
Compares DBSCAN point traversal and OPTICS runs from the same starting point with randomized heuristic search for crossing number.
What you can do after
Evaluate/understand whether repeated runs should match by checking processing order, starting point, and tie handling.

Read how Advanced Algorithms and Data Structures explains determinism →

Code Like a Pro in Rust

A deterministic computation produces the same result for the same inputs and relevant execution conditions.

How it is used
Uses deterministic functions as a guideline for decomposing software into small, testable computations.
How deep it goes
Defines determinism by repeatable results for given inputs and recommends it when possible, without discussing implementation internals.
What you can do after
Apply determinism by designing functions to return the same result for given inputs whenever possible.

Read how Code Like a Pro in Rust explains determinism →

Coding with AI

A system that produces the same output for the same input according to fixed rules.

How it is used
Contrasts fixed-rule systems with generative AI’s variable outputs.
How deep it goes
Defines determinism and illustrates it with a calculator, while keeping the explanation of AI high-level.
Examples
Uses a calculator’s 2 + 2 result and generative AI’s varying answers as examples.
What you can do after
Understand why a calculator repeats an answer while generative AI may vary its response.

Read how Coding with AI explains determinism →

Also covered in

What to know first

Related concepts

Questions about determinism

What is determinism?

Determinism is the property that the same relevant inputs, state, and conditions uniquely determine the same outcome or behavior.

Which Manning books explain determinism?

Data-Oriented Programming in Java, Functional Design and Architecture: Examples in Haskell, Learn AI-Assisted Python Programming, Second Edition, Optimization Algorithms: AI techniques for design, planning, and control problems, Machine Learning System Design, Deep Learning with R, Third Edition, Causal AI, Data-Oriented Programming: Reduce software complexity and 4 more.

What should I know before learning determinism?

Manning books that teach determinism usually introduce language model, input, JSON and software testing first.

What is the difference between determinism and predictability?

Determinism is the property that the same relevant inputs, state, and conditions uniquely determine the same outcome or behavior. Predictability is the degree to which a system’s behavior or outcomes can be anticipated from known inputs, conditions, rules, or patterns.

What kinds of determinism are there?

Kinds of determinism include TimesFM.

What is determinism a kind of?

Determinism is a kind of language model. A language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.

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.