liveBook · Manning

State

State is information describing the condition or configuration of a system or computation at a particular time that may influence its behavior or subsequent transitions.

How 52 Manning books explain it

React Quickly, Second Edition

Global state is application data maintained at a scope accessible to multiple components or parts of an application.

How it is used
Coordinates changing application data across components so interactions update the UI.
How deep it goes
Works through state placement, useState updates, and prop-based sharing; defers Context and more complex state techniques.
Examples
Uses a click counter, clock, current-page menu, and multicomponent task list to show local and shared state.
What you can do after
Build it from scratch: place shared state in a parent and pass values and update functions to task and filter components.

Read how React Quickly, Second Edition explains state →

Build a Frontend Web Framework (From Scratch)

The data representing the current conditions and values of a running application.

How it is used
Determines the current view and supplies the values changed in response to user interaction.
How deep it goes
Develops state from a to-do array into framework-managed values and per-component initialization, updates, and patching.
Examples
Uses a to-do list, a clickable counter, and a list of counters whose internal values challenge reconciliation.
What you can do after
Build it from scratch: define initial component state and update it through a method that patches the view.

Read how Build a Frontend Web Framework (From Scratch) explains state →

Applied Reinforcement Learning

A state describes the relevant condition of an environment at a particular point in a sequential decision process.

How it is used
Frames the information an agent uses to make sequential business decisions under uncertainty.
How deep it goes
Defines states and the Markov property, then develops feature selection, constraints, leakage prevention, and ablation in business environments.
Examples
Uses online pricing, call-center staffing, language generation, and portfolio management to illustrate state representations.
What you can do after
Apply state design to identify decision-relevant features, expose constraints, and test representations without leaking future information.

Read how Applied Reinforcement Learning explains state →

Natural Language Processing in Action, Second Edition

A hidden state vector is the numerical state carried through a recurrent network to summarize information from earlier sequence inputs.

How it is used
Uses hidden state to carry a learned summary between tokens and support predictions during sequence processing.
How deep it goes
Explains recurrent updates, initialization, backpropagation through time, and the distinction between LSTM hidden and cell states.
Examples
Inspects 128-dimensional hidden vectors and category predictions across expanding surname prefixes.
What you can do after
Build a basic recurrent network from scratch in PyTorch and inspect its hidden vectors across input prefixes.

Read how Natural Language Processing in Action, Second Edition explains state →

Hacking Cryptography

The internal state of an LFSR is the mutable sequence of register bits that determines its subsequent output and evolution.

How it is used
Frames prediction, cloning, and keystream-recovery attacks as consequences of exposed mutable cryptographic data.
How deep it goes
Explains LFSR state transitions in executable detail and connects state recovery to concrete cloning attacks.
Examples
Uses LCG and MT19937 cloning, LFSR keystream encryption, and secret-prefix MAC length extension.
What you can do after
Evaluate/understand how observable or recoverable state enables prediction, cloning, and continuation attacks.

Read how Hacking Cryptography explains state →

Functional Programming in Scala, Second Edition

State is a parameterized state-transition abstraction that represents computations producing a value while transforming an underlying state.

How it is used
Models stateful APIs as pure, composable computations that explicitly return their next state.
How deep it goes
Defines State as S => (A, S) and develops composition, get/set/modify, and state-machine simulation.
Examples
Uses a functional RNG and a coin-operated candy dispenser driven by Coin and Turn inputs.
What you can do after
Build it from scratch as a generic State type and compose state-machine transitions with standard combinators.

Read how Functional Programming in Scala, Second Edition explains state →

Rust Servers, Services, and Apps

Application state is the data representing the current condition of an application's configuration, behavior, or resources.

How it is used
Supplies shared course data or a database pool to Actix request handlers.
How deep it goes
Builds and tests in-memory state, then replaces its course collection with an injected Postgres pool.
Examples
Uses a health-check visit counter, course POST and GET handlers, and tests that construct handler state.
What you can do after
Build it from scratch with Actix `web::Data`, then configure handlers to use shared collections or a sqlx pool.

Read how Rust Servers, Services, and Apps explains state →

Build Python Web Apps with Streamlit

A graph state is the structured mutable data associated with a graph execution, including the messages for a conversation thread.

How it is used
Carries conversation and other application data between nodes in a LangGraph workflow.
How deep it goes
Defines graph state and works through state schemas, partial node updates, checkpointing, and history retrieval.
Examples
Uses a one-node chatbot, an added system-message field, and a persistent conversation history.
What you can do after
Apply it via LangGraph to define message state, update fields, and resume a conversation using a checkpointer and thread ID.

Read how Build Python Web Apps with Streamlit explains state →

Sutskever's List

A hidden state is the recurrent representation carried between sequence-processing steps and updated from prior state and current input.

How it is used
Carries learned context between sequence steps or graph-message rounds so later predictions can use earlier information.
How deep it goes
Explains stepwise recurrence, long-range memory failure, and LSTM state distinctions without deriving update equations.
Examples
Uses character prediction, an earlier mention of France, and molecular atoms exchanging messages.
What you can do after
Evaluate/understand it as useful carried context, while recognizing long-range forgetting and fixed-vector compression as distinct limitations.

Read how Sutskever's List explains state →

Inside Deep Learning: Math, Algorithms, Models

The recurrent state vector carried by an RNN across time steps, used here to store sequence information and initialize decoding.

How it is used
Uses hidden state to carry ordered sequence information into whole-sequence predictions and decoder initialization.
How deep it goes
Works through recurrent updates, fixed-size final states, and PyTorch extraction, then explains why long sequences motivate LSTM gating.
Examples
Uses ordered daily weather vectors and a name-classification RNN with a final-state classification layer.
What you can do after
Apply it via PyTorch nn.RNN to extract a sequence summary or initialize a sequence-to-sequence decoder.

Read how Inside Deep Learning: Math, Algorithms, Models explains state →

Get Programming: Learn to code with Python

How it is used
Uses an object’s current contents to explain why later list operations see earlier changes.
How deep it goes
Explains in-place change, rebinding, aliases, and copies, including their effect on object identity.
Examples
Uses grocery lists, indexed color replacements, artist-list copies, and a changing menu.
What you can do after
Diagnose/debug with it when a list changes unexpectedly, and choose an in-place update or an independent copy.

Read how Get Programming: Learn to code with Python explains state →

Functional Design and Architecture: Examples in Haskell

State is the information representing the current condition of a computation or system and that may affect subsequent behavior.

How it is used
Organizes stateful functional applications around lifetime, purity, and boundaries between business logic and interpreters.
How deep it goes
Explains lifetime categories and pure and impure representations, with worked interpreter and argument-passing examples.
Examples
Uses sandwich ingredients, spaceship mass updates, and a controller-to-device runtime map to illustrate state.
What you can do after
Apply argument-passing state and Haskell IORef or MVar representations to organize application and interpreter state.

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

Statistics Every Programmer Needs

A state is a distinct condition or status that a process or system can occupy at a particular point in time.

How it is used
Defines the possible conditions used to forecast a system’s next condition or distribution of conditions.
How deep it goes
Defines exhaustive, exclusive states and works through transition-matrix forecasts, including repeated multiplication and equilibrium.
Examples
Uses running versus non-running engine conditions and four cellular-carrier states, with NumPy market-share forecasts.
What you can do after
Apply it via NumPy to represent states, multiply a probability vector by a transition matrix, and interpret the forecast.

Read how Statistics Every Programmer Needs explains state →

Deep Learning with Python, Third Edition

A hidden-state tensor carried by a recurrent network that summarizes previous inputs and influences future outputs.

How it is used
Carries information across sequence steps for forecasting, character prediction, and encoder-decoder translation.
How deep it goes
Works through a toy recurrent update and explicit GRU state passing, without detailing GRU internals.
Examples
Uses a NumPy toy RNN, Shakespeare character generation, and English-to-Spanish translation.
What you can do after
Build it from scratch in a toy NumPy RNN and apply it via Keras GRU generation.

Read how Deep Learning with Python, Third Edition explains state →

Build AI-Enhanced Web Apps

Mutable information representing the current conditions and accumulated information of an application or workflow.

How it is used
Coordinates model context and visible interface data in AI-powered React applications.
How deep it goes
Explains state separation and walks through provider setup, server actions, and client hooks for a chat application.
Examples
Uses profile settings, sidebar visibility, and a streaming chat conversation to illustrate state management.
What you can do after
Apply state management via the Vercel AI SDK to initialize shared state and coordinate chat actions and interface updates.

Read how Build AI-Enhanced Web Apps explains state →

Functional Programming in C#, Second Edition

Information held by a program or computation that may change as execution proceeds.

How it is used
Uses state to model changing entities and carry information through stateful computations without mutation.
How deep it goes
Explains immutable snapshots and state transitions, then works through explicit state passing and computation composition.
Examples
Uses an exchange-rate cache and a tree-leaf numbering counter to illustrate state passing.
What you can do after
Build it from scratch by passing state through function inputs and outputs and composing stateful computations.

Read how Functional Programming in C#, Second Edition explains state →

Modern C, Third Edition

Hidden state is implementation or library state that affects program behavior without being directly represented by ordinary program values.

How it is used
Exposes implicit execution dependencies when reasoning about function purity and concurrent effects.
How deep it goes
Defines execution state and effects, then explains floating-point state dependencies and pointer aliasing.
Examples
Uses rounding-mode pragmas, aliased pointer arguments, and mutex, once-flag, and atomic-flag states.
What you can do after
Evaluate function purity and execution effects by identifying dependencies on implicit state.

Read how Modern C, Third Edition explains state →

Idiomatic Rust

Global data is program state stored in a globally accessible location rather than passed through local interfaces.

How it is used
Handles data needed beyond local interfaces while weighing the convenience of global access against its design and safety costs.
How deep it goes
Explains static initialization limits, lazy initialization, and library-level alternatives, with focused Rust examples rather than a full state-management framework.
Examples
Uses a rejected static vector of names, a lazy_static version, and a builder-created library context.
What you can do after
Evaluate/understand when to avoid global state and when to use lazy initialization or pass an explicit context instead.

Read how Idiomatic Rust explains state →

React in Depth

State is the data maintained by a component that represents its current condition and can cause updated rendering when changed.

How it is used
Organizes changing UI, form, application, and view-selection data as users interact with a React application.
How deep it goes
Works through hook typing, inspection, and a UX-state integration; stops short of explaining state-update internals.
Examples
Uses an appointment response, an empty tag list, a dark-mode inspector, and list/detail view selection.
What you can do after
Apply it via typed useState for local values and Zustand for view selection alongside TanStack Query.

Read how React in Depth explains state →

Akka in Action, Second Edition

State is the mutable or persistent information that represents an actor's current condition and influences its behavior.

How it is used
Uses state to model wallet balances and make command decisions sequentially within actors.
How deep it goes
Explains behavior-based updates, then develops event-sourced State with command and event handlers, persistence, snapshots, and restart settings.
Examples
Demonstrates bounded wallet totals, a cargo container State list, and a betting-wallet balance with reservation events.
What you can do after
Apply it via Akka Typed and Akka Persistence to implement stateful, durable wallet entities that accept or reject fund requests.

Read how Akka in Action, Second Edition explains state →

D3.js in Action, Third Edition

React state is component-owned data whose updates can trigger a component to render again.

How it is used
Coordinates loading, fetched chart data, and interactive filter selection so visualizations render and update.
How deep it goes
Defines useState variables and demonstrates asynchronous and click-driven updates, without detailing React rendering internals.
Examples
Demonstrates loading flags, fetched chart arrays, active ranking filters, and a dashboard that explores internet blackouts.
What you can do after
Apply it via React useState to load data, control conditional output, and update visualizations from user selections.

Read how D3.js in Action, Third Edition explains state →

AI Agents and Applications

State is the structured information representing a workflow's progress, intermediate results, failures, and contextual values across processing steps.

How it is used
Tracks data and control values across multi-step research and multi-agent workflows.
How deep it goes
Develops typed state, node updates, conditional routing, initialization, and execution through a research workflow conversion.
Examples
Uses a web research assistant with relevance-based query retries and an initialized state for a question about Roman spas.
What you can do after
Apply it via LangGraph to define workflow state, return node updates, and route according to intermediate results.

Read how AI Agents and Applications explains state →

Build a DeepSeek Model (From Scratch)

A state is the information describing the current situation from which a reinforcement-learning policy selects an action.

How it is used
Maps reinforcement-learning decisions onto successive contexts during language generation.
How deep it goes
Defines state transitions and relates state to a simplified policy-gradient update, while noting implementation details omitted from the equation.
Examples
Illustrates state with a cleaning robot's room and a growing response to a tennis-ball arithmetic prompt.
What you can do after
Evaluate how a sampled token changes the state and enters a reward-weighted policy update.

Read how Build a DeepSeek Model (From Scratch) explains state →

Build a Robo-Advisor with Python (From Scratch)

A state is a representation of the relevant current variables of an environment that determine an agent's possible decisions.

How it is used
Represents an investor’s current wealth and time when choosing stock-versus-bond allocations.
How deep it goes
Defines states, discretizes wealth-time nodes, and uses them in transition probabilities and backward induction.
Examples
Uses a wealth-time grid, a node just below a $2 million goal, and stock-bond allocation choices.
What you can do after
Build it from scratch by creating discrete wealth-time grids and evaluating state transitions for allocation decisions.

Read how Build a Robo-Advisor with Python (From Scratch) explains state →

Modern C

Hidden state is execution state that affects program behavior but is not directly represented as an ordinary program value.

How it is used
Frames C execution as changes to values, execution points, stored data, intermediate values, and hidden state.
How deep it goes
Defines state composition and effects, then works through pointer aliasing and concurrency without fully resolving multithreaded observability.
Examples
Uses pointer mutation, aliased arguments, function calls, void expressions, recursive calls, locks, once_flag, and atomic_flag.
What you can do after
Diagnose/debug state changes by tracking object locations, pointer aliasing, execution points, side effects, and synchronization state.

Read how Modern C explains state →

Data-Oriented Programming in Java

The data values that describe the current condition of an object or entity.

How it is used
Clarifies hidden business meaning in object fields and supplies a basis for data-oriented domain modeling.
How deep it goes
Explains state through identity, immutable values, and transitions, while deferring implementation details during early domain design.
Examples
Uses Java fields, Customer objects, Vector values, Ball frames, and state-driven test data.
What you can do after
Build it from scratch as immutable values and functions that transform explicit current states into next states.

Read how Data-Oriented Programming in Java explains state →

Apache Kafka in Action

Current state is the complete information representing the present condition of a system or entity.

How it is used
Represents an object’s complete condition in a Kafka message or a service’s current view derived from history.
How deep it goes
Defines complete state messages and explains reconstruction costs, but defers log-compaction details.
Examples
Uses product price and stock messages, a machine’s latest status, and a customer’s account balance.
What you can do after
Evaluate/understand it: distinguish complete state from changes and assess when reconstructing current state from Kafka history is costly.

Read how Apache Kafka in Action explains state →

Refactoring to Rust

State is data representing the current condition of a component or application.

How it is used
Tracks paginated article data and fetch status in React and Yew UI components.
How deep it goes
Defines state through working React and Yew examples, including initialization, updates, and rendering.
Examples
Uses a paginated article list and Yew fetch states for fetching, success, and failure.
What you can do after
Apply state through React hooks or Yew component methods to update and render a paginated article feed.

Read how Refactoring to Rust explains state →

The Well-Grounded Rubyist, Fourth Edition

State is the information and data associated with an object that represents its current properties or condition.

How it is used
Represents an object’s current information and supports distinguishing, updating, and querying individual instances.
How deep it goes
Explains instance-variable storage, initialization, access methods, persistence, and state removal in favor of pure functions.
Examples
Uses Person and Ticket objects, then contrasts a stateful Grade and ReportCard design with a stateless grading system.
What you can do after
Build it from scratch by defining, initializing, retrieving, modifying, or deliberately removing object state.

Read how The Well-Grounded Rubyist, Fourth Edition explains state →

Platform Engineering on Kubernetes

Application state is the data that represents an application's current condition and must persist across requests or component executions.

How it is used
Uses state management to determine whether Kubernetes services can scale replicas while preserving consistent application behavior.
How deep it goes
Explains external stores, in-memory limitations, connection pools, and sessions, but stops short of implementing session replication.
Examples
Demonstrates Conference Agenda replicas backed by Redis and contrasts them with agenda data kept in pod memory.
What you can do after
Diagnose scaling problems by comparing replica behavior, external persistence, database connections, and in-memory data.

Read how Platform Engineering on Kubernetes explains state →

Context Engineering

Information representing a system's current situation or progress.

How it is used
Tracks the current operational status of an agent, its task, and its environment across workflow steps.
How deep it goes
Explains state categories, representations, and update mechanisms, and identifies propagation, selection, and persistence as management operations.
Examples
Illustrates a Tokyo travel-planning state object and a payment-status update after tool execution.
What you can do after
Evaluate/understand it by comparing state representations and update strategies for agent workflows.

Read how Context Engineering explains state →

Automating API Delivery

The actual state is the configuration state that an API system currently has in operation.

How it is used
Uses actual state to monitor and control the configuration currently deployed in API gateway environments.
How deep it goes
Explains state reconciliation, drift detection, automatic correction, versioning, review, and rollback, but not implementation internals.
Examples
Demonstrates API gateway UI changes, environment repositories, Git pull requests, deployment pipelines, and reconciliation agents.
What you can do after
Operate/configure API gateway deployments by detecting drift and restoring actual configuration from reviewed Git declarations.

Read how Automating API Delivery explains state →

Timeless Algorithms, The Foundational Ideas

A representation of a problem configuration that captures information needed to determine subsequent choices and outcomes.

How it is used
Identifies the information needed to distinguish dynamic-programming subproblems and connect them systematically.
How deep it goes
Works through state definitions, transitions, and base cases across problems, showing that formulations depend on the task.
Examples
Uses item count and capacity in knapsack, and target amount in coin change, to illustrate alternative state representations.
What you can do after
Apply dynamic programming by specifying states, transitions, and base cases for a problem.

Read how Timeless Algorithms, The Foundational Ideas explains state →

Healthcare IT

A workflow state is the condition or status of a workflow entity at a particular point in its lifecycle.

How it is used
Coordinates clinical responsibilities, tasks, and recorded data as an EHR advances work through a workflow.
How deep it goes
Explains state through event-level transitions, associated data, actors, and patient identifiers using a CBC workflow.
Examples
Uses a CBC order moving from signed to active and a specimen moving from pending through analysis readiness.
What you can do after
Apply state transitions to model clinical events with responsible actors, captured data, and patient-linked workflow history.

Read how Healthcare IT explains state →

Vanilla Web

Data representing an application's current condition and behavior.

How it is used
Keeps changing application data available for predictable UI updates without a framework runtime.
How deep it goes
Defines state alongside derived data and effects, then implements a state object, form handlers, rendering, and optional microtask batching.
Examples
Uses a product-filter form with a search query, availability checkbox, product count, and rendered list.
What you can do after
Build it from scratch with a plain state object, input handlers, derived values, and a render function.

Read how Vanilla Web explains state →

Building Specialized AI Systems

A hidden state is an intermediate vector that stores a sequence model's accumulated representation of preceding inputs.

How it is used
Represents accumulated context in recurrent sequence processing and transfers the encoder’s compressed input representation to the decoder.
How deep it goes
Explains token-level updates, encoder-decoder roles, and fixed-size compression, but does not derive the underlying neural computations.
Examples
Uses encoder-decoder language translation to show sequential encoding, decoder generation, and information loss for long sequences.
What you can do after
Evaluate how recurrent models preserve context and diagnose information loss caused by compressing long inputs into one final state.

Read how Building Specialized AI Systems explains state →

Deep Learning with R, Third Edition

A neural-network state is an internal representation that carries information from earlier sequence elements to later processing steps.

How it is used
Carries sequence history through recurrent processing and supports autoregressive prediction one token at a time.
How deep it goes
Explains initialization, recurrent updates, explicit propagation, and sequence resets, without deriving training dynamics or long-term memory limitations.
Examples
Uses a toy RNN loop, an R implementation, and Shakespeare character generation with a prompted GRU state.
What you can do after
Build it from scratch with an RNN loop and propagate an explicit GRU state during token-by-token generation.

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

Grokking AI Algorithms, Second Edition

A state is a configuration of the environment at a particular point in an agent's interaction with it.

How it is used
Represents candidate solutions in genetic algorithms and the environment configuration an agent encounters as it acts.
How deep it goes
Defines state as a data structure and illustrates binary encoding and simulator state retrieval without developing formal state-space theory.
Examples
Uses binary item choices in the Knapsack Problem and an agent moving through a parking-lot environment.
What you can do after
Understand how binary item choices encode candidate solutions and how simulator state changes as an agent acts.

Read how Grokking AI Algorithms, Second Edition explains state →

Web Component Development with Modern Libraries and Tooling

The current data held by a component or application that can influence its behavior or rendered output.

How it is used
Coordinates data shared by multiple web components without prop drilling through their hierarchy.
How deep it goes
Explains initialization, reactive updates, bindings, persistence, named access, and subscriptions through small component examples.
Examples
Uses synchronized greeting and labeled-input components, reset buttons, shared name values, and a state-change subscription.
What you can do after
Build shared component data with FAST state objects or WrecState bindings, including updates, resets, persistence, and subscriptions.

Read how Web Component Development with Modern Libraries and Tooling explains state →

Grokking AI Applications

The stored sequence of prior user inputs and model outputs that represents an ongoing conversation.

How it is used
Maintains conversational context by storing and forwarding prior user messages and model outputs across requests.
How deep it goes
Defines the storage-and-forward operation but defers its implementation details.
Examples
Uses an ongoing chat where subsequent requests receive earlier user messages and model outputs.
What you can do after
Operate applications that preserve conversational context across requests.

Read how Grokking AI Applications explains state →

Kafka Streams in Action, Second Edition

State is retained information representing the accumulated condition or progress of a stream-processing computation.

How it is used
Tracks information or progress across related events in Kafka Streams.
How deep it goes
Defines state through keyed retrieval, updating, initialization, and reduction, while pointing toward state stores, joins, and timestamps.
Examples
Uses widget counting and per-player poker-score accumulation to demonstrate keyed state and reduction.
What you can do after
Apply it via Kafka Streams to aggregate keyed events and retain results across an unbounded stream.

Read how Kafka Streams in Action, Second Edition explains state →

Causal AI

A state is the representation of an agent's situation that determines the relevant decision and future dynamics in a sequential decision process.

How it is used
Represents the agent’s current decision context within a Markov decision process.
How deep it goes
Defines states, formalizes their transition kernel, and connects Markov assumptions to causal DAG reasoning.
Examples
Uses reachable grid cells, obstacles, terminal cells, latent states, and observed states as concrete representations.
What you can do after
Evaluate/understand sequential decision models and formulate causal queries involving observed or unobserved states.

Read how Causal AI explains state →

Road to Kubernetes

State is the persistent data or condition that determines how software behaves across operations or restarts.

How it is used
Frames deployment decisions around whether application data must survive destroyed machines or containers.
How deep it goes
Demonstrates persistence through database backups, Docker volumes, environment variables, and Ansible desired-state reporting.
Examples
Uses database data, recreated Python and Node.js environments, an interactive NGINX container, Docker volumes, and Ansible tasks.
What you can do after
Operate/configure containers with volumes and environment variables, and distinguish reproducible stateless workloads from persistent stateful services.

Read how Road to Kubernetes explains state →

Code Like a Pro in Rust

Global state is data accessible across an application's execution context rather than owned by a single local scope.

How it is used
Handles shared fixtures and global test state under Cargo's parallel unit-test execution.
How deep it goes
Explains unsafe mutable statics, atomics, Arc initialization limits, lazy_static, and mutex-based serialization.
Examples
Uses a mutable static counter, AtomicI32, Arc, lazy_static, and Mutex-protected tests as implementation examples.
What you can do after
Operate shared test state safely with atomics, lazy_static initialization, or mutex guards.

Read how Code Like a Pro in Rust explains state →

Transformers in Action

A state is a representation of the situation in a decision process that provides the information relevant to selecting an action.

How it is used
Represents decision situations for selecting actions and preserves sequence context during recurrent processing.
How deep it goes
Defines states and illustrates recurrent updates, without descending into implementation details of state representations.
Examples
Uses a dog navigating obstacles and an encoder-decoder translation workflow to make states concrete.
What you can do after
Evaluate how current situations guide agent actions and how recurrent processing carries context across sequence items.

Read how Transformers in Action explains state →

Amazon Web Services in Action, Third Edition: An in-depth guide to AWS

A state is a distinct condition of a process in a state machine that determines which transitions are possible.

How it is used
Models completed process stages so fault-tolerant applications can control transitions and recover from failures.
How deep it goes
Defines finite-state behavior and demonstrates DynamoDB checks, updates, and SQS messaging, without covering exhaustive workflow states.
Examples
Uses Created, Uploaded, and Processed image states plus EC2 stopping and termination as operational state examples.
What you can do after
Build it from scratch by defining permitted states, validating transitions, persisting updates, and retrying idempotent operations.

Read how Amazon Web Services in Action, Third Edition: An in-depth guide to AWS explains state →

Build Financial Software with Generative AI (From Scratch)

React state is dynamic data associated with a component that can affect its behavior and rendering.

How it is used
Uses dynamic component data to explain how React UI behavior and rendering can change.
How deep it goes
Defines state as dynamic component information and links it to behavior and rendering, without showing its implementation.
What you can do after
Understand how dynamic information within a component can change behavior and trigger rendering.

Read how Build Financial Software with Generative AI (From Scratch) explains state →

Learn Haskell by Example

Program state is the collection of values and conditions describing a computation at a particular point during its execution.

How it is used
Frames state as the source of hidden complexity that complicates reasoning about program correctness.
How deep it goes
Defines state through variables and execution context, then explains its dependencies using a concrete recipe analogy.
Examples
Uses variables, execution environments, and chocolate-cake preparation to make state and state dependencies concrete.
What you can do after
Evaluate how changing data and execution context affect program behavior, and recognize why minimizing state can simplify reasoning.

Read how Learn Haskell by Example explains state →

LLMs in Production

A hidden state is an internal representation produced by a sequence model that summarizes information processed up to a position or layer.

How it is used
Uses hidden state to carry sequence context into the next prediction or classification decision.
How deep it goes
Defines probabilistic and neural state, demonstrates implementations, and discusses vanishing and exploding gradients in recurrent processing.
Examples
Uses next-token generation, sentiment classification, tokenized documents, and RNN or LSTM implementations as concrete examples.
What you can do after
Build it from scratch using a Markov generator or inspect recurrent implementations that maintain state across tokens.

Read how LLMs in Production explains state →

Essential TypeScript 5, Third Edition

Component state is data maintained by a user-interface component whose changes can trigger a re-render.

How it is used
Manages component-local values that change through user interaction and cause React content updates.
How deep it goes
Explains typed class state, setState, and useState with a quantity example, but does not descend into React lifecycle internals.
Examples
Uses a product item whose select control changes a numeric quantity before an Add To Cart callback runs.
What you can do after
Apply state via typed class components with setState or functional components with useState and an updater function.

Read how Essential TypeScript 5, Third Edition explains state →

Machines that Think

A computational state is a structured snapshot of the entities, relations, or conditions relevant to a task at a particular time.

How it is used
Contrasts static neural network representations with the evolving state needed to track entities and changing situations.
How deep it goes
Traces the limitation to nonpersistent representations and identifies evolving entity relations, but does not explain an implementation.
Examples
Contrasts human concepts grounded in perception and action with patterns learned from text, images, and other indirect records.
What you can do after
Evaluate why learned representations do not by themselves constitute a persistent model of entities and their interactions.

Read how Machines that Think explains state →

Designing AI Systems

Actual state is the observed condition of a deployed workload and its running instances.

How it is used
Tracks whether deployed workflow instances match operational expectations and whether traffic can be routed safely.
How deep it goes
Distinguishes desired and actual replicas, healthy endpoints, and lifecycle status, but does not detail container internals.
Examples
Uses current_replicas, desired_replicas, healthy_endpoints, and deploying, healthy, or failed statuses.
What you can do after
Operate/configure deployments by checking status, replica counts, readiness, and routable endpoints.

Read how Designing AI Systems explains state →

Also covered in

What to know first

Related concepts

Questions about state

What is state?

State is information describing the condition or configuration of a system or computation at a particular time that may influence its behavior or subsequent transitions.

Which Manning books explain state?

React Quickly, Second Edition, Build a Frontend Web Framework (From Scratch), Applied Reinforcement Learning, Natural Language Processing in Action, Second Edition, Hacking Cryptography, Functional Programming in Scala, Second Edition, Rust Servers, Services, and Apps, Build Python Web Apps with Streamlit and 44 more.

What should I know before learning state?

Manning books that teach state usually introduce language model, array, Map and function first.

What is the difference between state and immutable collection?

State is information describing the condition or configuration of a system or computation at a particular time that may influence its behavior or subsequent transitions. An immutable collection is a collection whose contents cannot be changed after it is created.

What kinds of state are there?

Kinds of state include list.

What is state part of?

State is part of recurrent neural network. A recurrent neural network is a neural network that processes ordered inputs while carrying and updating an internal state across successive steps.

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.