liveBook · Manning

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.

How 8 Manning books explain it

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.

Read how Quarkus in Action explains reactive programming →

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.

Read how Modern Angular explains reactive programming →

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.

Read how Vanilla Web explains reactive programming →

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

What to know first

Related concepts

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.