Going Reactive with g rpc

@aalmiray | andresalmiray.com
Going Reactive with
gRPC

Andres
Almiray
Seasoned Sourceror

@ Oracle

Apache Groovy PMC

Java Champion

Hackergarten

github.com/aalmiray

Agenda
• The Road to Reactive

• Sync vs Async

• Data Streams

• gRPC

• RxgRPC

Concepts

State
Imperative Programming (Procedural)

var a := b + c

println a

Declarative Programming (Functional)

(println (sum(b, c))

Time
Imperative Programming

var a := b + c

println a

Reactive Programming

var a := b + c

a.done( v -> println v)

Sync vs async
Synchronous operations block the ﬂow until they yield a
result (success or error).

Asynchronous operations DO NOT block the ﬂow, rather
they allow the program to continue. Results (or errors) will
be handled at a later point in time, typically using
functions (callbacks).

Futures and promises
They describe an object that acts as mediator for a value
that may be unknown at init time.

The terms Future and Promise are normally used
interchangeably but there’s a diﬀerence:

• A Future is a read-only reference of the expected value.

• A Promise is a write-once container that sets the value of
the Future.

https://en.wikipedia.org/wiki/Futures_and_promises

Futures in Java are synchronous, this can be
demonstrated by the following method signatures found
in java.util.concurrent.Future
V get()
V get(long timeout, TimeUnit unit)

Java 8 added a new type, CompletableFuture, that
implements CompletableStage, which in turns deﬁnes
the contract of a Promise, such as

thenAccept(Consumer<? Super T> action)
whenComplete(BiConsumer<? super T,? super Throwable>
action)
exceptionally(Function<Throwable,? extends T> fn)
… and many others

JDeferred oﬀers a diﬀerent API that allows better function
composition

Promise<D, F, P> then(DoneCallback<D> doneCallback)
Promise<D, F, P> done(DoneCallback<D> callback)
Promise<D, F, P> fail(FailCallback<F> callback)
Promise<D, F, P> always(AlwaysCallback<D, F> callback)

Data streams

Data streams
A sequence of values calculated over time.

Values are emitted when ready; they are computed without blocking
consumers.

Consumers listen to changes in the data stream and react to said
changes (hence the name Reactive Programming).

Push vs pull model.

Observable/observer
Data streams are of type Observable while consumer are
of type Observer.

The Observable type exposes multiple operations that
allow value composition, combinations, ﬁltering, and
other value transformations.

NOTE: many operations from RxJava/Reactor generate a
new Observable (decorator pattern)

Rx Operations
(a small sample of)

http://rxmarbles.com

http://reactivex.io/RxJava/2.x/javadoc/index.html

gRPC

https://grpc.io/
gRPC is a modern, open source, high-performance
remote procedure call (RPC) framework that can run
anywhere. It enables client and server applications to
communicate transparently, and makes it easier to build
connected systems.

Go
Java

rxgrpc
https://github.com/salesforce/reactive-grpc

Combines gRPC with Reactive Streams

Encapsulates gRPC’s API

Producers/Consumers only see Rx API

https://github.com/aalmiray/hello-grpc

resources
http://download.java.net/java/jdk9/docs/api/java/util/concurrent/Flow.html

http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/
CompletableFuture.html

http://jdeferred.org/

http://andresalmiray.com/articles/jdeferred-simple-handling-of-promises-and-
futures/

http://andresalmiray.com/articles/testing-rxjava2/

https://www.infoq.com/articles/rxjava2-by-example

Reactive programming
implies and paradigm
change!

http://andresalmiray.com/newsletter
http://andresalmiray.com/editorial

Going Reactive with g rpc

More Related Content

Similar to Going Reactive with g rpc

More from Andres Almiray

Recently uploaded

Going Reactive with g rpc