Reactive Programming in Java using RXJava 3.x - ReactiveX

Expose the contrast between sync and async execution, explain asynchrony via concurrency, and show how callbacks become hard with many events, while RxJava simplifies concurrency and completion signals.

Explore callbacks in asynchronous programming with a simple thread example, highlighting callback hell and how rx java and the observer pattern simplify callback management.

Explore how the observer design pattern in RxJava builds one-to-many dependencies where a subject notifies registered observers of state changes, with subscribe, unsubscribe, and update actions in a library example.

Compare observable and observer concepts in RxJava 3.x, showing push-based data flow and the subscribe lifecycle with onNext, onComplete, and onError events.

Learn how connectable observables convert a cold observable into a hot multi-cast stream, so multiple subscribers receive emissions simultaneously, with late subscribers starting from current emission, illustrated using interval.

Explore rxjava's merge and concat for combining emissions from multiple observables; merge interleaves outputs while concat preserves order, with overloads for two to four sources and interval-based demos.

Compare zip and combine latest in rxjava, showing how zip pairs emissions from two observables using a zipper function, while combine latest merges on the latest emissions from each source.

Group by groups employees by a rating key into grouped observables, then convert each group to a map of rating to names using flatMap and a multi-map collector.

Explore how to combine observable emissions in RxJava 3.x using merge, concat, flatMap, concatMap, amb, zip, combineLatest, and groupBy.

Explore the five RxJava subject implementations - publish, replay, behavior, async, and unicast - showing how each emits data at subscription, caches items, or releases the last value after completion.

Explore RxJava 3.x reactive concepts: replay and cache operators, connectable vs observable, and subjects including publish, behavior, replay, async, and unicast, with multicast and emission management, ahead of concurrency topics.

Explore how to inject concurrency into RxJava programs by using threads and runnables, while preserving the observable contract and learning how schedulers enable asynchronous task execution.

ObserveOn switches to a different scheduler in the chain, affecting downstream while upstream remains unchanged. It can cause a producer-consumer gap, prompting the use of flowable and back pressure.

Learn how to create a flowable with a back pressure strategy in RxJava 3.x, exploring buffer, drop, latest, error, and missing, and why backpressure matters.