Reactive Streams

and

Akka

Reactive Streams

Write once, stream everywhere

• Functional extension of async/await 
• Handling streams of "live" data
• Problems: Synchronisation, Error handling, Producer-Consumer

• Interfaces/Contracts part of JDK 9 (JEP 266)
• ReactiveX (reactivex.io): Java, .NET, JS, C++... (backend, frontend...)
• Project Reactor (projectreactor.io): Java, Kafka (backend focused)

Observable → Operator → Subscriber

Observable = Stream prototype

Operator = Stream transformation

Subscriber = Stream consumer

Observable

Future, Iterable, merge, concat, periodic, timer, ...

Operator

Transformations

map, filter, scan, groupBy, flatMap, takeUntil, delay, ...

Backpressure

debounce, throttle, buffer, window, sample, ...

Error handling

retry, catch, using, delayError, switchOnError, ...

val loadNext = list.scollEvents()
                   .debounce(100, TimeUnit.MILLISECOND)
                   .observeOn(Schedulers.ui())
                   .map { list.maxY - list.list.currentY }
                   .filter { remaining -> remaining < 2 * PAGE_HEIGHT }

Observable
    .concat(
        Observable
            .range(1,100)
            .map { page -> 
                Observable
                    .fromCallable { downloadPage(page) }
                    .retry(2)
                    .delaySubscription(loadNext)
            }
    )
    .takeUntil { page -> page.isEmpty() }
    .flatMap { page -> Observable.from(page) }
    .subscribeOn(Schedulers.io())
    .observeOn(Schedulers.ui())
    .filter { item -> ! list.contains(item) }
    .subscribe(
        onNext = { item -> list.add(item) },
        onError = { e -> list.clear(); list.add(e) },
        onCompleted = { list.add(FOOTER) }
    )

Akka

(Like Erlang, but on JVM)

• Actor concurrency model
• message driven
• 2.5M actors / 1GB and 50M message / s

• Actors form a tree-like hierarchy (spanning a single or multiple machines)
• Each Actor is responsible for failures of its children (restart/back-off)
• Actor references and paths (local or remote)
• Actor persistence (serialisation/deserialisation)

Akka Streams

• Reactive Streams compliant
• More complex API (designed for cluster execution)
• Pipelining vs. Parallel processing
• Source / Sink / Flow / Graph
• Broadcasting / Consuming streams
• Allows cycles (RxJava uses Subjects)