Scala ed Rx in pratica

Scala ed Rx in pratica

Michele Mauro@michelemauro

Scala Treviso Meetup25/06/2015

WARDA - Fashion Digitalization

Chi vi parla...

CTO @ VisionestScientist @ 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 & Product Style & Product

Boarddigital technology

Boarddigital technologyVisual & Retail Visual & Retail

E-Commerce E-Commerce

Marketing & Social Marketing & 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 storico80k file1.2TB

DAMHTTP

VelocementeSenza 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 completamentoFuture#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 = 0LdoneResults.map(s => 1) .sum.subscribe(files = _)

var bytes = 0LdoneResults.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

https://scala-sbt.org/


Bonus 3: example codehttps://goo.gl/QWHNNb

https://bitbucket.org/michelemauro/scalatvmeetup20150625

https://goo.gl/QWHNNb

Scala ed Rx in pratica

Software

Transcript of Scala ed Rx in pratica