Monday, 2nd - Tuesday, 3rd December at Kings Place, London

35 experts will be speaking. Starts at 9:00 AM.

The Scala eXchange returns to Skills Matter for it's third year - share, learn and innovate with 350+ attendees, 60+ presentations, and the world's greatest Scala Rock Stars!

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.

Thanks to our sponsors

LENSES: COMPOSITIONAL DATA ACCESS AND MANIPULATION.

Haskell lets you write beautiful, modular code. Rather than waffle generally, I’ll use this talk to look at a particular example, Edward Kmett’s lovely lens library.

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.

Akka in Practice: designing actor-based applications

In this talk we will show you what we have learned from multiple years of designing serious, real-world applications with Akka.

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

There's a Prolog in your Scala!

This talk aims to shed some light on how Scala's type-level programming is essentially logic programming, and give reasoning for code, comprising 8+ implicit parameters with funny names (FnHipsterAux).

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 language...in 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.

What's new in Lift 3

David Pollak, Lift's founder, discusses some of the new features in Lift 3 including Streaming Promises (awesome for AngularJS work), Client-side Actors (send a message to a server-side Actor and magically it invokes a function in the browser and vice versa), asynchronous REST, and some of the enhancements to Lift's templating (support for arbitrary tags as well as data- attributes).

David Pollak

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

Metascala: a tiny DIY JVM

Metascala is a tiny metacircular Java Virtual Machine (JVM) written in the Scala programming language. Metascala is barely 3000 lines of Scala, and is complete enough that it is able to interpret itself metacircularly. Being written in Scala and compiled to Java bytecode, the Metascala JVM requires a host JVM in order to run.

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.

Haoyi Li

Haoyi is a recent MIT Graduate. He spent his years in college trying to build websites, and wondered why it always felt like bashing your head against a brick wall.

Lift 3 - High and Lifted Up

This talk will demonstrate the new features of Lift 3 on one side and also touches the topic of integrating client side JavaScript frameworks like Angular.js into an application architecture.

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".

Implicit Conversions => Implicit Parameters

In this talk, Bill Venners will tell the story of the journey from a design that leaned towards implicit conversions in ScalaTest 1.0 to one that emphasizes implicit parameters in ScalaTest and ScalaUtils 2.0.

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 the lead developer and designer of ScalaTest, an open source testing tool for Scala and Java developers, and coauthor with Martin Odersky and Lex Spoon of the book, Programming in Scala.

Failure: Deal with it!

As Scala programmers we solve a wide range of problems; from the tiniest bugfixes to the most interesting features—however no matter how flawless and well-tested and well-typed our code is, there is something that we should never forget: Reality—a place where things get FUBAR all the time—so lets talk about what can and will go wrong, and what strategies we have to deal with it; to recover; to heal our systems.

Viktor Klang

Viktor Klang, also known as √, is a passionate programmer with a taste for concurrency paradigms and performance optimization. Viktor is Chief Software Architect at Typesafe.

What Are Macros Good For?

This talk will outline what Scala macros are, and in what capacity the notion of compile-time metaprogramming can be useful to you, on a series of concrete use cases from research and industry. You will see how Slick, Play, Shapeless, Akka, Pickling, Async, Specs, and others use macros and will learn how to apply those techniques.

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

Being a metaprogramming aficionado, I believe that metaprogramming can be applied to mainstream programming in a safe and disciplined way. Since fall 2011, as a member of the Scala team and Martin Odersky’s PhD student, I am realizing this vision in

#ThisWeekInScala

This presentation takes you on the journey that Cake Solutions have taken in contributing to the Scala community as well as the Scala app that has been created to keep the service ticking along.

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.

How to please everyone, all the time - lessons in Scala API design

How do you design a library which satisfies a dozen different use cases? How can the same API be ideal for the rigour of a mission-critical production environment, yet still perfect for quick scripting in the REPL?

How can the same methods be equally well-suited to blocking and asynchronous code? How do you design an API which interacts seamlessly with a third-party library that hasn't even been conceived yet?

Jon will answer these questions with the simple application of some of Scala's more advanced features, taming implicits, type classes and type constructors to enable every Scala user (even beginners) to benefit from some cool and cunning new patterns in library design.

Jon Pretty

Jon has been an active member of the Scala community since 2004, when he launched the first commercial application in Scala. Since then, he's successfully deployed Scala in small businesses, large corporations, and government. Jon is the developer of the open-source Rapture I/O libraries.

Let The Types Set You Free

Types in functional programming should be embraced as they can model the logic intended to be codified into software more accurately and succinctly. From the basic to the more powerful we can provide both the pragmatic and the powerful building blocks that are necessary to build any systems.

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.

Introducing Adept

Dependency management should be something nobody should need to relate to, yet a surprising amount of time is spent on this aspect which should simply work. Adept is a new dependency management system in Scala, here to change the way it is done on the JVM. This talk will be about what Adept is, why you should care and how you can help.

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 Typesafe Fredrik is mainly teaching Scala and Play courses and helping customers to adopt these technologies.

Scala.js: write in Scala for the browser

Ever dreamed of writing you next Rich Internet Application in Scala, enjoying all the Scala goodness, but not sacrificing JavaScript interoperability? Then come and meet Scala.js, a Scala to JavaScript compiler

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.

Sebastien Doeraene

Sébastien Doeraene is a compiler/runtime systems hacker and a Scala enthusiast. He is a Ph.D. student at EPFL in the programming methods laboratory (LAMP) led by Martin Odersky, also known as the Scala team, where he designs and develops Scala.js.

spray: HTTP for your Akka Actors

Spray is an open-source toolkit for building REST/HTTP-based integration layers on top of Akka and the basis for the coming akka-http module. It provides a fast, fully-featured client- and server-side HTTP stack on top of the new Akka IO layer.

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 spray.io, 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 does the catwalk

In this session we will share our experience at Net-a-porter, creating our first reactive Scala/Akka/Spray service in a company with a long-standing Java codebase and production infrastructure.

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.

JScala - write your JavaScript in Scala

"JScala is a Scala macro that produces JavaScript from Scala code. I'll present JScala features including fully working Tetris example. The game is written in Scala which translates to JavaScript that you can run in your browser and have some fun.

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

#SCALAX PARK BENCH PANEL & PARTY

Join the #ScalaX Park Bench Panel to debate the day's talks with the experts and delegates. Have an opinion? Come share it and take the place of a panellist! After the Park Bench Panel we celebrate the day with drinks and nibbles.

The Road to Akka Cluster, and Beyond…

With the advent of mobile devices, NoSQL databases and cloud services, you most likely already have a distributed system at your hands. Distributed computing is the new norm. Writing distributed applications is both more important and more challenging than ever. In this talk Jonas takes you on a journey across the distributed computing landscape. Along the way he discusses the decisions and trade-offs that were made when creating Akka Cluster, its theoretical foundation, why it is designed the way it is and what the future holds.

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 the co-founder and CTO of Typesafe. He is a entrepreneur, programmer, teacher, mentor, speaker and author who spends most of his time hacking on open source and lecturing and speaking at developer conferences world-wide.

#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.

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 Macháček is the technical director at Cake Solutions, highly experienced Java enterprise architect, consultant and developer with very strong technical and team management skills.

Macro-based Scala Parallel Collections

This talk addresses Macro-based Scala Parallel Collections with a particular focus on what the new design means for the users.

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

Dmytro Petrashko is a programming languages and algorithms researcher and a doctoral assistant at EPFL. He is currently working on a doctorate as a research assistant in the School of Computer and Communication Sciences at the EPFL in Switzerland, in

Reconciling Eventually-Consistent Data with CRDTs

Would you like to learn how to reconcile eventually consistent data? Join Noel's talk and learn how to do this through conflict-free (sometimes commutative or convergent) replicated data types (CRDTs). In this talk Noel will describe the foundations of CRDTs, give some examples of known data types in Scala, and discuss issues that arise in practice. You will learn how to create straightforward CRDT counters, as well as how to create CRDTs for complex data types such as sets.

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 is a partner at Underscore, the leading Scala consultancy. Noel has over fifteen years experience in software architecture and development, and over a decade in machine learning and data mining.

WOOT for Scala, JavaScript and Lift

Ever wondered how systems like Google Docs can handle concurrent user editing, and give consistent results to everyone? There are a class of algorithms that try to achieve just that, and in this presentation we'll look at one, WOOT, and how it can be expressed in Lift.

Richard Dallaway

Richard Dallaway is an active member of the Scala User Group and regularly blogs about Scala and Lift on his blog: richard.dallaway.com.

Scala and graphs

In this talk I'll introduce this way of modelling data using Neo4j, the world's leading graph database. I'll show how to write queries using Neo4j's Cypher query language, and will discuss the Scala specific tools you can use to build your own graph based applications.

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 is a graph advocate and field engineer for Neo Technology, the company behind the Neo4j graph database. As a field engineer, Mark helps customers embrace graph data and Neo4j building sophisticated solutions to challenging data problems.

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

Futures, actors or iteratees make code easier to write and reason about, and in this talk I'll show a simple solution to make them easier to debug. The tool I present integrates well with the Eclipse plugin for Scala, and shows how a "reactive debugger" might look like.

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 Dragos is a key member of Martin Odersky’s EPFL's Scala team. For the last six years he has been the main contributor for many critical Scala components including the compiler backend, its optimizer and the Eclipse build manager.

Hidden Gems in ScalaTest 2.0

In this talk, Bill Venners will guide you through ScalaTest 2.0 by pointing out lesser-known features of the testing toolkit that can help you get stuff done. You'll gain insight into what ScalaTest offers, why ScalaTest is designed the way it is, and how you can get more out of it.

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

Bill Venners

Bill Venners is the lead developer and designer of ScalaTest, an open source testing tool for Scala and Java developers, and coauthor with Martin Odersky and Lex Spoon of the book, Programming in Scala.

Clojure + REPL = fun

Neale will live code a complete data visualisation application in clojure using the REPL, demonstrating why working in clojure is fun, fast and exciting.

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.

Akka for the rest of us

In this talk I aim to convince you that, even if you're not building a distributed system processing millions of transactions per second, Akka is a toolkit which can help build correct, elegant solutions. I'll demonstrate patterns from production apps at the Guardian to illustrate this.

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.

Take Flight : Using Spaces in Scala

This talk will show how to use the power of Space based systems in Scala. With a simple REPL showing the foundations of the Space API, leading to an example application built using Fly Object Space and the Play Frame work as examples.

Asher Glynn

Asher has over 18 years experience in the IT industry, and will use the most appropriate technology at hand, most recently Scala but also Java, Javascript and sometimes Visual Basic.

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.

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

In this talk though we'll focus on Scalding - a library, developed at Twitter, but used by many others - including eBay - to simplify and bring back the joy to Big Data by using a thin layer of Scala on top of Cascading to build-up data processing "as if it was a simple map { transformation } in plain Scala!

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 a late-night passionate programmer, currently working at eBay. His favourite platform is the JVM, with his current favourite being Scala. Other than that, he's a fan of automating every possible task and ridiculously long keyboard shortcuts

Play, sbt and its compilers

Ever wondered how the Play framework's reload magic works? And what about those compilers for JavaScript and CoffeeScript? The answer is a sbt plugin. Join Typesafe's Fredrik in an inquisitive dive into Play from the sbt point of view and learn more about Play, sbt and how to support your very own format!

Fredrik Ekholdt

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

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

At the start of the year we set out to create The Netbook, a fashion-based social network, from scratch. These are some lessons we learnt building its REST API backend using Scala, Akka and Spray; and deploying 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.

Patterns for Slick database applications

This talk suggests particular solutions to these problems. We will be looking at reducing boiler-plate, re-using code between queries, efficiently modelling object references and more.

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.

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

This talk will explore the benefits and power of this new Akka I/O layer, including a brief exploration of its benefits over the "Old" Akka IO. The presenter will introduce the ByteString & it's powerful manipulation tools for network traffic, the Pipeline system for composed protocol decoding, and much more.

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

A polyglot programmer, Brendan has made various contributions to Open Source in the past including building a Linux Driver for the Lego Mindstorms system — which now ships with the kernel. Brendan McAdams works at Netflix having previously worked within the Professional Services team at Typesafe.

Kings Place

With award-winning spaces, unrivalled technology capabilities, fantastic transport links and history of working with the world's biggest brands Kings Place is the perfect conference venue!

Jkldgoia5ssuqfvlrr4m

Kings Place

90 York Way, London, N1 9AG, GB


View details, travel and nearby hotels

To discuss sponsorship opportunities please contact the team:

Thanks to our sponsors