Reactive programming
Reactive programming is a paradigm in which computations are expressed through data flows and automatically respond to changing values or events, often arriving asynchronously.
Functional Programming in JavaScript
A programming paradigm centered on data flows and propagation of change, especially for responding to asynchronous or event-driven updates.
- How it is used
- Unifies asynchronous and event-based data providers into observable streams that can be transformed and subscribed to.
- How deep it goes
- Explains observable streams and pipelines with map, filter, subscription, errors, completion, and asynchronous flattening without detailing implementation internals.
- Examples
- Uses number ranges, generated squares, SSN input validation, and filtering U.S. students returned from a JSON request.
- What you can do after
- Apply it via RxJS to transform event, promise, collection, and service-call values through observable pipelines.
Read how Functional Programming in JavaScript explains reactive programming →
Quarkus in Action
Reactive programming is a programming paradigm centered on asynchronous data streams and the propagation of changes over time.
- How it is used
- Uses asynchronous, nonblocking execution to keep I/O-heavy Quarkus applications responsive under load.
- How deep it goes
- Explains continuations and event-loop request handling, then connects them to reactive database access and pipeline types.
- Examples
- Contrasts blocking and nonblocking I/O handling and uses Hibernate Reactive database access to illustrate asynchronous results.
- What you can do after
- Apply it via Quarkus and SmallRye Mutiny to build nonblocking pipelines while keeping blocking work off event-loop threads.
Spring Start Here, Second Edition
A reactive approach structures asynchronous operations around nonblocking results and declared dependencies.
- How it is used
- Frames reactive programming as an approach for handling asynchronous work and calling REST endpoints in reactive applications.
- How deep it goes
- Explains task dependencies, thread use, and subscription flow, while recommending deeper study before implementation.
- Examples
- Uses a banking debt calculation and a WebClient payment request to illustrate blocking and reactive task execution.
- What you can do after
- Evaluate whether WebClient suits a reactive app or RestClient and OpenFeign suit a nonreactive app.
Read how Spring Start Here, Second Edition explains reactive programming →
Spring in Action, Sixth Edition
Reactive programming is a programming approach based on asynchronous processing of data streams and the propagation of change over time.
- How it is used
- Introduces reactive programming as an alternative to imperative processing and a foundation for Spring’s reactive web support.
- How deep it goes
- Explains incremental pipelines and core Reactor types through a greeting, deferring detailed treatment of individual operations.
- Examples
- Uses a newspaper subscription analogy and contrasting Java greeting implementations to illustrate incremental processing and pipelines.
- What you can do after
- Evaluate reactive pipelines by contrasting their data flow with imperative steps and recognizing when reactive programming may be appropriate.
Read how Spring in Action, Sixth Edition explains reactive programming →
Modern Angular
Reactive programming is a programming technique that expresses computation in terms of asynchronous data streams and the propagation of changes.
- How it is used
- Frames Angular frontend behavior as state changes propagated from asynchronous events into rendered UI.
- How deep it goes
- Defines state, UI, events, and pull-versus-event-driven behavior, then points toward RxJS without detailing operator internals.
- Examples
- Uses a counter component, a synchronous data pull, and a click-event listener to contrast state-driven and event-driven behavior.
- What you can do after
- Apply reactive programming in Angular with RxJS, including observable cleanup and dependency-aware custom operators.
Spring Security in Action, Second Edition
Reactive programming is a programming paradigm based on asynchronous processing of streams of data and events, typically to support nonblocking and concurrent execution.
- How it is used
- Supports Spring Security application development when asynchronous, fragmented processing changes how authentication and authorization operate.
- How deep it goes
- Defines incremental processing and demonstrates a Mono endpoint, while deferring detailed reactive application study.
- Examples
- Uses incremental file uploads, a milk-factory analogy, a Mono-based HelloController, and publisher-subscriber streams.
- What you can do after
- Build a simple Spring WebFlux endpoint and recognize when reactive processing may improve delivery of fragmented results.
Read how Spring Security in Action, Second Edition explains reactive programming →
Vanilla Web
Reactivity is a programming model in which changes to data automatically propagate to dependent computations or interface output.
- How it is used
- Keeps a Vanilla application's interface synchronized with changing data.
- How deep it goes
- Defines state, derived data, and effects, then surveys binding patterns without prescribing one implementation.
- Examples
- Uses count and query/product state, computed todo counts and totals, and user input flowing between state and the DOM.
- What you can do after
- Apply it via browser events and DOM updates to keep data and interface synchronized with a chosen small pattern.
Functional Design and Architecture: Examples in Haskell
Reactive programming is a programming technique for expressing computations that respond to continuously arriving events or changing data.
- How it is used
- Organizes formulas and stateful applications around continuously arriving data and changing environmental conditions.
- How deep it goes
- Defines the motivating principle and surveys actors, streams, event models, protocols, MVars, STM, and message queues without detailed implementation.
- Examples
- Uses spacecraft motion, fuel, and interconnected-system formulas as the central domain example.
- What you can do after
- Evaluate reactive designs by comparing actors, streams, event models, MVars, STM, and message queues.
Read how Functional Design and Architecture: Examples in Haskell explains reactive programming →
Also covered in
- Knowledge Graphs and LLMs in Action
- Inside AI
- Functional Programming in C#, Second Edition
- Web Component Development with Modern Libraries and ToolingIn early access (MEAP)
- Building User-Friendly DSLs
- Pro Angular 16
What to know first
- stateState is information describing the condition or configuration of a system or computation at a particular time that may influence its behavior or subsequent transitions.
- imperative programmingImperative programming is a programming paradigm that expresses computation as ordered commands or instructions that direct execution or change state.
- asynchronous programmingAsynchronous programming structures operations so that the initiating execution can continue or yield control without synchronously waiting for each operation to complete.
- Document Object ModelThe Document Object Model is a platform-independent programming interface that represents a document as a structured tree of nodes and provides ways to access and modify its content and structure.
Related concepts
- imperative approachcontrasts with · An imperative approach processes a bulk of available data as a whole rather than incrementally as data arrives.
- imperative programmingalternative to · Imperative programming is a programming paradigm that expresses computation as ordered commands or instructions that direct execution or change state.
- Project Reactorused by · Project Reactor is a JVM reactive programming library providing asynchronous, nonblocking types and operators for composing data sequences with backpressure.
- push modeluses · A push model is a communication pattern in which a producer or system initiates delivery of data, messages, work, or updates to consumers without waiting for them to request each transfer.
- Quarkus platformused by · Quarkus is a Java framework for building cloud-native applications, optimized for containerized environments, fast startup, and low memory use.
Questions about reactive programming
What is reactive programming?
Reactive programming is a paradigm in which computations are expressed through data flows and automatically respond to changing values or events, often arriving asynchronously.
Which Manning books explain reactive programming?
Functional Programming in JavaScript, Quarkus in Action, Spring Start Here, Second Edition, Spring in Action, Sixth Edition, Modern Angular, Spring Security in Action, Second Edition, Vanilla Web and Functional Design and Architecture: Examples in Haskell.
What should I know before learning reactive programming?
Manning books that teach reactive programming usually introduce state, imperative programming, asynchronous programming and Document Object Model first.
What is the difference between reactive programming and imperative approach?
Reactive programming is a paradigm in which computations are expressed through data flows and automatically respond to changing values or events, often arriving asynchronously. An imperative approach processes a bulk of available data as a whole rather than incrementally as data arrives.
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.







