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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Also covered in
- React Hooks in Action: With Suspense and Concurrent Mode
- Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
- 100 Java Mistakes and How to Avoid Them
- Tiny Python Projects: Learn coding and testing with puzzles and games
- Software Design for Python Programmers
- Python How-To
- Object-Oriented Software Design in C++
- Unit Testing Principles, Practices, and Patterns
- Elixir in Action, Third Edition
- The Quick Python Book, Fourth Edition
- Robotics for ProgrammersIn early access (MEAP)
- Deep Learning with JAX
What to know first
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- arrayAn array is an ordered collection of elements organized in one or more dimensions and accessible by position or index.
- MapA map is an associative data structure that stores key-value associations and supports retrieving values by key.
- functionA function is a callable unit of program code that performs a computation or operation, can accept inputs, and may produce a result or side effect.
Related concepts
- immutable collectioncontrasts with · An immutable collection is a collection whose contents cannot be changed after it is created.
- accessor methodused by · An accessor method or function is a callable that reads, computes, or assigns a value associated with a property, field, or data element.
- listincludes · A list is an ordered collection of elements arranged in a sequence.
- recurrent neural networkpart of · A recurrent neural network is a neural network that processes ordered inputs while carrying and updating an internal state across successive steps.
- reduction operationused by · A reduction operation combines multiple input values according to a rule to produce fewer results, often a single aggregate.
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.



















































