Reactive programming principles

PRINCIPI DI
REACTIVE PROGRAMMING
INGEGNERIA DEL SOFTWARE
Università degli Studi di Padova
Dipartimento di Matematica
Corso di Laurea in Informatica, A.A. 2013 – 2014
rcardin@math.unipd.it

Ingegneria del software mod. B
GO REACTIVE!
 Applicazione anni 2000
 Decine di server
 Tempi di risposta nell’ordine dei secondi
 Ore di downtime per manutenzione
 Dati nell’ordine dei Gigabyte
 Accedute da dispositivi desktop
 Applicazione moderne (≥ 2010)
 Cluster di migliaia di processi multicore
 Tempi di risposta nell’ordine dei millisec
 100% uptime
 Dati nell’ordine dei Petabyte
 Accedute da qualsiasi tipo di dispositivo
2
Riccardo Cardin

GO REACTIVE!
 Nuovi requisiti richiedono nuove tecnologie
 Reactive Application
 Orientate agli eventi
 Scalabili
 Resilienti
 Responsive
3
Riccardo Cardin
"Readily responsive to a stimulus"
Merriam-Webster
react to events
La natura event-driven abilita
alle altre qualità
react to load
La scalabilità non deve dipendere
da risorse condivise
react to failure
Sistemi resilienti permettono
di recuperare errori a tutti
i livelli
react to users
I tempi di risposta non devono
dipendere dal carico di lavoro

REACTIVE MANIFESTO
4
Riccardo Cardin
responsive
scalable resilient
event-driven
• Loosely coupled design
• Communication orientation
• Uso efficiente delle risorse
• Nessun redesing per
ottenere la scalabilità
• Scalabilità on-demand
• Risk-management
• Downtime è perdita
di denaro
• Parte del design
• Real-time, engaging, reach,
collaborative
• Nessuna latenza nelle
risposte

MODELLO SINCRONO
 Il mondo sincrono è senza futuro...
 Frequenti operazioni di I/O
 Scarso utilizzo delle feature offerte dai processori moderni
 Larga diffusione delle architetture multiprocessore
 Cicli non ottimizzati
 Scarso parallelismo o gestione difficoltosa
 Tipico dei linguaggi imperativi e ad oggetti
 C, C++, Java, ...
5
Riccardo Cardin
// Synchronous world (w/o Future)
val session = socialNetwork.createSessionFor("user", credentials)
// blocked on method, waiting for results (latency)...
session.getFriends()
// There are a lot of operation to do!!! :(

MODELLO SINCRONO
 Il mondo sincrono è senza futuro...
 Esempio: recuperare il nome del file più pesante
6
Riccardo Cardin
public String getBiggestFile(final File folder) {
long maxLength = 0L;
String fileName = null;
for (final File fileEntry : folder.listFiles()) {
if (maxLength < fileEntry.length()) { // Not so efficient
fileName = fileEntry.getName();
maxLength = fileEntry.length();
}
}
return fileName ;
}
...
if (maxLength… // computationfileEntry.length() // I/O
CPU poco utilizzata,
I/O sovrabbondante
Java
Tempo totale di attesa

MODELLO ASINCRONO
 Callbacks
 Funzioni da invocare al termine di una elaborazione
 Gestione migliore della CPU
 Ridotti tempi di attesa
 Più processi gestiscono più richieste
 Asynchronous JavaScript and XML (AJAX)
7
Riccardo Cardin
var callback = function(){
alert('I was called back asynchronously');
};
$.ajax({
type: 'GET',
url: 'http://example.com',
done: callback, // positive case
fail: anotherCallback // negative case
});
jQuery
In attesa della risposta, è
possibile continuare
l’elaborazione (rendering UI)

MODELLO ASINCRONO
 Callbacks
 Linguaggi o framework che gestiscano l’elaborazione
asincrona e concorrente
 Node.js, jQuery, ...
 Ma...c’è sempre un ma... 8
Riccardo Cardin
CPU1
CPU2
CPU3
CPU4
Tempo totale di attesa
I/O è ancora presente, ma
viene distribuito
sull’elaborazione di più CPU

MODELLO ASINCRONO
 Callbacks...HELL!!!
9
Riccardo Cardin

10
Riccardo Cardin
module.exports = function (dir, cb) {
fs.readdir(dir, function (er, files) {
if (er) return cb(er)
var counter = files.length
var errored = false
var stats = []
files.forEach(function (file, index) {
fs.stat(path.join(dir,file), function (er, stat) {
if (errored) return
if (er) {
errored = true
return cb(er)
}
stats[index] = stat
if (--counter == 0) {
var largest = stats
.filter(function (stat) { return stat.isFile() })
.reduce(function (prev, next) { // [6]
if (prev.size > next.size) return prev
return next
})
cb(null, files[stats.indexOf(largest)])
}
}) // [1]
}) // [2]
}) // [3]
}
node.js
Innesto callback per gestire i
flussi degli eventi
Difficile da verificare e
manutenere
Difficile gestire le
eccezioni con blocchi
try/catch

FUTURES E PROMISES
 Futures
 Tecnica per eseguire molte operazioni in parallelo, in
modo efficiente e non-blocking
 Stile dichiarativo
 Immutabile
 Rappresenta un segnaposto per un risultato futuro
 Componibili
 Implementano meccanismi per la gestione delle eccezioni
11
Riccardo Cardin
// With Futures (asynchronous world)
val session = socialNetwork.createSessionFor("user", credentials)
// Create placeholder for computation
val f: Future[List[Friend]] = future { session.getFriends() }
// Statements here can be executed, while waiting for results :)
scala

FUTURES E PROMISES
 Monad
 Rappresenta un contesto di esecuzione (framework)
 Amplificatore di tipi, computation builder
 Può racchiudere un tipo
 È componibile con altre monadi
 Composizione (a.k.a. concatenazione) sul tipo racchiuso
 Spesso permette di estrarre il valore del tipo contenuto
 Caratteristica dei linguaggi funzionali
12
Riccardo Cardin
public class Monad<T> {
public Monad(T t) { /* ... */ }
}
public class Monad<T> {
public abstract <V> Monad<V> bind(Function<T, Monad<V>> f);
}

FUTURES E PROMISES
 Monad
 È simile ad una bolla!
13
Riccardo Cardin
Può racciudere
qualcosa
È qualcosa di non
concreto
Può ricevere istruzioni su
cosa fare del contenuto
Può
evaporare,
lasciando
libero il
contenuto

FUTURES E PROMISES
 Future[T]è una monad
 Racchiudono l’elaborazione da eseguire in modo
asincrono (callback)
 Successfully completed / Failed with an exception
 Eventual execution: nessun vincolo temporale
14
Riccardo Cardin
import scala.util.{Success, Failure}
// Asynchronous execution inside future context
val f: Future[List[String]] = future {
session.getRecentPosts
}
// Do something else...
f onComplete {
// onSuccess
case Success(posts) => for (post <- posts) println(post)
// onFailure
case Failure(t) => println("An error has occured: " +
t.getMessage)
}
posts è il risulato
dell’elaborazione
t è un’eccezione scala

FUTURES E PROMISES
 Future[T]è una monad
 Composizione funzionale di più elaborazioni
 Non più callback hell!!!
 Si riporta il modello asincrono al modello sincrono
 Se un future nella catena fallisce, fallisce l’intera catena
15
Riccardo Cardin
// First future execution
val rateQuote = future {
connection.getCurrentValue(USD)
}
// Bind second execution to first
val purchase = rateQuote map { quote =>
if (isProfitable(quote)) connection.buy(amount, quote)
else throw new Exception("not profitable")
}
// Get final result
purchase onSuccess {
case _ => println("Purchased " + amount + " USD")
}
scala

FUTURES E PROMISES
 Promise[T]
 Single-assigment container (monad) / proxy
 Un Future legge il risultato di un’elaborazione asincrona
 Una Promise scrive (completa) un Future
16
Riccardo Cardin
val p = promise[T]
// Future that is completed by the promise
val f = p.future
val consumer = future {
startDoingSomething()
f onSuccess {
case r => doSomethingWithResult()
}
}
val producer = future {
val r = produceSomething()
p success r // Promise completes the Future
// It should be „p failure exception‟ also
continueDoingSomethingUnrelated()
}
produceSomething
startDoingSomething
doSomethingWithResult
r
scala
Valore che rappresenta
l’elaborazione

FUTURES E PROMISES
 Javascript promises (Q library)
 Promise e future sono fusi nelle medesime strutture
 Promise stile Scala  Q Deferreds
17
Riccardo Cardin
promiseMeSomething()
// value is the return value of promiseMeSomething
.then(function (value) {
// Do something as soon as promiseMeSomething finishes
},
// Something went wrong, reason is an exception
function (reason) {
});
then ritona una
promise, quindi è
concatenabile
var deferred = Q.defer();
FS.readFile("foo.txt", "utf-8", function (error, text) {
if (error) { deferred.reject(new Error(error)); }
else { deferred.resolve(text); }
});
return deferred.promise; Deferred permette di
completare una promise.
concatenabile

FUTURES E PROMISES
 Java 8 promises: CompletableFuture<T>
 Creazione (usando le lambda extension)
 Composizione (future stile Scala)
18
Riccardo Cardin
A Future that may be explicitly completed (setting its value and
status), and may include dependent functions and actions that
trigger upon its completion.
Javadoc
final CompletableFuture<String> future =
CompletableFuture.supplyAsync(() -> {
//...long running...
return "42";
}, executor);
Effettua l’override del
metodo
CompletableFuture.get()
// f1 is a promise that will completed with an Integer value
CompletableFuture<Double> f3 =
f1.thenApply(Integer::parseInt).thenApply(r -> r * r * Math.PI).
exceptionally(ex -> "We have a problem: " + ex.getMessage());
thenApply è simile a map di
Scala

REACTIVE EXTENSIONS (RX)
 Gestione sequenze di valori in modo asincrono
 Observable sequences
 Estensione del design pattern Observer
 Utilizzo di operatori di composizione (monads!)
19
Riccardo Cardin
Single items Multiple items
Synchronous T getData() Iterable<T> getData()
Asynchronous Future<T> getData() Observable<T> getData
public static void hello(String... names) {
Observable.from(names).subscribe(new Action1<String>() {
@Override
public void call(String s) {
System.out.println("Hello " + s + "!");
}
});
}
// hello("Ben", "George");  Hello Ben! Hello George!

 Observables (RxJava)
20
Riccardo Cardin
Event Iterable (pull) Observable (push)
Retrieve data T next() onNext(T)
Discover error throws Exception onError(Exception)
Complete returns onCompleted()
Aggiunta al
pattern GoF
getVideos().subscribe(new Observer<Video>() {
def void onNext(Video video) { // Invoked on next element
println(“Video: ” + video.videoId)
}
def void onError(Exception e) { // Invoked on error
e.printStackTrace()
}
def void onCompleted() { // Invoked when stream finishes to emit
println(“Completed”)
}
}

 Observables (RxJava)
 Monads  Componibili
 Mantengono la proprietà di asincronia originaria
21
Riccardo Cardin

 Composizione Observables
22
Riccardo Cardin

ACTOR MODEL
 Reactive
 Elaborazioni solo in risposta a stimoli esterni
 Dormiente / attivo
 Non c’è un concetto esplicito di thread
 Tre azioni fondamentali
 Invio di un messaggio async a se stesso o altro attore
 Creazione nuovi attori
 Modifica del proprio comportamento
 Nessuno stato interno (...in teoria...)  Immutabili
23
Riccardo Cardin
Each actor is a form of reactive object, executing some
computation in response to a message and sending out a reply
when the computation is done
John C. Mitchell

ACTOR MODEL
 Messaggi (task)
 Interfaccia di comunicazione dell’attore
 Variare nel tempo (comportamento)
 Elaborazione dei messaggi uno per volta
 Coda di messaggi (mail box)
 Nessuna garanzia sull’ordine di arrivo
 Mail system
 Ogni attore ha associato un mail address
 Composti di tre parti
24
Riccardo Cardin
tag target data
email address del
receiver
operazione

ACTOR MODEL
 Esempio
 Ad ogni cambio di stato viene creato un nuovo attore
 State change: no race conditions
 Behavioural change
25
Riccardo Cardin
A1:[1, 4, 7]
A1:[1, 2, 4, 7]
A1:[2, 4, 7]
Insert|2
Get_min
Min|1

ACTOR MODEL
 Akka
 Toolkit e runtime che implementano attori su JVM
26
Riccardo Cardin
(c) http://akka.io

AKKA
27
Riccardo Cardin
type Receive = PartialFunction[Any, Unit]
trait Actor {
def receive: Receive // Actor actual behaviour
implicit val self: ActorRef // Reference to itself
def sender: ActorRef // Reference to the sender of last message
implicit val context: ActorContext // Execution context
}
abstract class ActorRef {
// Send primitives
def !(msg: Any)(implicit sender: ActorRef = Actor.noSender): Unit
def tell(msg: Any, sender: ActorRef) = this.!(msg)(sender)
// ...
}
trait ActorContext {
// Change behaviour of an Actor
def become(behavior: Receive, discardOld: Boolean = true): Unit
def unbecome(): Unit
// Create a new Actor
def actorOf(p: Props, name: String): ActorRef
def stop(a: ActorRef): Unit // Stop an Actor
// ...
}
scala

AKKA
 Esempio
 Implementazione di un contatore con gli attori
28
Riccardo Cardin
class Counter extends Actor {
// State == explicit behaviour
def counter(n: Int): Receive = {
// Receive two types of messages: „incr‟ and „get‟
// „incr‟ change actor‟s behaviour
case ”incr” => context.become(counter(n + 1))
// „get‟ returns current counter value to sender
case ”get” => sender ! n
}
def receive = counter(0) // Default behaviour
}
scala
a:[0]
a!incr
a:[1]
a!incr
a:[2]
a!get sender!2
È possibile
modellare
anche stati
interni

AKKA
 Resilienza
 Contenimento e riposte automatiche agli errori
 Gli attori in errore vengono terminati o riavviati
 La decisione è presa da un attore supervisore
 Gli attori con supervisione formano una struttura ad albero
 Il supervisore crea i suoi subordinati
29
Riccardo Cardin
class Manager extends Actor {
// OneForOneStrategy restarts only actor which died
override val supervisorStrategy = OneForOneStrategy() {
case _: DBException => Restart // reconnect to DB
case _: ActorKilledException => Stop
case _: ServiceDownException => Escalate
}
// ...
context.actorOf(Props[DBActor], ”db”)
// ...
}
sup
sub1
sub2
sub1.1
Errorflow

AKKA
 Actor lifecycle
30
Riccardo Cardin
Start
Restart
Stop
new Actor
preStart
fail
preStart
new Actor
stop
postStop
Supervisor
An actor
ActorRef rimane
valido tra un riavvio
e l’altro
Le fasi di riavvio
possono essere
molteplici

BIBLIOGRAFIA
 The Reactive Manifesto http://www.reactivemanifesto.org/
 Promises in Node.js with Q – An Alternative to Callbacks
http://strongloop.com/strongblog/promises-in-node-js-with-q-
an-alternative-to-callbacks/
 The Reactive Extensions (Rx) http://msdn.microsoft.com/en-
us/data/gg577609.aspx
 Futures and Promises http://docs.scala-
lang.org/overviews/core/futures.html
 Java concurrency (multi-threading)
http://www.vogella.com/tutorials/JavaConcurrency/article.html
#futures
 Java 8: Definitive guide to CompletableFuture
http://nurkiewicz.blogspot.it/2013/05/java-8-definitive-guide-
to.html
 Taming asynchronous programming
http://eamodeorubio.github.io/tamingasync/#/ 31
Riccardo Cardin

BIBLIOGRAFIA
 Monadic futures in Java 8
http://zeroturnaround.com/rebellabs/monadic-futures-in-java8/
 Monads http://ericlippert.com/category/monads/
 Callback Hell http://callbackhell.com/
 CompletableFuture
http://www.slideshare.net/kojilin/completable-future
 RxJava Wiki https://github.com/Netflix/RxJava/wiki
 Functional Reactive Programming with RxJava
https://speakerdeck.com/benjchristensen/functional-reactive-
programming-with-rxjava-javaone-2013
 Principle of Reactive Programming
https://class.coursera.org/reactive-001
 Actors http://doc.akka.io/docs/akka/snapshot/scala/actors.html
32
Riccardo Cardin

Reactive programming principles

Recommended

More Related Content

Viewers also liked (14)

Similar to Reactive programming principles (20)

More from Riccardo Cardin (20)

Reactive programming principles