This document discusses reactive systems and programming. It begins with an introduction to reactive systems and programming, explaining the difference between the two. It then discusses why reactive systems are useful, covering topics like efficient resource utilization. The document goes on to explain key concepts like observables, backpressure, and reactive libraries. It provides examples of reactive programming with Spring Reactor and reactive data access with Couchbase. Overall, the document provides a high-level overview of reactive systems and programming concepts.

1. Reactive Systems
Naresh Chintalcheru

2. Agenda
Part - 1
● Intro to Reactive Systems
● Reactive Programming Vs Reactive Systems
● Why Reactive Systems
● Side-effects
● Reactive Data Access
Part - 2
● Workshop

3. Programming puzzle

4. Programming puzzle
a = 1;
b = a + 1;
a = 2;
print a; ---> 2
print b; ---> ?

6. Programming puzzle
a = 1;
b = a + 1;
a = 2;
print a; ---> 2
print b; ---> ?
2 or 3

7. Programming puzzle
a = 1;
b = a + 1;
a = 2;
print a; ---> 2
print b; ---> ?
2 3

8. Programming puzzle
a = 1;
b = a + 1;
a = 2;
print a; ---> 2
print b; ---> ?
2 3
Imperative Reactive

9. Reactive Programming Interface

10. Reactive Programming
Programming paradigm oriented around data flows and propagation of change
-Wiki
Functional programming with asynchronous data streams

11. Functional Reactive Programming
● Reactive programming is based on the functional constructs
● Functional programming principles are essential in understanding RP
● Functional programming provides Declarative, Composable and Concurrent
code
● Learn to replace loops with recursion, traverse data structures without iterators,
do input/output using monads, and dealing with Immutable data sources.
● Exceptions are side-effects that undermine type system and functional purity

12. Functional Programming
● Pure Functions, Higher-Order Functions, Monads, Currying and Immutable data
● Pure functions does not have side-effects, for a given inputs it always have same
output, e.g., mathematical functions
● Higher-Order Functions, functions which takes at least one more functions as
parameters and return a function (e.g., Lambds’s)
● Monads wraps data value and provide series of computational operators (e.g.,
Streams/Optional)
● Currying is technique of translating the evaluation of a function that takes
multiple arguments into evaluating a sequence of functions, each with a single
argument

13. Reactive Programming
Rx = Observable + Observer + Scheduler

14. Observable
Observable is the combination of GOF's Observer and Iterable pattern
● The ability of consumer to push elements to consumer
● The ability for the producer to signal to the consumer that there is no more data
available.
● The ability for the producer to signal to the consumer that an error has
occurred.

15. Reactive Programming
● Reactive applications use observable models, event
streams and stateful clients.
● Observable models enable other systems to receive events
when state changes.

16. Polyglot Reactive Libraries
Rx.Net, RxJava, RxJS, RxScala, RxSwift, RxRuby, RxPHP

17. Reactive Programming
● Imperative programming is a Pull model (hasNext, Next)
● Reactive programming is Push model, the elements will be pushed down the
stream as soon as they are available
● Difference is the direction of the data flow

18. Pull model & Thread Block
Consumer pulls values from the producer and the thread is blocked in the pull model
until the elements arrive.

19. Reactive streams
● Mouse and Keyboard interaction
● Stock Prices
● System Events

20. Reactive Programming vs Reactive Systems

21. Reactive Manifesto 2.0

22. Reactive Programming vs Reactive Systems
Reactive programming is about Data Flows and Change propagation
Reactive System is about Message-driven based Control Flows and System
responsiveness even under load (Scalability) or partial failure (Resilient)

23. Why Reactive Systems ?

24. Why Reactive
● The driver for Reactive is the efficient resource utilization, or in other words,
spending less money on servers and data centres
● The promise of Reactive is that you can do more with less, specifically you can
process higher loads with fewer threads
● Stagnation in CPU Clock Speed 4GHz
● Highest clock speeds requiring cooling through liquid nitrogen are stuck
between 8.5 and 9 GHz

25. Why Reactive
● Increased investments in parallelism for both - hardware and software
● Parallelism in hardware with Multicore processors
● Software OS support for Non-Blocking I/O
○ Linux Kernel 2.6 release in 2006, Support Asynchronous I/O, POSIX AIO API
● Rise of functional programming and Concurrency
● Cloud computing costs, microservices latency makes Reactive programming a
good choice

26. Benefits Reactive Streams
- Efficient in handling of system resources using
asynchronous Non-Blocking I/O
- Cost effective in Cloud
- Reactive streams are designed to solve the central issue
with asynchronous programming Backpressure
- Individual Stream items can be on specialized hardware
(GPU, APU, RDMA)
Remote Direct Memory Access (RDMA) is a technology that allows computers in a network to exchange data in main memory without
involving the CPU

27. Backpressure
What is Backpressure ?

28. What is Backpressure
Observable is emitting items more rapidly than an operator or
observer can consume.

29. Backpressure Overflow Strategy
FluxSink.OverflowStrategy.BUFFER
Buffer all signals if the downstream can't keep up
FluxSink.OverflowStrategy.DROP
Drop the incoming signal if the downstream is not ready to receive it
FluxSink.OverflowStrategy.ERROR
Signal an IllegalStateException when the downstream can't keep up
FluxSink.OverflowStrategy.IGNORE
Completely ignore downstream backpressure requests
FluxSink.OverflowStrategy.LATEST
Downstream will get only the latest signals from upstream

30. Node.js & Reactive Programming
● Node runs on single thread and excellent choice for I/O based processing
● Node supports Streams similar to Java but imperative streams. The data flows
and change propagation are missing
● Libraries just RxJS, bacon.js add reactive abstraction over Node.js

31. Reactive Libraries on JVM
● RxJava
● Spring Reactor
● Vert.x
● Java v9 Flow APIs

32. How Reactive Libraries Work
● Graph Processing algorithm that captures the
dependencies among the reactive values and the language
runtime uses the graph to keep track of which
computations must be executed again when one of the
inputs changes
● Change propagation techniques Pull, Push or Hybrid

33. Reactive Stream Specification (RS)
Reactive Streams standard for Asynchronous Stream processing with Non-blocking
Back Pressure
Runtime environments (JVM and JavaScript) as well as network protocols
www.reactive-streams.org

34. Spring Reactor

35. Spring Reactor Architecture

36. Reactor Types
Reactor supports two types
● Flux<T>
● Mono<T>

37. Flux (Publisher/Observable)
Flux is a Reactive Streams Publisher with rx operators that emits 0 to N elements,
and then completes (successfully or with an error).
Observer subscribes to an Observable, Observer reacts/operates to item or
sequence of items the Observable emits

38. Mono (Publisher/Observable)
Mono is a Reactive Streams Publisher with rx operators that emits 0 to 1 elements,
and then completes (successfully or with an error)

39. Reactor code

40. Reactor code

41. Reactor code

42. Reactor code

43. Reactor code

44. Non-Blocking
ParallelFlux<T> parallel()
Prepare to consume this Flux on number of 'rails' matching number of CPU Cores
in round-robin fashion.
ParallelFlux<T> parallel(int parallelism)
Prepare to consume this Flux on parallelism number of 'rails' in round-robin fashion.
ParallelFlux<T> parallel(int parallelism, int prefetch)
Prepare to consume this Flux on parallelism number of 'rails' in round-robin fashion
and use custom prefetch amount and queue for dealing with the source Flux's
values.

45. Operators
Operators operate on Observables
Operators By Category
● Creating Observables
● Transforming Observables
● Filtering Observables
● Combining Observables
● Backpressure Observables

46. Stateful/Stateless Operators
● Stateless Operators - filter, flatMap
● Stateful Operators - Sort, Distinct

47. Streaming Database Access

48. Reactive Data Access
● Couchbase Reactive Streams Java SDK Driver, providing asynchronous
stream processing with non-blocking backpressure.
● Fully implements the Reactive Streams API for providing interop with other
reactive streams within the JVM ecosystem.

49. Reactive Data Access
List<JsonDocument> comments =
bucket
.async()
.get("post::1")
.flatMap(post -> Observable.from(post.content().getArray("comments").toList()))
.flatMap(commentId -> bucket.async().get((String) commentId))
.filter(comment -> comment.content().getBoolean("published"))
.take(2)

50. Workshop

51. Ref
https://www.ibm.com/developerworks/library/l-async/
https://projectreactor.io/docs/core/release/api/
http://reactivex.io/documentation/operators/backpressure.html
https://en.wikipedia.org/wiki/Reactive_programming