Reactive Programming

What Is Reactive Programming?

Reactive programming is a declarative programming paradigm centered around data streams and the propagation of change.

Instead of manually pulling or polling data, you react to data as it arrives.

It’s about defining what should happen when a data source emits new values over time, rather than how to do it step-by-step.

1. Key Concepts

a. Data Streams

Anything that changes over time can be represented as a stream:

UI events (clicks, keystrokes)
API responses
WebSocket data
Sensor inputs
Stock price updates

b. Observers and Observables

Observable: Emits values over time
Observer: Listens to observable and reacts to those values

[observable] → emits → [observer] → reacts

c. Operators

Functions that transform, filter, combine, or throttle stream data (e.g., map, filter, merge, debounce).

2. Reactive vs Imperative Code

Imperative Style (manual updates):

button.addEventListener("click", () => {
  fetchData().then(data => display(data));
});

Reactive Style:

fromEvent(button, 'click')
  .pipe(
    switchMap(() => fetchData())
  )
  .subscribe(data => display(data));

In reactive code, we declare relationships between events, not control flow.

3. Benefits of Reactive Programming

Benefit	Description
Asynchronous by design	Built to handle async events and streams
Decoupled logic	Producers and consumers don’t need to know about each other
Declarative syntax	Focus on what, not how
Better scalability	Efficient use of threads and CPU via non-blocking I/O
Resilient design	Built-in error handling and retry mechanisms

4. Reactive Programming vs Functional Programming

While both are declarative, reactive programming focuses on data over time, while functional programming focuses on pure functions and immutability.

They’re often used together (e.g., RxJS, Reactor, RxJava use functional operators like map, reduce).

5. Popular Libraries & Frameworks

Language	Library/Framework
JavaScript	RxJS (Reactive Extensions for JS)
Java	RxJava, Reactor (Spring)
Kotlin	kotlinx.coroutines Flow
Python	RxPY
.NET	Reactive Extensions (Rx.NET)
Scala	Akka Streams, Monix
Rust	futures-rs, tokio streams

6. Example: RxJS in JavaScript

import { fromEvent } from 'rxjs';
import { debounceTime, map } from 'rxjs/operators';

const searchBox = document.getElementById('search');

fromEvent(searchBox, 'input')
  .pipe(
    debounceTime(300),
    map(event => event.target.value)
  )
  .subscribe(value => performSearch(value));

Explanation:

fromEvent turns DOM events into a stream
debounceTime waits before firing (throttling)
map transforms the event
subscribe consumes the final output

7. Backpressure Handling

Backpressure occurs when the data producer emits values faster than the consumer can process them.

Reactive libraries offer:

Buffering
Dropping
Throttling
Windowing
Request limits (request(n) in Reactive Streams spec)

8. Reactive Streams Specification (JVM)

A standard for asynchronous stream processing with non-blocking backpressure.

Key interfaces:

Publisher
Subscriber
Subscription
Processor

Supported by:

Project Reactor
Akka Streams
RxJava 3 (partially)

9. Core Operators

Operator	Purpose
`map`	Transform each value
`filter`	Only pass values that match
`merge`	Combine multiple streams
`switchMap`	Cancel previous and switch to new observable
`debounceTime`	Wait for user pause before emitting
`distinctUntilChanged`	Avoid duplicate emissions
`catchError`	Handle stream errors gracefully

10. Use Cases for Reactive Programming

Domain	Use Case
UI Development	Responsive, event-driven user interfaces
IoT & Sensors	Real-time data processing
Real-Time Apps	Chat, stock tickers, sports updates
Microservices	Reactive APIs and messaging (e.g., WebFlux)
Streaming Pipelines	Dataflow systems like Kafka, Flink
Games	Event-based logic, animation streams

11. Reactive Programming vs Multithreading

Aspect	Reactive Programming	Multithreading
Abstraction	Streams and operators	Threads and synchronization
Performance	Scales well via non-blocking I/O	Can be CPU-intensive
Complexity	Logical flow + operators	Race conditions and locks
Thread Usage	Often single-threaded + event loop	Multiple OS threads

Reactive systems rely heavily on event loops, not context switching.

12. Reactive Architectures

Modern frameworks like Spring WebFlux, Vert.x, and Node.js follow reactive design principles:

Non-blocking I/O
Message-driven communication
Backpressure-aware flows
Elastic and resilient systems

These systems scale naturally under load without spawning excessive threads.

Summary

Feature	Description
Core Idea	Code reacts to data streams over time
Syntax Style	Declarative, operator-based
Best For	Async, event-driven, streaming applications
Languages	JavaScript, Java, Kotlin, Python, .NET, Scala
Key Libraries	RxJS, RxJava, Reactor, Flow, Akka Streams
Challenges	Steep learning curve, debugging, mental model shift