Scala ed Rx in pratica

Scala ed Rx
in pratica
Michele Mauro
@michelemauro
Scala Treviso Meetup
25/06/2015

WARDA - Fashion Digitalization
Chi vi parla...
CTO @ Visionest
Scientist @ Warda
Risolvo problemi

WARDA è la piattaforma software che mette ordine
al MEDIA CHAOS mediante specifiche applicazioni che
coprono le esigenze in tutte le fasi dell’azienda
Style & ProductStyle & Product
Board
digital technology
Board
digital technologyVisual & RetailVisual & Retail
E-CommerceE-Commerce
Marketing & SocialMarketing & Social

Di cosa vi parlo
Scala applicato ad un problema diverso
dalla “solita„ applicazione web o Big Data
https://www.flickr.com/photos/photosdavidgabrielfischer/13990127367

Problema
Archivio storico
80k file
1.2TB
DAMHTTP
Velocemente
Senza intervento manuale
Tracciando quanto eseguito

Prima analisi
Attraversamento di un albero
di dimensione e cardinalità
ignota
La visita restituisce un
risultato ed i nodi del livello
successivo

Future[T]
Un Future[T] diventerà un valore in futuro
La sua elaborazione può iniziare in qualsiasi momento
Future#get blocca fino al completamento
Future#isCompleted è vero quando il valore è
disponibile

“Velocemente„
Con Future[T] gestiamo le operazioni di lunga
durata; e non dobbiamo più preoccuparci della
concorrenza.
type ResultRest[R] =
(TreeResult[R], List[TreeAction[R]])
type FutureResultRest[R] =
Future[ResultRest[R]]

Il tipo dei dati
Tipo di dato
Documentazione Lessico
Istruzione Materia prima
Uno dei vantaggi più accessibili di Scala è la facilità con
cui è possibile maneggiare, costruire, e descrivere tipi.

“Velocemente„
def buildFuture(
arg: TreeAction[R],
subscriber: Subscriber[TreeEvent[R]]):
FutureResultRest[R]
def select[A](
fs: Seq[Future[A]])
(implicit ec: ExecutionContext):
Future[(Try[A], Seq[Future[A]])]
Grazie a Viktor Klang: https://gist.github.com/4488970

“Velocemente„
● Il numero di thread è un facile parametro
sull'ExecutionContext
● La condizione di termine è che la coda sia vuota, cioè
che select() ritorni (Success[A], Seq())

“Velocemente„
def run(current: Seq[FutureResultRest[R]],
subscriber: Subscriber[TreeEvent[R]]): Unit = {
select(current) onSuccess {
case (done: Try[ResultRest[R]],
rest: Seq[FutureResultRest[R]]) =>
val result = done.get
val remaining = rest ++ result._2.map({ action =>
subscriber.onNext(TreeActionQueue(action))
action
}).map(buildFuture(_, subscriber))
if (remaining.isEmpty)
executionContext.shutdown()
else run(remaining, subscriber)
}
}

Il tipo dei dati
When Scala came out,
Static Typing was dead
Martin Odersky, Scala Italy Milan 08/05/2015
Image by Marco Firrincieli https://plus.google.com/photos/112206187111185023340/albums/6162489666224189969

“Una traccia di quanto eseguito„
● Come contare e sommare risultati che arrivano
contemporaneamente da più thread?
● E nel frattempo annotare le operazioni eseguite?

ReactiveX
“An API for asynchronous
programming with
observable streams„
Semantica standardizzata
e accuratamente definita
“The Observer pattern
done right„
reactivex.io
introtorx.com

ReactiveX

Il nostro esecutore è un Observable. Ne ricaviamo un
ConnectableObservable, in modo da poterci collegare
più Subscribers:
val walker = TreeWalker[SyncDone]
(config.threads).traverse(List(root)).publish

walker.subscribe(_ match {
case TreeActionEnd(
TreeResult(source, SyncDone(...), _), _) =>
localLog.println(f"...")
case _ => Nil })
var files = 0L
doneResults.map(s => 1)
.sum.subscribe(files = _)
var bytes = 0L
doneResults.map(_.bytes)
.sum.subscribe(bytes = _)

walker.connect

Risultati
Problema risolto
Ottima interazione con Java
Codice riutilizzabile
Multithreading semplice

Punti critici
Tempi di compilazione
Ecosistema giovane
Inversione della prospettiva

Ringraziamenti

Bonus 1: scopt
https://github.com/scopt/scopt

Bonus 2: sbt
https://scala-sbt.org

Bonus 3: example code
https://goo.gl/QWHNNb
https://bitbucket.org/michelemauro/scalatvmeetup20150625

Scala ed Rx in pratica

Recommandé

Recommandé

Contenu connexe

Similaire à Scala ed Rx in pratica

Similaire à Scala ed Rx in pratica (20)

Scala ed Rx in pratica