Talk & Drinks: Reactive Streams and Unsucking Future's

Öffentliche Gruppe

Enter Eindhoven

Science Park Eindhoven 5001 · Son

Wie du uns findest

North of Eindhoven, near the IKEA. See here on how to plan a route:

Bild des Veranstaltungsortes



I hope everyone had a good summer. I assume, after the ScalaDays and GotoAMS conferences in Amsterdam, you probably had loads of stuff you wanted to dive into this summer. ;-)

Hugo Zwaal joined me as co-organiser of this meetup. Together we hope to be able to plan even more meetup. We're thinking to extend the current setup to also regularly do Scala Intro sessions to keep attacking new enthusiasts and Community sessions where we together work on contributing to the Scala community.

But first .... we have a beautiful lineup for the first after-summer meetup: Lutz Huehnken, Solutions Architect of Typesafe is coming to talk about Reactive Streams. And Erik Bakker, fulltime Scala developer of Lunatech, has a very nice talk about how to unsuck Future's (or Monads).

This meetup is kindly hosted by Enter in Son (

18:00 - Walk-in
18:30 - Food
19:00 - Lutz Huehnken : "Reactive Streams"
20:15 - Erik Bakker : "Options in Future's, how to unsuck them".
21:15 - Time for drinks and chat

Talk details:
Lutz Huehnken is Solutions Architect at Typesafe. He has worked in professional software development since 1997, and has successfully deployed major web applications for clients in different fields (retail, logistics, hospitality, finance). His current focus in on the development of reactive applications - responsive, scalable, resilient systems - with Scala, Akka and Play. Occasionally he speaks about this at conferences, such as Devvoxx, JAX and ScalaDays. He tweets as @lutzhuehnken.

Reactive streams
Reactive Streams is an initiative to provide a standard for asynchronous stream processing with non-blocking back pressure on the JVM. It is a collaborative effort by Twitter, Netflix, Pivotal, Red Hat, Typesafe and others.

In this session, we want to talk about streams in general, the main concepts behind the reactive streams API, and how to handle streams with Akka. After an introductory talk we are going to go through some code examples using Akka streams, an implementation of reactive streams on top of the Akka actor library. We will look into interfacing streams and actors, and handling streams with Akka's Flows.

Akka HTTP (formerly Spray) and Slick 3 will also be discussed.

Erik Bakker has been a full-time Scala developer for for years, and is enthusiastic about functional programming. He has been teaching Scala to team members of the various teams he has been in over the years. Erik Bakker occasionally speak about Scala for various audiences, from basic introductions to Scala for non-Scala programmers at several companies looking to adopt Scala, to advanced talks and hands-on sessions about iteratee fundamentals or functional concepts like monad transformers to people with a Scala background and recently to a group of mostly Academic Haskell users at the Dutch Functional Programming day. Erik Bakker co-authored the book Play for Scala, published by Manning.

"Options in Future's, how to unsuck them":
Many libraries are asynchronous, and will return everything in a Future. For-comprehensions is a nice way to deal with the contents of Futures, but when the content is wrapped in a container like Option or Either, for-comprehensions alone are not enough. The result is often ugly nested code. This talk will show you how to make for-comprehensions work nicely with such structures. You'll learn how to fuse a Future and an inner container together, and nicely work with them in for-comprehensions. In an asynchronous application, this will give great readability benefits. Finally, we'll see that these friendly and easy to understand things are actually monad transformers. Additional notes --- This talk is a condensed version of a successful longer hands-on session that I did with multiple groups of Scala programmers at companies and a Scala user group event. Most of them really liked this content, because they run into this problem of deeply nested code in practice, usually caused by Future[Option[X]] values. In this talk we don't start with an off-the-shelve monad transformer, but we build one ourselves, by first building a monadic wrapper specialized for Future[Option[X]]. To most people that's surprisingly simple, and immediately after this step we can . We then generalize that into a proper monad transformer for Option inside any other monad, which is also a nice introduction to monads in itself. Finally we highlight a couple use cases for this, one of them being Play Framework action methods, than can often be written as a single for-comprehension, given a proper monad stack.