Codemotion akka voló sobre el nido del future

MADRID · NOV 27-28 · 2015
Scala Programming @ Madrid
Akka voló sobre el nido del Future
Javier Santos
David Vallejo

MADRID · NOV 27-28 · 2015
About us
David Vallejo @dvnavarro
« It’s not a bug – it’s an
undocumented feature.»
Anonymous
Javier Santos @jpaniego
«Hay dos formas de programar sin
errores; solo la tercera funciona»
Alan J Perlis

MADRID · NOV 27-28 · 2015
Introduction: A functional world
● Purely functional: whole world could be implemented
in a single functional line
● Functional features
○ Robust
○ Debuggable
○ Predictable
○ Pluggable

MADRID · NOV 27-28 · 2015
● Example
type Context = (Input,Output,Error)
type Action = Context => (Context,Event)
def main(
actions: Iterable[Action],
context: Context):(Context,Seq[Event]) = {
((context,Seq.empty[Event]) /: actions) {
case ((context,events),action) =>
action.apply(context) match {
case (context,event) => (context, events :+ event)
}
}
}

MADRID · NOV 27-28 · 2015

MADRID · NOV 27-28 · 2015
● Problem? World actions are not precalculated.
What happens to I/O?
● World can be considered as
○ asynchronous: Things may happen at same time
○ reactive: Things may happen due to
■ actions: that trigger …
■ ...events: action consequences.

MADRID · NOV 27-28 · 2015
Introduction: Runnable & Callable
● java.lang.Runnable
trait Runnable {
def run(): Unit
}
● java.util.concurrent.Callable
trait Callable[V] {
def call(): V
}

MADRID · NOV 27-28 · 2015
Introduction: Threads
● Scala’s concurrency model is built on Java’s
● java.lang.Thread
val myThread = new Thread(new Runnable {
def run(){
println(“hi”)
}
}
myThread.start()
● Thread improvements (ExecutorService ~ Thread pool)
● Anyway, Threads abstraction level is too low

MADRID · NOV 27-28 · 2015
What about Scala and threads?

MADRID · NOV 27-28 · 2015
Future: Overview
● By default, non-blocking operations
● They will hold a T value at some point
● So a future may be uncompleted(it has no value yet) or
completed
● Completion will be treated as a scala.util.Try value
It will have two possible values:
○ Success(t: T)
○ Failure(t: Throwable)

MADRID · NOV 27-28 · 2015
Future: Overview
● Future example
import scala.concurrent._
import ExecutionContext.Implicits.global
val firstPrimeNumbers: Future[List[Int]] = Future {
List(1,2,3,5,7,11,13)
//what if 'calculateFirstPrimeNumbers(100000000)'…
}
res0: Future[List[Int]]

MADRID · NOV 27-28 · 2015
Future: Overview
● Failing Future example
import ExecutionContext.Implicits.global
val thisWillFail: Future[Int] = Future(2 / 0)
res0: Future[Int]

MADRID · NOV 27-28 · 2015
Future: ExecutionContext
● A future, once it’s completed, it never changes of value
● An ExecutionContext
○ executes tasks submitted to them.
○ They can be seen as thread pools.
○ Most of future ops require an implicit
ExecutionContext.

MADRID · NOV 27-28 · 2015
Future: Expecting results
● Expecting results.
○ Blocker way (discouraged but sometimes
mandatory).
○ Non-blocker way: using callbacks

MADRID · NOV 27-28 · 2015
Future: Blocking - Await
● Blocking: Await.result / Await.ready
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global
val f: Future[Int] = Future{
Thread.sleep(10000)
2
}
println(Await.result(f,12.seconds))
//2

MADRID · NOV 27-28 · 2015
Future: Blocking - Await
● Blocking: Await (Problem: Not enough time)
import scala.concurrent.duration._
Thread.sleep(10000)
2
}
println(Await.result(f,5.seconds))
java.util.concurrent.TimeoutException: Futures timed out after
[5 seconds]

MADRID · NOV 27-28 · 2015
Future: Non-blocking - Callbacks
● Non-Blocking: callbacks
Thread.sleep(10000)
2
}
f.onComplete( n => println(n) )
//at some point, “Success(2)” will appear
Non-blocking

MADRID · NOV 27-28 · 2015
Future: Callbacks
● Callbacks will be executed asynchronously when future
is completed
● type Callback = Try[T] => Unit
● Try[T] ~ Either[Throwable,T]
○ Left(throwable) ~ Failure(throwable)
○ Right(t) ~ Success(t)

MADRID · NOV 27-28 · 2015
Future: Callbacks
● onComplete
f.onComplete( (t: Try[Int]) => println(t) )
//Success(2)
● onSuccess
f.onSuccess( n => println(n) )
//2
● onFailure
f.onFailure( throwable => println(throwable.getMessage) )
//it will never print an error (because it equals Success(2))

MADRID · NOV 27-28 · 2015
Future: Operations
● map
def getFirstMillionOfPrimes(): Future[List[Int]] = ???
getFirstMillionOfPrimes().map(
(list: List[Int]) => list.head)
res0: Future[Int]

MADRID · NOV 27-28 · 2015
Future: Operations
● flatMap
def getFirstMillionOfPrimes(): Future[List[Int]] = ???
def concatenate(l: List[Int]): Future[String] = ???
getFirstMillionOfPrimes().flatMap(
(list: List[Int]) => concatenate(list))
res0: Future[String]

MADRID · NOV 27-28 · 2015
Future: Monad behavior
● Composition
○ Future is like a monad
■ Point Function: Future.apply
■ Bind Function: flatMap
■ Some math properties and so...
○ Since Future has map,flatMap,filter methods;
it can be composed easily in a for-comprehension

MADRID · NOV 27-28 · 2015
Future: Composition
● Problem
var result: String = “”
val f1: Future[Unit] = Future{
result += “Hi ”
}
val f2: Future[Unit] = Future{
result += “ everyone”
}
● result value? “Hi everyone”? “ everyoneHi”?

MADRID · NOV 27-28 · 2015
Future: Composition
● for-comprehension is your friend
for {
primes <- getFirstMillionPrimes()
primesString <- concatenate(primes)
} yield primesString
res0: Future[String]
Future[List[Int]]
Future[String]

MADRID · NOV 27-28 · 2015
Future: Recovering from failure
● recover
1 / 0
}.recover{
case e: ArithmeticException => 0
}

MADRID · NOV 27-28 · 2015
● recoverWith
1 / 0
}.recoverWith{
case e: ArithmeticException => Future(0)
}

MADRID · NOV 27-28 · 2015
● fallbackTo
val f1: Future[Int] = Future{
1 / 0
}
val f2: Future[Int] = Future(0)
val f = f1 fallbackTo f2

MADRID · NOV 27-28 · 2015
Promise: Overview
● Futures can be created by
○ Future.apply
○ Promises
● You can think about it like
○ Future ~ Read future value
○ Promise ~ Write future value
● Promises are single-assigned (just once. Immutable as
futures)

MADRID · NOV 27-28 · 2015
Promise: Baggage & claim
Menu
order
Menu
Being
Cooked
Ticket
Menu ready

MADRID · NOV 27-28 · 2015
Promise: Baggage & claim
Begin
completion
Future[T]
p.success
or
p.failure
Try[T]
Promise[T]

MADRID · NOV 27-28 · 2015
Promise: example
val r: T = produceSomething()
p success r
doSomethingElse()
startDoingSomething()
f onSuccess {
case r: T => handleResult()
}
val p = promise[T]
val f = p.future
Producer Consumer

MADRID · NOV 27-28 · 2015
Promise: completion
● complete
val p = promise[Int]
p.complete(Try(2))
● completeWith
val p = promise[Int]
p.completeWith(Future(2))

MADRID · NOV 27-28 · 2015
Future alternatives
● Scalaz futures
● Scala’s async library

MADRID · NOV 27-28 · 2015
Tones of slides and however...
Futures/Promises
Akka actors

MADRID · NOV 27-28 · 2015
Akka: main concepts
● Actors, actors everywhere
● Asynchronous messages
● Event-driven processes
● Distributed systems

MADRID · NOV 27-28 · 2015
Akka: Actors
● Black box
● State without race condition
● Messages to update the state

MADRID · NOV 27-28 · 2015
Akka: Actors
class MyFirstActor extends Actor {
override def receive = {
case _ => println("Hello World!")
}
}

MADRID · NOV 27-28 · 2015
Akka: Send a message
● Tell message
actor ! "Hi"
● Ask message
actor ? "Are you there"

MADRID · NOV 27-28 · 2015
Akka: Ask pattern
implicit val timeout = Timeout(5 seconds)
val f: Future[String] =
(actorRef ? AreYouThere).mapTo[String]

MADRID · NOV 27-28 · 2015
Akka: An example

MADRID · NOV 27-28 · 2015
Akka: Services user
service
contact
service
address
service
System
GetUser(id)
GetContacts(name)
GetAddress(name)
Option[User]
List[Contact]
Address
UserInfo

MADRID · NOV 27-28 · 2015
Akka: Ask Pattern & For
Comprehension
class UserServiceActor extends Actor {
val users: Map[String, User] =
Map("1" -> User("John"), "2" -> User("Jack"))
override def receive = {
case GetUser(userId: String) =>
sender ! users.get(userId)
}
}

MADRID · NOV 27-28 · 2015
Akka: Ask Pattern & For
Comprehension
def getInfo(userId: String): Future[UserInfo] =
for {
Some(user) <- (usersActor ? GetUser(userId))
.mapTo[Option[User]]
contacts <- (contactsActor.?(GetContacts(user.name))
(Timeout(5 seconds),context.self))
.mapTo[List[Contact]]
address <- (addressesActor ? GetAddress(user.name))
.mapTo[Address]
} yield UserInfo(user, contacts, address)

MADRID · NOV 27-28 · 2015
scalera.es
@scalerablog

MADRID · NOV 27-28 · 2015
Primeros pasos con Akka:
Olvídate de los threads
27 NOVEMBER
TRACK D
18:00

MADRID · NOV 27-28 · 2015
Caminando de Java a Scala en
menos de 2 horas
28 NOVEMBER
TRACK B
9:30

Codemotion akka voló sobre el nido del future

Recommended

Recommended

More Related Content

What's hot

What's hot (11)

Viewers also liked

Viewers also liked (7)

Similar to Codemotion akka voló sobre el nido del future

Similar to Codemotion akka voló sobre el nido del future (20)

Recently uploaded

Recently uploaded (20)

Codemotion akka voló sobre el nido del future