Monday, 2nd - Tuesday, 3rd December in London

34 experts spoke.

Join us at the third Annual Scala eXchange 2013 for 2 days of learning Scala skills! Meet the amazing Bill Venners and gain an understanding of the trade-offs between implicit conversions and parameters and how to take advantage of implicit parameters in your own designs. Or join Viktor Klang's talk to learn strategies for the recovery and healing of your systems, when things go FUBAR. Find out about Lift from David Pollak, or find out about Adept, the new dependency management system for Scala in Fredrik Ekholdt's talk. Find out about the road to Akka Cluster, and beyond in Jonas Boner's keynote or about the new design of theMacro-based Scala Parallel Collections with Alex Prokopec! Featuring 2 days of talks over 3 tracks, The Scala eXchange will bring the world's top Scala experts and many of the creators of Scala stack technologies together with Europe's Scala community to learn and share skills, exchange ideas and meet like minded people. Don't miss it!

Tickets 2014

If you'd like to join us and 500+ other developers passionate about Scala and Reactive Programming you can find more information about the Scala eXchange 2014 on the #Scalax webpage.

Excited? Share it!


The Road to Akka Cluster, and Beyond…

We will start with walking through some of the early work in computer architecture—setting the stage for what we are doing today. Then continue through distributed computing, discussing things like:

  • Important Impossibility Theorems (FLP, CAP)
  • Consensus Protocols (Raft, HAT, Epidemic Gossip etc.)
  • Failure Detection (Accrual, Byzantine etc.),
  • Current exciting research, like:
    • ACID 2.0,
    • Disorderly Programming (CRDTs, CALM etc).

All these ideas and approaches to distributed computing have influenced the creation of Akka Cluser. In this talk, Jonas explains what ideas influenced their decisions, the theory behind Akka Cluster and he provided some insights in the future roadmap too.

Everyone loved this talk at the Scala eXchange 2013, with lots of tweets buzzing around during and after the talk.

A lot of the ideas discussed in this talk have influenced Jonas to write (the first version of) The Reactive Manifesto, which explains the need for Reactive Applications: Applications that are Event-driven, Scalable, Resilient and Responsive. Skills Matter supports the Reactive Manifesto because we believe it is the architecture for the future. Indeed, the ideas and technologies that form the foundation of the Reactive Manifesto, have been shared and explained in many talks at Skills Matter over the last few years.

Jonas Bonér

Jonas Bonér is founder and CTO of Lightbend, inventor of the Akka project, co-author of the Reactive Manifesto and a Java Champion.

Overcoming U-turns and Dead Ends: Lessons of using Scala, Akka & Spray on Heroku

Not satisfied with being new to the Scala language, Akka's actor model, and the unique constraints of the Heroku platform, circumstances conspired to add PostgreSQL, MongoDB & Redis to our tech stack.

Sam Dean

Sam started out on embedded C, did a stint with PHP (which is best forgotten), toyed with Flash and has since moved onto iOS where he's been happy for a few years.He has recently got the chance to work on some back-end stuff for a change and jumped h

Stig Brautaset

Multilingual software guy, best known for his work on SBJson. At NET-A-PORTER he got the opportunity to learn Scala and Akka while working on several different projects including The Netbook backend.

What Are Macros Good For?

Just three months after the first, experimental release of Scala macros in 2.10, we had a Scala team meeting where we decided that macros look good for becoming non-experimental in 2.12. Why go from an experiment to an official part of the language so swiftly? Well, that's because macros are genuinely useful in a wide range of applications, making impossible things possible and tedious things enjoyable.

The beautiful thing about macros in Scala is their natural integration into the language that gives rise to a number of unexpected and handy interactions with other language features. In this talk, you will learn about the most important of such interactions and will understand the mechanisms that underlie them, becoming able to realize the full potential of Scala macros in your libraries and applications.

Eugene Burmako

Eugene works with Twitter Inc and is a member of the Scala team, founder of Scala Macros and Scala Meta.


ThisWeekInScala has become the de-facto source for the latest Scala releases, news, blogs, presentations and tutorials. Released every week, the blog is read by thousands of developers.

Chris Cundill

With over eight years in software, Chris is an experienced software developer & project manager who has built enterprise systems supporting over 10,000 users, processing over a 1,000 transactions per minute.

spray: HTTP for your Akka Actors

In this session I'll be live-coding for most of the time, showing you how easy it is to:

  1. Send an HTTP request and receive HTTP responses on the client-side
  2. Write a low-level HTTP server
  3. Use the high-level routing DSL on the server-side to define a simple REST API behavior.

Additionally I'll talk about what is on the agenda regarding the move into Akka as well as the transition from Netty to the new akka-http as the HTTP "driver" for the Play framework.

If you haven't used spray yourself yet the recording of the recent Typesafe Webinar gives you some good more high-level introduction to spray, which might help in making the most of this session.

Mathias Doenitz

Mathias is lead developer of, Akka committer and passionate Scala-ista. As a long-time and active member of the Java and Scala open source community he is especially excited about everything performance-, scalability- and web-related.

Scala.js: write in Scala for the browser

Scala.js compiles full-fledged Scala code down to JavaScript, which can be integrated in your Web application. It provides very good interoperability with JavaScript code, both from Scala.js to JavaScript and vice versa. E.g., use jQuery and HTML5 from your Scala.js code, either in a typed or untyped way. Or create Scala.js objects and call their methods from JavaScript.

Other outstanding features include generation of Source Maps 2 for a smooth debugging experience, and integration with the Google Closure Compiler 3 for producing minimal code for production.

Sébastien Doeraene

Scala Center, EPFL

Rethinking the debugger: the Future (is) in reactive applications

New abstractions for concurrency make writing programs easier by moving away from threads and locks, but debugging such programs becomes harder. The call-stack, an essential tool in understanding why and how control flow reached a certain point in the program, loses meaning when inspected in traditional debuggers.

Iulian Dragos

Iulian Dragoș dreams about a world where the Scala programming language is the default choice for new projects. He learned Scala by writing the compiler backend for it during his PhD at EPFL, back in 2004, and he was the first employee of Lightbend (formerly Typesafe). At Lightbend he helped the company grow from 5 to 85 employees, playing the role of engineer, technical lead, consultant, trainer or sales engineer. Iulian is a frequent speaker at conferences and actively contributing to several open-source projects.

Play, sbt and its compilers

Fredrik Ekholdt

Fredrik Ekholdt has spent all of his free time working with Scala since he was introduced to Scala back in 2009. At Lightbend Fredrik is mainly teaching Scala and Play courses and helping customers to adopt these technologies.

Introducing Adept

In the mean time have a look at adept's github page to learn more.

Fredrik Ekholdt

Fredrik Ekholdt has spent all of his free time working with Scala since he was introduced to Scala back in 2009. At Lightbend Fredrik is mainly teaching Scala and Play courses and helping customers to adopt these technologies.

Failure: Deal with it!

Viktor Klang

Viktor Klang is the Deputy CTO at Typesafe—prolific contributor to the Akka project as well as member of the Reactive Streams SIG when not involved in the Scala Standard Library concurrency APIs. Interested in all things distributed and concurrent—software as hardware.

Scala does the catwalk

We've heard how Twitter and LinkedIn adopted Scala on greenfield initiatives and we're excited to use a more expressive language running on a robust, familiar VM. But is the ecosystem ready to support the demands of a long-established enterprise infrastructure, mission-critical (non-Scala!) middleware and the traditional dev-test-release workflow?

We'll start by exposing what drove our decision to dive into Scala. Next: We'll talk about some of the challenges we faced designing, building, load testing and debugging our service. We will discuss some of the patterns we used moving to a more reactive platform, the availability/maturity of the tooling and some of the framework code we had to write. Finally we'll outline the benefits gained through embarking on this project and any prices we have paid for doing so.

Ariel Kogan

Ariel is part of the Labs Team of Net-A-Porter. After a long lasting happy romance with Java, he is starting to share the love with other JVM running languages as Scala.

Ian Forsey

Initially joining Net-A-Porter as a Java Developer, Ian has spent the last two years developing with Scala for the Labs Team. This transition has led him to author two open source scala projects and contribute to others such as Spray and json4s.

There's a Prolog in your Scala!

Scala is known to be a nice blend of object-oriented and functional paradigms. A lesser known fact is that it's also a logic programming type system! After all, it's not the syntax, but rather the semantics we're after right? Functional in the small, OO in the large, logic in the type system!

George Leontiev

George became interested in Scala right after he graduated from university. As soon as the opportunity presented itself, he switched to full-time Scala programming, and has never looked back. Nowadays he's working on backends at SoundCloud, and contributing to opensource on his free time.

Metascala: a tiny DIY JVM

The goal of Metascala is to create a platform to experiment with the JVM: a 3000 line JVM written in Scala is probably much more approachable than the 1,000,000 lines of C/C++ which make up HotSpot, the standard implementation, and more amenable to implementing fun features like continuations, isolates or value classes. The 3000 lines of code gives you:

  • The bytecode interpreter, together with all the run-time data structures
  • A stack-machine to SSA register-machine bytecode translator
  • A custom heap, complete with a stop-the-world, copying garbage collector

  • Implementations of parts of the JVM's native interface

Although it is far from a complete implementation, Metascala already provides the ability to run untrusted bytecode securely (albeit slowly), since every operation which could potentially cause harm (including memory allocations and CPU usage) is virtualized and can be controlled. Ongoing work includes tightening of the security guarantees, improving compatibility and increasing performance.

Scala e xchange 2013 haoyi li on metascala a tiny diy jvm from Skills Matter.

#Moody tweets

In Jan's exciting, invigorating, Broadway-style live-coding session, we will build a Tweet mood analysis application. Jan will show how to use spray-client with the new Akka I/O to download the tweets. The application will then store the tweets in Cassandra and then attempt to perform simple mood analysis. Discover whether people are indeed happy about #Scala tweets and miserable about #Java8 tweets.

To make the most of the session, you will need to have basic understanding of Scala and conceptual understanding of Akka; you do not need to worry about Cassandra nor Spray. Everyone is welcome, though novices may find the pace too fast to follow.

Jan Machacek

Jan Machacek is a passionate technologist with hands-on experience of the practical aspects of software delivery (architecture, quality, CI, CD), the project management approaches (applying the principles of agile project management), and mentoring and motivating engineering & business teams.

Scalding A.K.A: Writing Hadoop jobs, but without the pain

Hadoop and all it's eco system has settled down for good in our hearts and / or minds. It's quite old and has proven to be quite reliable for certain kinds of tasks. Yet one problem still remains - writing Map Reduce jobs in plain Java is really a pain.

The API is clunky and does it's best to hide the actual algorithm beneath tons of boilerplate. Throughout the years many tools and aproaches have shown up - Hadoop's own Streaming API or the great Cascading library.

We'll dive into code examples as well as look into how Scalding actually works, so you can try it out on your cluster when you come back to work on Monday (and smile a bit more when asked to write a Job next time!)

Konrad Malawski

Konrad is an Akka hakker at Typesafe, where he also participated in the Reactive Streams initiative, and implemented its Technology Compatibility Kit.

Network I/O for a More Civilized Age: The New Akka I/O

Until recently, users seeking a way of doing Scalable I/O had two choices: NIO, which provides an esoteric interface requiring serious expertise and concurrency control, or Netty - which provides a rich and powerful layer above NIO. The downsides to Netty however include an extremely idiomatic Java API, and a series of separated threads and thread pools left out of the control of the user.

There is, however, hope for the Scala user who abhors free range threading and wants a more Scala-sane interface to a network. Working with the Spray has recently introduced a new, lightweight Non-blockimg network I/O interface built around Akka's core Actors.

Further insights will include a demonstration of Akka I/O's built in system for Backpressure — allowing true handling & awareness of an overloaded network buffer, and compositing of Futures on top of the Actor API to emulate a more functional interface.

Brendan McAdams

Brendan is a Senior Consultant & Trainer at BoldRadius, where he works directly with clients to help them find success through consulting and training on the Typesafe Reactive Platform.

Scala and graphs

Graph databases provide a rich data model that allows us to model, query, and manipulate highly connected data far more than we've been used to in either the relational world, or in many of the contemporary NoSQL stores.

Mark Needham

Mark Needham is a graph advocate and Developer Relations Engineer at Neo4j.

JScala - write your JavaScript in Scala

Alexander Nemish

Alexander Nemish is a software engineer/architect and Scala enthusiast. Alexander participated in development of several server-side banking platforms for UBS and Deutsche Bank. Currently he works on Scala/Akka based distributed trade capturing platf

Let The Types Set You Free

Sean Parsons

Five years ago Sean made the jump from insurance and big banks to Mind Candy and in his time there made a big push into the use of Scala. He is also a core contributor to Argonaut and has made a few contributions to Scalaz.


Lenses have been called “jQuery for data types”: they give you a way to poke around in the guts of some large aggregate structure. Lenses compose (so you can make big lenses by gluing together little ones), and they exploit type classes to allow a remarkable degree of flexibility (get, set, fold, traverse, etc).

Simon Peyton Jones

Simon Peyton Jones, MA, MBCS, CEng, graduated from Trinity College Cambridge in 1980. Simon was a key contributor to the design of the now-standard functional language Haskell, and is the lead designer of the widely-used Glasgow Haskell Compiler (GHC). He has written two textbooks about the implementation of functional languages.

After two years in industry, he spent seven years as a lecturer at University College London, and nine years as a professor at Glasgow University before moving to Microsoft Research (Cambridge) in 1998.

His main research interest is in functional programming languages, their implementation, and their application. He has led a succession of research projects focused around the design and implementation of production-quality functional-language systems for both uniprocessors and parallel machines.

More generally, he is interested in language design, rich type systems, software component architectures, compiler technology, code generation, runtime systems, virtual machines, and garbage collection. He is particularly motivated by direct use of principled theory to practical language design and implementation -- that's one reason he loves functional programming so much.

What's new in Lift 3

David Pollak

David Pollak is a long time Scala dude, interested in Functional Programming, Scala, Clojure and making things better.

Macro-based Scala Parallel Collections

With the arrival of Scala Macros a new breed of optimization opportunities present themselves for the Scala Parallel Collections.

Many abstraction penalties have been overcome through macro-based callsite specialization. This eliminates boxing and iterators, uses heavy inlining and applies fusion optimizations - consequently achieving optimal baseline performance.

Parallel Collections also come with a redesigned scheduler that achieves better load balancing for tasks with heavily skewed workloads. In addition, the new scheduler is highly configurable and can be tuned for specific applications. And finally, the new Scala Parallel Collections features a new API based on implicit value classes that reduces the number of intermediate classes and allows looser coupling with standard library collections.

Alex Prokopec

Aleksandar Prokopec is a research assistant in the School of Computer and Communication Sciences at the EPFL in Switzerland, working in the LAMP laboratory under the supervision of dr. Martin Odersky. He received his Master degree at the Faculty of E

Dmitry Petrashko

Dmitry has been working on Scala since 2013 when he joined Martin Odersky's research lab at EPFL, working on ScalaBlitz, macro-generated collections for Scala. Since 2015, he has been working on the Dotty Compiler. He designed Mini-Phases, ported the JVM backend, implemented support for Java 8 lambdas and default methods along with various other parts of the compiler, including the pattern matcher, lazy vals, tail recursion transformations and parts of erasure and mixin composition.He is currently working on implementing the Dotty Linker, an optimizing compiler based on Dotty.

Akka in Practice: designing actor-based applications

You have probably heard Jonas Bonér talk about Akka. Words like scalable and reactive are buzzing around the industry. There clearly is a growing need for scalable, reactive, event-driven applications but there is not all that much practical information out there about how to build serious applications this way. How would you go about designing an application around these new(ish) concepts? What does it mean for an application to be reactive? What works and what doesn't?

We will show you which application and domain concepts should be modeled as actors, when and how to use Futures, how to prevent bottlenecks when calling blocking code, what Akka extensions are for, how to expose a REST API on top of Akka with Spray, how to test all of the above, and much more.

In short: we will assume you have heard the What and the Why so we will concentrate on the How.

Raymond Roestenburg

Raymond Roestenburg is writing the book "Akka in Action" for Manning. He has contributed to the Akka Camel module in Akka 2.x and has been using Akka in production since early 2010

Clojure + REPL = fun

Neale Swinnerton

Neale Swinnerton has been developing professionally for more than 20 years. He thinks that complexity is the enemy and that we should all tackle it head on for the good of those that follow.

Lift 3 - High and Lifted Up

The currently developed upcoming Lift 3 (Scala 2.10+) contains innovative ways to craft web applications, like for instance actors that communicate between JS client and Lift server.

Torsten Uhlmann

Torsten Uhlmann is the founder of AGYNAMIX, a small consulting firm, he's a Lift committer and author of the "Lift Web Applications How-to".

Hidden Gems in ScalaTest 2.0

ScalaTest 2.0 is a vast enough forest that it is hard to see all the useful trees.

Bill Venners

Bill Venners is president of Artima, Inc., provider of Scala books, developer tools, training, and consulting. He leads the open source projects for the ScalaTest testing library and the Scalactic library for functional, object-oriented programming. He is coauthor with Martin Odersky and Lex Spoon of the book, Programming in Scala.

Implicit Conversions => Implicit Parameters

Using primarily demos in the Scala REPL, Bill will show you several use cases and applications of implicit parameters that will help you understand the tradeoffs between implicit conversions and parameters and how to take advantage of implicit parameters in your own designs.

Bill Venners

Bill Venners is president of Artima, Inc., provider of Scala books, developer tools, training, and consulting. He leads the open source projects for the ScalaTest testing library and the Scalactic library for functional, object-oriented programming. He is coauthor with Martin Odersky and Lex Spoon of the book, Programming in Scala.

Patterns for Slick database applications

Slick is Typesafe's open source database access library for Scala. It features a collection-style API, compact syntax, type-safe, compositional queries and explicit execution control. Community feedback helped us to identify common problems developers are facing when writing Slick applications.

Jan Christopher Vogt

Jan Christopher Vogt is a Software Engineer at Sport195 NYC, a former member of the Scala team in Switzerland and a major contributor to the Slick database library.

Take Flight : Using Spaces in Scala

Asher Glynn

Asher is a consultant with over 20 years experience in the IT industry, and will use the most appropriate technology at hand, be that Scala or Java, Javascript and when pushed Visual Basic and Excel. With strong hands on knowledge of performance and scale, exposure to platforms from mainframes to mobiles has taught him an appreciation for the subtleties of applying technology to difficult problems - be they technical or people challenges. Asher has had experience in a variety of organisations ranging from the BBC, GSMA, Betfair, Equens, Close Brothers and the TAB to small startups.

Nigel Warren

Nigel is the Architect and project lead on Fly Object Space. He is a Visiting Research Fellow at Brunel University where his main research interests are long running distributed system and inter component lifetimes and dependencies.

Reconciling Eventually-Consistent Data with CRDTs

Eventually consistent data is common in modern web applications. We all know about eventually consistent data stores, popularised by Dynamo and Cassandra, but there are other sources of eventually consistent data. Mobile applications can go offline, but that doesn't stop people from using them, requiring synchronising data when they come back online. For robustness and to reduce network latency, applications may be hosted in multiple data centres connected by relatively high latency connections. It's infeasible to maintain strong consistency between these connections, again requiring synchronisation at regular intervals. How do we reconcile eventually consistent data?

One way is to use data types that we are guaranteed to merge without conflict. Then we easily reconcile all the different replicas in our system with a simple merge operation that we know cannot fail. These data types are known as conflict-free (sometimes commutative or convergent) replicated data types (CRDTs).

It seems straightforward to create, say, CRDT counters, but can we create CRDTs for complex data types such as sets? It turns out we can. There are wide variety of CRDTs available.

Noel Welsh

Noel has been interested in computers for a long time, particularly the leverage that computers give to people. He followed this interest to a PhD in machine learning, focusing on Bayesian nonparametrics and reinforcement learning. He still finds machine learning very interesting, but right now is more involved with programming and programming languages. A large part of his work is helping people become more effective with functional programming.

Akka for the rest of us

Akka is a toolkit and runtime for building highly concurrent, distributed and fault tolerant event-driven applications, but it can also be very useful for those of us who more commonly build applications that run happily on a single EC2 micro.

Phil Wills

Phil is senior software architect at the Guardian. He has worked on just about every part of the Guardian's site and the tools which support it; building features, optimising performance and increasing resilience.

Other Years

Thank you to our sponsors and partners