Isomorphic Reactive Programming

Isomorphic Reactive
Programming
Giorgio Natili

@giorgionatili#MobileTea + @DroidconBos
About Me
• Engineering Manager at Akamai (NG2 on desktop
and mobile)
• Founder of Mobile Tea
• Organizer of the Hash Conf
• Organizer of DroidCon Boston

Hash Conf
http://hashconf.io/

Droidcon Boston
bitly.com/dcbos18

Agenda
• Fundamentals of Reactive Programming
• Fundamentals of Reactive Extensions
• Observables, Observers and Subjects
• Reactive Extensions Operators
• Parallel Programming

Foundation
• Programming paradigm
• Computation is affected by signals
• No notion of event scope
• It favors function composition

Elasticity (in contrast to
Scalability)
• A system scales up or down automatically to meet
demand
• Elasticity builds upon scalability adding the notion
of automatic resource management

Failure (in contrast to Error)
• A failure is an unexpected event that prevents a
system from continuing to function normally
• This is in contrast with an error, which is an
expected and coded-for condition

Isolation (and Containment)
• Isolation can be deﬁned in terms of decoupling in
time and space
• Decoupling in time means that the sender and
receiver can have independent life-cycles
• Decoupling in space means that the sender and
receiver do not have to run in the same process

Message-Driven (in contrast
to Event-Driven)
• A message is an item of data that is sent to a
speciﬁc destination
• Notiﬁcation listeners are attached to event sources
such that get invoked when the event is emitted

Back-Pressure
• When one component is struggling to keep-up, the
system as a whole needs to respond in a sensible
way
• Back-pressure is an important feedback
mechanism that allows systems to gracefully
respond to load rather than collapse under it

Signals
• Functional programming ties signals together in a
dependency graph
• Each signal is either an external input or a derived
signal
• Signals feeds off of other signals that have already
been deﬁned

Advantages
• Efﬁciency, by minimizing the amount of the
computation that must be rerun when inputs
change (e.g. history)
• Dynamism by reconﬁguring the computation over
time, as the inputs to your system change
• Ease of reasoning due to a paradigm that has a
clean semantics

Streams
• Data
• I/O operations
• User interactions

Streams and Async Code
• Asynchronous code allows independent IO
operations to run concurrently
• Streams can be encapsulated in async code and
improve code efﬁciency and readability

Callback Hell

Get Out of the Callback Hell
• Abstractions that allow us to express the effect of
latency in asynchronous computations
• Encapsulate event-handling code, and use higher-
order functions such as map, reduce, and ﬁlter
• Compose clean and readable asynchronous code

Warning
• Reactive code composed with higher-order
functions is often not purely functional
• Functional reactive code typically involves side
effects through network or ﬁle system IO

Functions

Composition and Currying
• A mechanism to combine simple functions to build
more complicated ones
• Closely related to currying that instead translate a
function with multiple arguments into multiple
functions accepting one argument

Pure Functions
• In a pure functional language a function can only
read what is supplied to it in its arguments
• The only way it can have an effect on the world is
through the values it returns

Monads
“Monads are monoids in the category of
endofunctors”

Monoids
• Are the most basic way of combining values
together
• Don’t necessarily have to combine containers of
values
• Can combine any values with certain properties
• Support associativity and neutral elements (aka 0)

Isomorphic Reactive Programming

Monads
• Elegant abstractions for describing how state is
manipulated in a pure functional programming
language
• Monads apply a function that returns a wrapped
value to a wrapped value

Monads Operations
• The return operation that promotes regular values
of type A to monads M[A]
• The bind operation that takes a function A =>
M[B] that is used to transform underlying values

Practically Speaking
• Monads are wrappers around function invocations
• There are a bunch of different Monads with
identical syntax but different semantics
• Wrappers that do IO, Exceptions, Nullability, State,
Logging, Messaging, etc.

Optional<String> maybeFirstName = Optional.of("Joe");
Optional<String> maybeLastName = Optional.of("Black");
Optional<String> maybeFullName =
maybeFirstName.flatMap(firstName ->
maybeLastName.map(lastName -> firstName + " " +
lastName)
);
Monads in Java

Advantages
• Interfacing pure functional programming to the
impure dysfunctional world
• Interacting with a stateful system without
compromising functional programming semantic

Stateful and Stateless
• Stateful means the system keeps track of the state
of interaction by setting values in a sort of storage
• Stateless means there is no record of previous
interactions and each interaction request has to be
handled based entirely on information that comes
with it

Functors
• When a value is wrapped in a context, you can't
apply a normal function to it
• A Functor is any data type that deﬁnes how
functions like map applies to it
• A functor is simply something that can be mapped
over

Functors and map
fun sumThree(n: Int) = n + 3
Option.Some(2).map(::sumThree)
// => Some(5)
func plusThree(addend: Int) -> Int {
return addend + 3
}
Optional.Some(2).map(plusThree)
// => .Some(5)

Recap
• A functor is a type, denoted by Type<T>, that:
• wraps another inner type (like Array<T> or Optional<T> )
• has a method map with the signature (T->U) -> Type<U>
• A monad is a type that:
• is a functor (so it has an inner type T and a map method)
• also has a method flatMap with the signature  
(T->Type<U>) -> Type<U>

Reactive Programming
and Reactive Extensions

Reactive Extensions
• It is a set of tools allowing imperative programming
languages to operate on sequences of data
• It provides a set of sequence operators that
operate on each item in the sequence

Functional Reactive
Programming (FRP)
• It’s just another a programming paradigm
• It focuses on reacting to streams of changes (data
and events)
• It favors function composition, avoidance of global
state and side effects

Observer Pattern and
Manipulation
• FRP is based on the Observer pattern
• FRP supports manipulating and transforming the
stream of data that Observables emit

Lambdas
• A lambda expression is an anonymous function
that you can use to create delegates or expression
tree types
• Lambda functions are often arguments being
passed to higher-order functions

Subject
• A Subject is a sort of bridge that is available in
most of the implementations of ReactiveX
• It acts both as an observer and as an Observable
• It can subscribe to one or more Observables,
• Because it is also an Observable, it can pass
through the items it observes by re-emitting them

Observables
• onNext, an Observable calls this method
whenever the Observable emits an item
• onError, an Observable calls this method to
indicate that it has failed to generate the expected
data
• onCompleted, an Observable calls this method
after it has called onNext for the ﬁnal time

Push vs Pull
• Observable is push based, it decides when to
emit values
• Iterable is pull based, it sits until the some ask
for the next() value

Observable Pipelines
Observable<String> sentenceObservable =  
Observable.from("hello", "world");
Observable.subscribe(new Action1<String>() { 
@Override
public void call(String s) {
System.out.println(s);
}
});

Observing Subjects
• A professor is an observable
• A student is an observer
• A Subject emits all the subsequent items of the
source Observable at the time of subscription

Publish Subject
 
“It emits all the subsequent items of the source
Observable at the time of subscription”

 
“It emits all the items of the source Observable,
regardless of when the subscriber subscribes”
Replay Subject

Behavior Subject
 
“It emits the most recently emitted item and all the
subsequent items of the source Observable when
an observer subscribes to it”

Async Subject
 
“It only emits the last value of the source
Observable (and only the last value)”

Create
 
“By using the Create operator, you pass this
operator a function that accepts the observer as its
parameter”

Defer
 
“Do not create the Observable until the observer
subscribes, and create a fresh Observable for
each observer”

From
 
“Convert various other objects and data types into
Observables”

Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(Subscriber<? super Integer> observer) {
try {
if (!observer.isUnsubscribed()) {
for (int i = 1; i < 5; i++) {
observer.onNext(i);
}
observer.onCompleted();
}
} catch (Exception e) {
observer.onError(e);
}
}
} ).subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});

Just
 
“Converts an object or a set of objects into an
Observable that emits that or those objects”

Interval
 
“Creates an Observable that emits a sequence of
integers spaced by a given time interval”

Timer
 
“Creates an Observable that emits a particular item
after a given delay”

Map
 
Transforms the items emitted by an Observable by
applying a function to each item

FlatMap
 
Transforms the items emitted by an Observable into
Observables, then ﬂatten the emissions from those
into a single Observable

Scan
 
Applies a function to each item emitted by an
Observable, sequentially, and emit each
successive value

Buffer
 
Periodically gather items emitted by an Observable
into bundles and emit these bundles rather than
emitting the items one at a time

Window
 
Periodically subdivide items from an Observable
into Observable windows and emit these windows
rather than emitting the items one at a time

ViewObservable.clicks(view)
.map { System.currentTimeMillis() }
.slidingWindow(3)
.filter { it.get(2) - it.get(0) < 500 }
.subscribe { println("Triple tap!") }
)

Filter
 
“Emits only those items from an Observable that
pass a predicate test”

First
 
“Emits only the ﬁrst item (or the ﬁrst item that meets
some condition) emitted by an Observable”

Last
 
“Emits only the last item (or the last item that meets
some condition) emitted by an Observable”

Find
 
“Emits only the items emitted by an Observable
that meet a condition expressed as a function”

Skip
 
“Suppress the ﬁrst n items emitted by an
Observable”

Take
 
“Emits only the ﬁrst n items emitted by an
Observable”

Distinct
 
“Suppresses duplicate items emitted by an
Observable”

Merge
 
“Combines multiple Observables into one by
merging their emissions”

Zip
“Combines the emissions of multiple Observables
together using function and emit single items for
each combination based on the results of this
function”

/* Using arguments */
var range = Rx.Observable.range(0, 5);
var source = Observable.zip(
range,
range.skip(1),
range.skip(2),
function (s1, s2, s3) {
return s1 + ':' + s2 + ':' + s3;
}
);
var subscription = source.subscribe(
function (x) {
console.log('Next: ' + x);
},
function (err) {
console.log('Error: ' + err);
},
function () {
console.log('Completed');
});

Join
 
“Combines the items emitted by two Observables,
and selects the items to combine upon the
duration-windows deﬁned on a per-item basis”

Concat
 
“Concatenates the output of multiple Observables
so that they act like a single Observable”

Achieving Parallelization
• A common question about Reactive Extensions is
how to achieve parallelization, or emitting multiple
items concurrently from an Observable
• You can achieve parallelization in RxJava without
breaking the Observable contract

Schedulers
• immediate(), creates and returns a Scheduler that executes work
immediately on the current thread
• trampoline(), creates and returns a Scheduler that queues work
on the current thread to be executed after the current work completes
• newThread(), creates and returns a Scheduler that creates a new
Thread for each unit of work
• computation(), creates and returns a Scheduler intended for
computational work
• io(),creates and returns a Scheduler intended for IO-bound work
(unbounded, multiple threads)

subscribeOn
The method subscribeOn() allows you to move
the execution of the Observable code into another
thread and with an speciﬁc behavior

ﬂatMap
The flatMap() has to merge emissions from
multiple Observables happening on multiple
threads, but it cannot allow concurrent onNext()
calls to happen down the chain including the
Subscribe

Observable<Integer>vals = Observable.range(1,10);
vals.flatMap(val -> Observable.just(val)
.subscribeOn(Schedulers.computation())
.map(i -> intenseCalculation(i))
).toList()
.subscribe(val -> System.out.println("Subscriber received "
+ val + " on "
+ Thread.currentThread().getName()));
Calculating 4 on RxComputationThreadPool-2
Subscriber received [3, 2, 1, 6, 4, 7, 10, 5, 8, 9] on RxComputationThreadPool-3
Parallelization with RxJava

–Giorgio Natili
“Keep calm and react gracefully to
asynchronous system events…”

Isomorphic Reactive Programming

More Related Content

Similar to Isomorphic Reactive Programming (20)

More from Giorgio Natili (20)

Recently uploaded (20)

Isomorphic Reactive Programming