Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/1oj0gUw. Sadek Drobi discusses how to use Futures and Iteratees to deal with blocking threads in a system with many IO calls and heavy threads. Filmed at qconlondon.com. Sadek Drobi is a software engineer specialized in bridging the gap between the problem domain and the solution domain. As a core Play developer and Play2 co-creator, he works on the design and implementation of the framework.

1. "Do not block threads!"
a blessing in disguise or a curse?

2. Watch the video with slide
synchronization on InfoQ.com!
http://www.infoq.com/presentations
/block-threads
InfoQ.com: News & Community Site
• 750,000 unique visitors/month
• Published in 4 languages (English, Chinese, Japanese and Brazilian
Portuguese)
• Post content from our QCon conferences
• News 15-20 / week
• Articles 3-4 / week
• Presentations (videos) 12-15 / week
• Interviews 2-3 / week
• Books 1 / month

3. Presented at QCon London
www.qconlondon.com
Purpose of QCon
- to empower software development by facilitating the spread of
knowledge and innovation
Strategy
- practitioner-driven conference designed for YOU: influencers of
change and innovation in your teams
- speakers and topics driving the evolution and innovation
- connecting and catalyzing the influencers and innovators
Highlights
- attended by more than 12,000 delegates since 2007
- held in 9 cities worldwide

4. @sadache
prismic.io co-founder, Play framework co-creator

5. Modern Applications
• Spend a considerable time talking to internet
• Internet means latency
• How does your runtime integrate this latency?

7. A Typical Request
App
latency
Service

8. We should not waste scarce resources
while waiting for work to be done on other machines
• Memory, CPU, …
• Threads/processes?
• lightweight (millions on a single machines)
• heavyweight? …

11. JVM and co
• Threads are scarce resources (or are they? )
• We should not hold to threads while doing IO (or
internet call)
• “Do not block threads!”

13. Copy that! what CAN I do?

14. Do not block threads!
• Then what should I do?
• Non blocking IO and Callbacks
• ws.get(url, { result =>
println(result)
})
• What happens if I want to do another call after?
• Callback hell!

16. Futures!
(Tasks, Promises, …)
• Future[T] represents a result of type T that we are
eventually going to get (at the completion of the
Future)
• Doesn’t block the thread
• But how can I get the T inside?
• // blocking the current thread until completion of the future?
Result.await(future)

17. Examples of Future
composition
val eventuallyTweet: Future[String] = …
val et: Future[Tweet] = eventuallyTweet.map(t => praseTweet(t))
!
val tweets: Seq[Future[Tweet]] = …
val ts: Future[Seq[Tweet]] = Future.sequence(tweets)

18. Future composition

19. Future composition

20. Future composition

21. Some syntax sugar
// for comprehensions
for {
t <- getTweet(id)
k <- getKloutScore(t.user)
} yield (t,k)

22. Futures are elegant
• all, any, monads, applicatives, functors
• do all the scheduling and synchronisation behind
the scenes

23. Future is not satisfactory

24. Futures are not completely
satisfactory
• Manage execution on completion (who is
responsible of executing the code?)
• Additional logic complexity (adding one level of
indirection)
• Has a big impact on your program (refactorings)
• Ceremony, or am I doing the compiler/runtime work?
• Stacktrace gone!

25. Who runs this code?
val eventuallyTweet: Future[String] = …
val et: Future[Tweet] = eventuallyTweet.map(t => praseTweet(t))

26. Futures are not completely
satisfactory
• Manage execution on completion (who is
responsible of executing the code?)
• Additional logic complexity (adding one level of
indirection)
• Has a big impact on your program (refactorings)
• Ceremony, or am I doing the compiler/runtime work?
• Stacktrace gone!

27. Scala’s solution to execution
management (on completion)
• Execution Context
• def map[S](f: (T) ⇒ S)(implicit executor: ExecutionContext): Future[S]
• Just import the appropriate EC
• Very tough to answer the question (developers tend to
chose the default EC, can lead to contentions)
• import scala.concurrent.ExecutionContext.global
• Contention?

28. Futures are poor man’s
lightweight threads
• You might be stuck with them if you’re stuck with
heavyweight threads…
• Scala async!
• Why not an async for the whole program?

29. Futures are poor man’s
lightweight threads
val future = async {
!
val f1 = async { ...; true }
!
val f2 = async { ...; 42 }
!
if (await(f1)) await(f2) else 0
!
}

30. Futures are poor man’s
lightweight threads
• You might be stuck with them if you’re stuck with
heavyweight threads…
• Scala async
• Why not an async for the whole program?

31. Inversion of control
(Reactive)
• Future but for multiple values (streams)
• Just give us a Function and we call you each time
there is something to do
• Mouse.onClick { event => println(event) }

32. Inversion of control
(Reactive)
• What about maintaining state across calls
• Composability and tools
• Iteratees, RX, Streams, Pipes, Conduits, … etc

33. Iteratees
<a quick introduction>

34. Iteratees
• What about maintaining state between calls
• Composability and tools
• Iteratees, RX, Streams, Pipes, Conduits, … etc

35. Iteratees
trait Step
case class Cont( f:E => Step) extends Step
case class Done extends Step

36. Iteratees
trait Step[E,R]
case class Cont[E,R]( f:E => Step[E,R]) extends Step[E,R]
case class Done(r: R) extends Step[Nothing, R]

37. Iteratees
// A simple, manually written, Iteratee
val step = Cont[Int, Int]( e => Done(e))
//feeding 1
step match {
case Cont(callback) => callback(1)
case Done(r) => // shouldn’t happen
}

38. Counting characters
// An Iteratee that counts characters
def charCounter(count:Int = 0): Step[String, Int] = Cont[String, Int]{
case Chunk(e) => charCounter(count + e.length)
case EOF => Done(count)
}

39. Iteratees
trait Input[E]
case class Chunk[E](e: E)
case object EOF extends Input[Nothing]
!
trait Step[E,R]
case class Cont[E,R]( f:E => Step[E,R]) extends Step[E,R]
case class Done(r: R) extends Step[Nothing, R]

40. Counting characters

41. Counting characters
// An Iteratee that counts characters
def charCounter(count:Int = 0): Step[String, Int] = Cont[String, Int]{
case Chunk(e) => step(count + e.length)
case EOF => Done(count)
}

42. Same principle
• count, getChunks, println, sum, max, min, etc
• progressive stream fold (fancy fold)
• Iteratee is the reactive stream consumer

43. Enumerators
• Enumerator[E] is the source, it iteratively checks on the Step
state and feeds input of E if necessary (Cont state)
• Enumerators can generate, or retrieve, elements from anything
• Files, sockets, lists, queues, NIO
• Helper constructors to build different Enumerators

44. Enumeratees
• Adapters
• Apply to Iteratees and/or Enumerators to adapt their input
• Create new behaviour
• map, filter, buffer, drop, group, … etc

45. Iteratees
</ a quick introduction>

46. Iteratees
Inversion of controls: Enumerators chose when to call the Iteratees
continuation
They chose on which Thread to run continuation
What if an Iteratee (or Enumeratee) decided to do a network call?
Block the thread waiting for a response?

47. Counting characters
// An Iteratee that counts characters
def sumScores(count:Int = 0): Step[String, Int] = Cont[String, Int]{
case Chunk(e) =>
val eventuallyScore: Future[Int] = webcalls.getScore(e)
step(count + Result.await(eventuallyScore)) // seriously???
case EOF => Done(count)
}

48. Reactive all the way
// An Iteratee that counts characters
def sumScores(count:Int = 0): Step[String, Int] = Cont[String, Int]{
case Chunk(e) =>
val eventuallyScore: Future[Int] = webcalls.getScore(e)
step(count + Result.await(eventuallyScore)) // seriously???
case EOF => Done(count)
}

49. Iteratees
trait Step[E,R]
case class Cont[E,R]( f:E => Step[E,R]) extends Step[E,R]
case class Done(r: R) extends Step[Nothing, R]

50. Iteratees
trait Step[E,R]
case class Cont[E,R]( f:E => Future[Step[E,R]]) extends Step[E,R]
case class Done(r: R) extends Step[Nothing, R]

51. Reactive all the way
// An Iteratee that counts characters
def sumScores(count:Int = 0): Step[String, Int] = Cont[String, Int]{
case Chunk(e) =>
val eventuallyScore: Future[Int] = webcalls.getScore(e)
eventuallyScore.map( s => step(count + s))
case EOF => Future.successful(Done(count))
}

52. Seamless integration between
Futures and Iteratees
Seq[Future[E]] is an Enumerator[E]
Iteratees can integrate any Future returning call
Back-pressure for free

53. Suffer from the same
drawbacks of Futures
• Manage execution on completion (who is
responsible of executing the code?)
• Everything becomes a Future
• Stacktrace gone!

54. Elegant, help manage complexity of
asynchronous multiple messages
Composable
Builders and helpers
Modular

55. Recap
• Stuck with heavyweight threads?
• NIO and Callback hell
• Futures
• Composable Futures
• Iteratees and co
• Developer suffering from what the runtime/compiler couldn’t
provide

56. Asynchronous
Programming
is the price you pay, know what you’re paying for

57. The price is your
productivity

58. Asynchronous
Programming
calculate your cost effectiveness

59. Questions

60. Watch the video with slide synchronization on
InfoQ.com!
http://www.infoq.com/presentations/block-threads