Scala Days

May 30th- June 2nd, 2017 Copenhagen

Keynotes


Pre-Conference Community Events

ScalaBridge, Tuesday May 30, 09:00 - 17:00
ScalaBridge is a fun and friendly introduction to Scala, with an explicit goal of encouraging diversity in the Scala community. To coincide with Scala Days, a ScalaBridge will be held in Copenhagen at Bella Center on Tuesday, 30th of May, from 9am to 5pm. It's completely free to attend, but you need to register here.

We ask that attendees have a bit of programming experience (any language is fine) and are from a group that is underrepresented in the Scala community, broadly interpreted.
If you are an experienced Scala developer, and interested in helping out as an instructor, we also want to hear from you.

ScalaBridge has three goals:

  • To have fun! Always the most important goal at ScalaBridge. Our curriculum is based around expressing your creativity through computer graphics. It is explicitly designed for people who don't have the science / engineering / maths background that is typical of programmers.
  • To show that programming is a systematic task. If you follow some recipes you can't go wrong.
  • To set you up for future learning. We want to provide you with enough background that you can pick up other programming material (and particularly functional programming material) and not feel completely lost.

Open Source Spree, Wednesday May 31, 10:00 - 16:00
The Scala Center is organizing an Open Source Spree in Copenhagen on May 31st. The focus of Scala Sprees is to introduce newcomers and veterans alike to open source! Come meet contributors of well-known open source Scala projects and learn how you can make your own contribution. More details available here and you need to register here


App

Download the Scala Days App in order to see the latest version of the schedule, vote sessions, follow the #scaladays twitter streamand much more: For iOS / For Android

If you have any questions please contact us at scaladays@trifork.com

About

Scala Days Copenhagen

Scala Days, the premier Scala Conference, will be held this year at Bella Center in Copenhagen. Trainings will be on May 30th - 31st, 2017, and the conference will be held from May 31st - June 2nd, 2017. The conference will start after the trainings - so don't panic, you can attend both training and conference! There will also be a Scala Days US at the Swissotel in Chicago on April 18th - 21st, 2017. 

 

The conference will bring together developers from all corners of the world to share their experiences and new ideas around creating applications with Scala and related technologies, like Akka and Play Framework. Scala Days provides a unique opportunity for Scala users to interact with the contributors to the language and related technologies and connect with fellow developers.

 

Leaders from Scala User Groups and communities around the globe, students and language contributors, will gather to discuss academic research, use-cases and visionary projects for a two day, action-packed event.

Last year’s conferences in New York and Berlin were sold-out events!

Wednesday (31st May.)
16:00 Registration
ROOM A2+A3
17:00
Keynote: What's Different In Dotty
Martin Odersky
Scala Creator & Co-Founder of Lightbend
Close
Keynote: What's Different In Dotty
Martin Odersky
Scala Creator & Co-Founder of Lightbend

Martin Odersky created the Scala programming language and is a professor in the programming research group at EPFL, the leading technical university in Switzerland. Throughout his career, Martin's singular objective has been to make the basic job of writing programs faster, easier and more enjoyable. In the process, he has personally written more lines of Java and Scala code than almost any other individual in the world. He wrote javac, the compiler used by the majority of today's Java programmers, and scalac, the compiler used by the fast-growing Scala community. He authored "Programming in Scala," the best-selling book on Scala. Previously he has held positions at IBM Research, Yale University, University of Karlsruhe and University of South Australia, after having obtained his doctorate from ETH Zürich as a student of Niklaus Wirth, the creator of Pascal.

Twitter: @odersky

Wednesday (31st May.) 17:00
Dotty is the project name for the next iteration of the Scala language. As we are nearing a first developer preview, this talk will give a summary of the major changes and innovations as they are currently implemented. I will show with many examples how you can increase the legibility and safety of your Scala programs using the new features.
18:00
Welcome Reception sponsored by Databiz and Lunatech
Close
Welcome Reception sponsored by Databiz and Lunatech
Wednesday (31st May.) 18:00
Thursday (1st Jun.)
08:00 Registration
09:00
Keynote: Tools for Verified Scala
Viktor Kuncak
EPFL
Close
Keynote: Tools for Verified Scala
Viktor Kuncak
EPFL
Thursday (1st Jun.) 09:00
I will speak about tools for code verification, synthesis, and repair that my research group at EPFL developed over the past years.
10:00 Break
ROOM Aud. 11 Aud. 12 Aud. 15 A2+A3
TRACK
Track 1 - Beginner Thursday
Track 2 - Intermediate Thursday
Track 3 - Intermediate Thursday
Track 4 - Intermediate Thursday
10:25
Easy and Efficient Data Validation with Cats
Daniela Sfregola
Director @Daniela Tech LTD
Close
Easy and Efficient Data Validation with Cats
Daniela Sfregola
Director @Daniela Tech LTD
Daniela Sfregola is a Software Consultant based in London, UK. She is an active contributor to the Scala Community and a passionate blogger at danielasfregola.com.
Thursday (1st Jun.) 10:25

Often when we create a client/server application, we need to validate the requests: can the user associated to the request perform this operation? Can they access or modify the data? Is the input well-formed?

When the data validation component in our application is not well designed, the code can quickly become not expressive enough and probably difficult to maintain. Business rules don't help, adding more and more requirements to add in our validation, making it more and more complex to clearly represent and maintain. At the same time when the validation fails, it should be fairly straight forward to understand why the request was rejected, so that actions can be taken accordingly.

This talk introduces Cats, a Scala library based on category theory, and some of its most interesting components for data validation. In particular we'll discuss some options to achieve efficient and expressive data validation. We will also argue that, compared to other options in the language, Cats is particularly suited for the task thanks to its easy-to-use data types and more approachable syntax.

Throughout the talk, you will see numerous examples on how data validation can be achieved in a clean and robust way, and how we can easily integrate it in our code, without any specific knowledge of category theory.

8 Akka anti-patterns you'd better be aware of
Manuel Bernhardt
Reactive Systems Consultant @manuel.bernhardt.io
Close
8 Akka anti-patterns you'd better be aware of
Manuel Bernhardt
Reactive Systems Consultant @manuel.bernhardt.io
Manuel Bernhardt is a passionate engineer, author, speaker and consultant who has a keen interest in the science of building and operating networked applications that run smoothly despite their distributed nature. Since 2008, he has guided and trained enterprise teams on the transformation to distributed computing. In recent years he is focusing primarily on production systems that embrace the reactive application architecture, using Akka, Play Framework, Scala and Java to this end.

Manuel likes to travel and is a frequent speaker at international conferences. He lives in Vienna where he is a co-organizer of the Scala Vienna User Group. Next to thinking, talking about and fiddling with computers he likes to spend time with his family, run, scuba-dive and read. You can find out more about Manuel's recent work at http://manuel.bernhardt.io
Thursday (1st Jun.) 10:25
CAUTION: If you are responsible for an Akka system deployed to production, attending this talk may cause intense moments of self-doubt, stress and possibly panic.

Akka is a toolkit for building highly concurrent and distributed applications on the JVM using the actor model. Given the prevalence of frameworks over toolkits and models in the industry, it is easy to forget that the former will not prevent you from using them in any way you please – including ways that are possibly suboptimal or perhaps even harmful.

In this talk you'll learn about a few of the most common anti-patterns related to Akka usage. You'll also get to know about alternative and more appropriate solutions to use for each one of those anti-patterns. It should be noted that these suboptimal uses of Akka are not merely theoretical ponderings but real and recurring observations that the speaker made during a range of consulting projects.
Bifurcation Without Schism: The Scala Ecosystem
Tomer Gabel
System Architect @Wix
Close
Bifurcation Without Schism: The Scala Ecosystem
Tomer Gabel
System Architect @Wix
A programming junkie and computer history aficionado, Tomer's been around the block a few times before settling at Wix as a system architect. In the last few of years he's developed a major crush on Scala, promoting it within the Israeli software industry as part of Java.IL (Israeli Java user group) and Underscore (Israeli Scala user group) and organizing the annual Scalapeño conference in Tel-Aviv.
Thursday (1st Jun.) 10:25
Since the dawn of time, the Scala community has been fairly split in two: functional programming aficionados on one end of the spectrum, and Scala-as-a-better-Java on the other. It is remarkable that the two communities coexist happily, and I believe there is a valuable lesson to be learned here, because the Scala community is also split along a much more divisive axis: the language aficionados looking to exploit the language to its fullest, and the "blue collar" developers striving for simplicity.

I've lately come to the realization that this apparent bifurcation of the community, if managed carefully and its challenges tackled head-on, is actually a GOOD thing because it means we get the best of both worlds: crazy-powerful libraries alongside a practical, productive language for your everyday job! In this talk I'll outline what I think these challenges are, and hopefully start a discussion on how to solve them.
Fast startup & low latency: pick two
Denys Shabalin
Research Assistant @EPFL
Close
Fast startup & low latency: pick two
Denys Shabalin
Research Assistant @EPFL
Denys is a research assistant at LAMP/EPFL and the project lead of the Scala Native project. His interests include implementation of modern programming languages, memory management and metaprogramming.
Thursday (1st Jun.) 10:25
JVM is a blessing. JVM is a curse.

Startup time and predictable performance are extremely hard to achieve on the JVM due to the complexity of the underlying VM. This makes Scala unsuitable for writing applications that are sensitive to these requirements.

In this talk, we're going to show how Scala Native enables lightweight system programming without breaking a sweat.
11:10 Break
11:35
GraphQL - a type system for your API
Oleg Ilyenko
Software Engineer @commercetools GmbH
Close
GraphQL - a type system for your API
Oleg Ilyenko
Software Engineer @commercetools GmbH
I am a backend engineer, creator of a scala GraphQL implementation Sangria, scala dependency injection library Scaldi and author several blogs (http://hacking-scala.org, https://medium.com/@oleg.ilyenko). I'm also a co-organizer of Berlin GraphQL user group. Passionate about scala, functional and functional-reactive programming, API design and agile management.
Thursday (1st Jun.) 11:35
In July 2015 Facebook released the first draft of GraphQL specification. GraphQL provides an alternative to the REST API with a high emphasis on efficient data retrieval and introspection with a powerful type system behind it. It allows you to build the client applications based on highly decoupled components without sacrificing performance or over-/under-fetching a data. GraphQL is ideal for any application that requires very precise and performant data fetching/manipulation, like mobile applications. GraphQL type system is not only a perfect fit for scala applications, but it also opens a door for a brand new set of tools for API discovery, documentation, and code generation. In this talk I would like to give an introduction to GraphQL - the concepts behind it and how it addresses common API design challenges like versioning, documentation, and discovery. You will learn how you can start using GraphQL today in your scala applications with Sangria - a scala GraphQL implementation.
Learn you Akka Streams for great Good!
Heiko Seeberger
Codecentric
Close
Learn you Akka Streams for great Good!
Heiko Seeberger
Codecentric
Heiko Seeberger is Fellow at codecentric and an internationally renowned expert on Scala and Akka. He has more than 20 years of experience in consulting and software development. Heiko tweets under @hseeberger and blogs under heikoseeberger.de
Thursday (1st Jun.) 11:35
Stream processing has become ubiquitous and Akka Streams, an implementation of the Reactive Streams specification, is one of the hottest kids on the block. In this talk we not only cover the essentials, but also introduce some advanced features like working with materialized values and cyclic graphs. As we strongly believe in writing code as the best way to learn coding, we show zero slides, but a lot of live code and live demos instead.
Building code analysis tools at Twitter
Stu Hood
Software Engineer @Twitter
Eugene Burmako
Software Engineer @Twitter
Close
Building code analysis tools at Twitter
Stu Hood
Software Engineer @Twitter
Long term user and advocate, medium term Scala build engineer. Helping to make it as pleasant to build Scala as it is to write it.
Eugene Burmako
Software Engineer @Twitter
Member of the Scala language team, founder of Scala Macros and Scala Meta.
Thursday (1st Jun.) 11:35
At Twitter, we’re working with millions of lines of Scala code, and that makes intelligent developer tools especially important. Multiple aspects of our development workflow, including code browsing, code review and code evolution, can be significantly improved if we go beyond just grep and ctags. In this talk, we will present our vision and hands-on experience with a next-generation code analysis toolkit based on the newly introduced scala.meta semantic API.
Quantifying and Explaining Immutability in Scala
Philipp Haller
Assistant Professor @KTH Royal Institute of Technology
Close
Quantifying and Explaining Immutability in Scala
Philipp Haller
Assistant Professor @KTH Royal Institute of Technology
Philipp Haller is an assistant professor in the department of theoretical computer science at KTH Royal Institute of Technology in Stockholm, the leading technical university in Sweden. Philipp is co-author of Scala's async/await extension for asynchronous programming, and one of the lead designers of Scala's futures library. Main author of the book "Actors in Scala," he created Scala's first widely-used actor library. Previously, Philipp held positions at Typesafe, Stanford University, and EPFL. In 2010, he received a PhD in computer science from EPFL.
Thursday (1st Jun.) 11:35
One of the main advantages of Scala is that it is a powerful functional programming language. Functional programming typically emphasizes programming with first-class functions and immutable data. Immutable data types enable fault tolerance in systems like Apache Spark, and ensure safe message exchange in Akka, among many other applications. However, beyond the distinction between vals and vars, Scala's type system does not have a built-in notion of immutability for type definitions. As a result, it is not possible to require, say, the generic type of a method parameter to be immutable (e.g., using a marker trait or a context bound). Instead, immutability is "by-convention" in Scala, and statistics about the use of immutability in real-world Scala code are non-existant.

This talk reports on the results of an empirical study on the use of immutability in medium to large open-source Scala projects, including but not limited to Scala's standard library. The study investigates both shallow and deep immutability, two widely-used forms of immutability in Scala. Perhaps most interestingly, for type definitions determined to be mutable, explanations are provided for why neither the shallow nor the deep immutability property holds; in turn, these explanations are aggregated into statistics in order to determine the most common reasons for why type definitions are mutable rather than immutable. Last but not least, this talk presents a plug-in for the Scala compiler, scala-immutability-plugin, which you can use to gather statistics on immutability in your own Scala projects.
12:20 Lunch
13:20
Introduction to gRPC with ScalaPB
Petra Bierleutgeb
Software Engineer and Consultant
Close
Introduction to gRPC with ScalaPB
Petra Bierleutgeb
Software Engineer and Consultant
Petra Bierleutgeb is an independent software engineer and consultant living in Munich. She is a Scala enthusiast and interested in FP, software architecture and infrastructure. Away from the keyboard, she greatly enjoys rock climbing and the outdoors.
Thursday (1st Jun.) 13:20
This talk will introduce the audience to writing gRPC applications in Scala using ScalaPB. gRPC is a modern, high-performance, open-source RPC framework focused on the requirements of connecting polyglot services in microservice-oriented systems. Its support of HTTP/2, protocol buffers, bi-directional streaming and type-safety make it an attractive alternative to traditional REST/JSON based service communication. gRPC support for Scala is available through ScalaPB - a community provided protocol buffer compiler that can be smoothly integrated into the sbt development workflow. Once integrated, ScalaPB will automatically generate the source code required for the implementation of the defined services and messages, as well as stubs for both synchronous and asynchronous clients. This talk will start with a short introduction to gRPC and its principles, followed by live coding examples of setting up gRPC with ScalaPB and implementing services and clients using various forms of gRPC communication styles, such as single request/response and bi-directional streaming. As a bonus - and if time allows - there will also be a demonstration about how to integrate gRPC with Akka Streams.
Akka support in IntelliJ IDEA
Andrew Kozlov
JetBrains
Close
Akka support in IntelliJ IDEA
Andrew Kozlov
JetBrains
Andrew has been a JetBrains employee since graduating with a B.Sc. degree in Computer Science. After falling in love with Scala joined the Scala plugin team. Currently is working on Akka and Dotty support in IntelliJ IDEA. Besides programming is interested in public speaking: has participated in several conferences (including ScalaDays), has been teaching programming courses for high school and university students for more than 5 years.
Thursday (1st Jun.) 13:20
Since Akka is one of the most popular Scala related frameworks, its support in IntelliJ IDEA has been just a matter of time. The purpose of the talk is to introduce one to Akka specific features of IntelliJ IDEA. Moreover this talk could be considered as an opportunity to suggest a killing feature that may be soon introduced.
Introduction to Spark Datasets
Holden Karau
Principal Software Engineer @IBM
Close
Introduction to Spark Datasets
Holden Karau
Principal Software Engineer @IBM
Holden Karau is transgender Canadian, and an active open source contributor. When not in San Francisco working as a software development engineer at IBM's Spark Technology Center, Holden talks internationally on Spark (see some selected videos at http://bit.ly/holdenSparkVideos) and holds office hours at coffee shops, at home and abroad. Holden is a co-author of numerous books on Spark including High Performance Spark (which she believes is the gift of the season for those with expense accounts) & Learning Spark. She makes frequent contributions to Spark, specializing in PySpark and Machine Learning. Prior to IBM she worked on a variety of distributed, search, and classification problems at Alpine, Databricks, Google, Foursquare, and Amazon. She graduated from the University of Waterloo with a Bachelor of Mathematics in Computer Science. Outside of software she enjoys playing with fire, welding, scooters, poutine, and dancing.
Thursday (1st Jun.) 13:20
Apache Spark is one of the most popular Big Data tools in the Scala Community & Datasets are the next evolution of its popular API. Spark Datasets allow for a hybrid approach to programming, mixing both functional and relational concepts on the same data. This talk will introduce the basics of working with Spark Datasets, as well as look at how Spark's own different components (machine learning & streaming) are being rewritten to expose Dataset compatible APIs. No existing knowledge of Spark is required, but a basic understanding of Scala is assumed.
Compiling like a boss!
Mirco Dotta
Co-founder @Triplequote
Iulian Dragos
CEO @Triplequote
Close
Compiling like a boss!
Mirco Dotta
Co-founder @Triplequote
Co-founder of Triplequote, a company aiming at boosting Scala teams' productivity. Mirco has 10+ year experience with Scala, and he has contributed to several open source projects such as Lagom, Playframework, Scala IDE for Eclipse, and the Scala language. Before founding his own company, he worked at Lightbend (formerly Typesafe), where he wore different hats: from engineering, to consulting, and, fun fact, even sales! He is a certified Lightbend trainer for Akka, Playframework, and Scala. He loves meeting people and sharing experiences. In his freetime, he plays chess and studies wine - both theory and practice! :) @triple_quote
Iulian Dragos
CEO @Triplequote
Iulian Dragos is a Lightbend-certified trainer for Scala and Spark and one of the top committers to the Scala IDE and Scala projects. He has learned Scala by writing the backend for it during his PhD in Martin Odersky's research lab at EPFL, back in 2004, and worked on various parts of the compiler and ecosystem since then.

He joined Lightbend (formerly Typesafe) from day 1, a start-up founded by the language creator, Martin Odersky, where he worked on development tools for Scala and later lead the Apache Spark team at Lightbend. In 2016 he founded Triplequote, a tooling company focused on enterprise needs for Scala.
Thursday (1st Jun.) 13:20
We all love Scala, but the one aspect we have a hard time accepting are long compile times. It’s not uncommon for a project to experience compilation times of a handful of minutes, if not worse. On top of that, compilation times are unpredictable, depending on a combination of language features, external libraries, and type annotations. A single line change may increase compilation times ten fold.
What can we do? It’s paramount we gain greater insight into the tools and libraries we use. There are also established (anti-)patterns that you should know about, if you fancy to keep compilation times to a minimum. And why not utilizing all cores when compiling? The stock Scala compiler can’t do it, but Triplequote Hydra is here to change that. Sit tight and let’s cut down on compilation time!
14:05 Break
14:30
Problem Solving Recipes Learned from Supporting Spark
Stavros Kontopoulos
Software Engineer @Lightbend
Justin Pihony
Developer Support Manager @Lightbend
Close
Problem Solving Recipes Learned from Supporting Spark
Stavros Kontopoulos
Software Engineer @Lightbend
Stavros is an R&D polyglot software engineer (Java, Scala, C, C++, Javascript). He has worked for several years building software solutions that scale in different verticals like telecoms and marketing. He’s currently working for Lightbend the company behind reactive applications, Scala, Akka, and Play. He helps with the implementation of the company’s fast data strategy. His interests among others are: distributed system design, streaming technologies, and NoSql databases. He is also a Phd student in the area of distributed indexing structures, social network analysis, and data structures.
Justin Pihony
Developer Support Manager @Lightbend
Justin is a software journeyman, continuously learning and honing his skills. He is currently using his knowledge to provide developer support at Lightbend. As much as he loves to learn, he also loves to spread his knowledge through teaching and helping others. He has authored three online courses for Pluralsight, including a Spark Fundamentals one, is one of the top Spark answerers on StackOverflow, and organizes the Pittsburgh Scala meetups.
Thursday (1st Jun.) 14:30
Due to Spark, writing big data applications has never been easier... at least until they stop being easy! At Lightbend we've helped our customers out of a number of hidden Spark pitfalls. Some crop up often; the ever-persistent OutOfMemoryError, the confusing NoSuchMethodError, shuffle and partition management, etc. Others occur less frequently; an obscure configuration affecting SQL broadcasts, struggles with speculating, a failing stream recovery due to RDD joins, S3 file reading leading to hangs, etc. All are intriguing! In this session we will provide insights into their origins and show how you can avoid making the same mistakes. Whether you are a seasoned Spark developer or a novice, you should learn some new tips and tricks that could save you hours or even days of debugging.
Streams, effects and beautiful folds, a winning trilogy
Eric Torreborre
Software engineer @Zalando
Close
Streams, effects and beautiful folds, a winning trilogy
Eric Torreborre
Software engineer @Zalando
I am a developer coding micro-services in Scala at Zalando, where we ship fashion all across Europe.

I created the specs2 testing library (http://specs2.org) and more recently the eff library, a very cool alternative to monad transformers (https://atnos-org.github.io/eff).
Thursday (1st Jun.) 14:30
Most applications are just reading data, transforming it and writing it somewhere else. And there are great libraries in the Scala eco-system to support these use cases: Akka-Stream, fs2, Monix,... But if you look under the hood and try to understand how those libraries work you might be a bit scared by their complexity!

In this talk you will learn how to build a very minimal "streaming library" where all the difficult concerns are left to other libraries: eff for asynchronous computations and resources management, origami for extracting useful data out of the stream. Then you will able to decide how to spend your complexity budget and when you should pay for more powerful abstractions.
Adventures in Metaprogramming: Macros versus Shapeless
Dave Gurnell
Underscore
Close
Adventures in Metaprogramming: Macros versus Shapeless
Dave Gurnell
Underscore
Dave is a Scala developer and consultant at Underscore. He has authored and co-authored several books on Scala, including The Type Astronaut's Guide to Shapeless and Advanced Scala with Cats. He has a decade's experience as a commercial functional programmer and has spoken at numerous conferences worldwide, including Scala Days, Scala Exchange, Scala World, and ICFP.
Thursday (1st Jun.) 14:30
In this talk we will compare three techniques for meta-programming in Scala: macros, shapeless, and code generation. Through a sequence of simple examples we will attempt to characterise the relative pros and cons of each technique, where they are most appropriate, and where they might turn around and bite you.

We can solve many Scala programming problems using simple tools: algebraic data types, higher order functions, and type classes. Sometimes our code can become verbose or unwieldy, and we have to search for ways to make it cleaner and more maintainable.

"Meta-programming" is a broad term describing techniques for generating code using code. It often provides the key to eliminating boilerplate, but the meta programming techniques listed above could not be more different. Identify the best meta-programming technique can be they key to saving hours of frustration attempting to go down blind alleys. This is the problem we will solve in this talk.

The talk is aimed at intermediate Scala developers who have a basic awareness of each technique. You don't need to know shapeless or macro programming to benefit.
Long-lived microservices
Jan Machacek
CTO @Cake Solutions
Close
Long-lived microservices
Jan Machacek
CTO @Cake Solutions
I help companies achieve exceptional growth and success through use of modern computing technologies; specifically large-scale machine learning and big data systems, particularly those that interact with IoT, wearables, mobiles as well as modern web applications. My experience and expertise allows me to advise on future technical strategies.

Naturally, I am a passionate technologist; I have hands-on experience with delivering large-scale systems—particularly those that bring together the data science and mathematics with modern engineering practices. I regularly contribute to open source projects, and I regularly speak at technical conferences.
Thursday (1st Jun.) 14:30
Jan will talk about building, maintaining and evolving production microservice systems over a many years. He will show architectural and implementation choices to implement distributed systems in vehicle IoT, reliable medical messaging, biometric security, and video streaming. The talk will cover everything from good Scala code, through best practices in use of Akka (Persistence, Cluster, HTTP, Streaming): highlighting the need for asynchronous I/O and messaging, while managing the complexity of implementation, debugging and monitoring, distributed state and the implication of maintaining distributed state particularly when it comes to consistency, all the way to documentable and expressive protocols and APIs.

Come to Jan's talk if you are about to start a large-scale microservices system and wonder what potential challenges await you: learn how to make the most of the Lightbend stack ecosystem of tools and frameworks, together with the necessary infrastructure to keep the system running. The examples Jan will show, together with the code on his GitHub repository, will give you the needed boost—years of consultancy experience—to your microservices project.
15:15 Break
15:40
ADTs For The Win!
Noel Markham
Senior Developer @47 Degrees
Close
ADTs For The Win!
Noel Markham
Senior Developer @47 Degrees
Noel started out as a Java developer in finance before moving to functional programming in startups for both games and social media. More recently, he has worked in broadcast media, and is currently working in London at 47 Degrees.
Thursday (1st Jun.) 15:40
Algebraic data types, ADTs, sometimes called sum types, coproducts or sealed trait families, are a killer Scala feature that possibly does not get the focus it deserves. While many developers are happy and comfortable using ADTs when provided from the language or a library, they often don't see the steps to take the next leap in creating ADTs for their own domain.

In this talk we will take a look at just what ADTs can do for you, covering some common classes that you don't even realise are ADTs from the standard library and also some well-known libraries, revisit pattern matching, and understand how the compiler can help us with techniques such as folding. Finally, we will develop a brand new collection type using our new-found knowledge.
Monix Task: Lazy, Async and Awesome
Alexandru Nedelcu
Lead Software Developer @Eloquentix
Close
Monix Task: Lazy, Async and Awesome
Alexandru Nedelcu
Lead Software Developer @Eloquentix
Alexandru is a software developer living in Bucharest, Romania, currently working for Eloquentix. A startup guy, by day he's been helping with projects for powering the next generation energy grid solutions and for advancing the health-care industry. By night he's fueled by his work on the Monix project, the Scala library for composing asynchronous and event-based programs. He's also a proud father, husband, has a very unhealthy sleep schedule and appreciates talking about programming over beer. Sometimes he blogs at https://alexn.org
Thursday (1st Jun.) 15:40
Scala’s Future from the standard library is great, but sometimes we need more. A Future strives to be a value, one detached from time and for this reason its capabilities are restricted and for some use-cases its behavior ends up being unintuitive. Therefore, while the Future/Promise pattern is great for representing asynchronous results of processes that may or may not be started yet, it cannot be used as a specification for an asynchronous computation.

The Monix Task is in essence about dealing with asynchronous computations and non-determinism, being inspired by the Scalaz Task and designed from the ground up for performance and to be compatible with Scala.js/Javascript runtimes and with the Cats library. It also makes use of Scala’s Future to represent results, the two being complementary.

In this talk I’ll show you its design, when you should use it and why in dealing with asynchronicity it’s better to work with Task instead of blocking threads.
DRY compiling!
Krzysztof Romanowski
Scala specialist @Virtuslab
Close
DRY compiling!
Krzysztof Romanowski
Scala specialist @Virtuslab
Krzysztof is Scala specialist @ Virtuslab where he has spent endless hours debugging Scala IDE, SBT, IntelliJ or even Scala compiler itself. Author of expression evaluator engine for Scala IDE and zinc contributor.
Thursday (1st Jun.) 15:40
How many time do you spent compiling your code after branch change?
Did you ever setup multiple copy of same repository just not to trigger full compilation?

Scala is known for it’s long compilation times. Dotty or Hydra compilers may help us here but we don’t expect order of magnitude speedup (and this is what we really want).

It’s time to change this!
Let’s reuse incremental compilations from CIs or your colleagues computers and save lots of time. You are one commit ahead of master? Don't worry - incremental compilation will do all the work for you!

Fixing critical problems in old releases? Open source project setup? Cached compilation can save your precious minutes there.

Add Hoarder plugin (github.com/romanowski/hoarder) to your sbt project and don’t repeat yourself compiling code that was already compiled!
Existential Types — Make OOP Great Again!
Julien Richard-Foy
Scala Center
Close
Existential Types — Make OOP Great Again!
Julien Richard-Foy
Scala Center
Julien Richard-Foy likes writing programs. In particular, he likes leveraging programming language features to solve engineering problems. He is fascinated by languages that make it easy to turn ideas into programs that are executable by machines and easy to reason about by humans. He writes tools and MOOCs for the good of the community, at Scala Center.
Thursday (1st Jun.) 15:40
Means of abstraction are the holy grail of programming languages. They allow developers to write programs by relying on other programs whose implementation details are unknown. But the more about these programs is unknown, the more difficult it is to manipulate and combine them in a correct (and useful) way.
This talk will explore the solutions brought by existential types and their encoding in Scala. You will learn what they can do and what they can not throughout concrete use cases, and how they compare to other alternatives for modularization (e.g. “basic” inheritance and typeclasses).
No theoretical background is required.
16:25 Break
16:50
Using Scala.js and functional reactive programming for developing (enterprise) applications
Thomas Gawlitza
Development manager @SAP
Fabian Schmitthenner
Developer @SAP
Close
Using Scala.js and functional reactive programming for developing (enterprise) applications
Thomas Gawlitza
Development manager @SAP
Fabian Schmitthenner
Developer @SAP
Thursday (1st Jun.) 16:50
In this talk, we give an overview over a project that we are conducting at SAP. The goal of this project is to build a Scala-based application development stack that enables developers to easily build cloud applications that integrate with SAP systems. The application development stack we are building embraces Scala all over the place – including the development of user interfaces for which Scala.js is utilized to provide a type-safe interface to SAP's own JavaScript UI library SAP UI5. Our stack is tailored to the needs of application developers who work within the SAP ecosystem and focuses on simplicity, for instance, provided by embedded domain-specific languages.

After a brief overview of how we are using Scala within our project at SAP, we deep dive into one particular subproject that we also recently released as an open-source library called "Dive". The library provides functionality for functional-reactive programming as descriped in Ingo Maier and Martin Odersky's article 'Deprecating the Observer Pattern' from 2010. We use this library within our UI library.
Taming Distribution: Formal Protocols for Akka Typed
Roland Kuhn
CTO and co-founder of Actyx
Close
Taming Distribution: Formal Protocols for Akka Typed
Roland Kuhn
CTO and co-founder of Actyx
I am CTO and co-founder of Actyx, author of Reactive Design Patterns, a co-author of the Reactive Manifesto, co-teacher of the Coursera course “Principles of Reactive Programming”, and a passionate open-source hakker. Previously I led the Akka project at Lightbend. I also hold a Dr. rer. nat. in particle physics from TU München and have worked in the space industry for several years. I spend most of my life in the central European timezone.
Thursday (1st Jun.) 16:50
Cloud computing, reactive systems, microservices: distributed programming has become the norm. But while the shift to loosely coupled message-based systems has manifest benefits in terms of resilience and elasticity, our tools for ensuring correct behavior has not grown at the same pace. Statically typed languages like Java and Scala allow us to exclude large classes of programming errors before the first test is run. Unfortunately, these guarantees are limited to the local behavior within a single process, the compiler cannot tell us that we are sending the wrong JSON structure to a given web service. Therefore distribution comes at the cost of having to write large test suites, with timing-dependent non-determinism.

In this presentation we take a first peek at ways out of this dilemma. The principles are demonstrated on the simplest distributed system: Actors. We show how parameterized ActorRefs à la Akka Typed together with effect tracking similar to HLists can help us define what an Actor can and cannot do during its lifetime—and have the compiler yell at us when we do it wrong.
Scala Meta Live Coding Session
Pathikrit Bhowmick
Principal Engineer @Coatue
Close
Scala Meta Live Coding Session
Pathikrit Bhowmick
Principal Engineer @Coatue
Pathikrit is a Principal at Coatue Management where he enjoys using Scala to solve complex problems in finance. He is also the author and maintainer of many popularly used open source Scala libraries like better-files and scalgos. Pathikrit's interests include functional programming, databases and algorithms.
Thursday (1st Jun.) 16:50
In this talk, we will have an interactive live coding session where we will use Scala Meta to code something useful (a code generator for your REST API). Hopefully this will embolden other Scala users to explore macros for profit and fun without fear.
Reconstructing Scala
Felix Mulder
Release Manager & Compiler Engineer @EPFL
Close
Reconstructing Scala
Felix Mulder
Release Manager & Compiler Engineer @EPFL
Felix is the release manager for the next generation Scala compiler, Dotty, being developed by Martin Odersky's lab at EPFL. He started his foray into Scala by re-engineering the Scaladoc tool for Scala 2.12 and was subsequently hired to work on Dotty at EPFL.
Thursday (1st Jun.) 16:50
The new Scala compiler is nearing beta readiness. A lot of thought has gone into designing Dotty to be as fast and structurally sound as possible. Now comes the next step - adding a new level of usability to the compiler and the surrounding tools.
In this talk I want to show what Dotty can offer you as a developer in terms of improved experience - whether it is awesome error messages, rewrite rules or optimizations.
I will also talk about how we are optimizing the project for outside contributors, and what you can do to get involved today!
17:35 Break
18:00
ScalaQuest: the Scala adventure
Alejandro Lujan Toro
Senior Developer and Trainer
Close
ScalaQuest: the Scala adventure
Alejandro Lujan Toro
Senior Developer and Trainer
As a Senior Software Developer & Trainer, I split my time between architecting and building software, and coaching others on how to effectively use the Lightbend Reactive Platform.

I have a strong passion for teaching and coaching others, and I'm lucky to do a lot of professional training in Scala, Akka and Play. This has allowed me to interact with hundreds of people who are new to these technologies, as well as many other experts in charge of building and supporting the platforms.

I also contribute to the Scala community by organizing Scala Up North, the first and only Scala conference in Canada.
Thursday (1st Jun.) 18:00
ScalaQuest is a fun, enticing game that will take you from Zero to Hero in your path to learning Scala (1).
You will battle Goblins and Wizards and face all kinds of challenges to prove your worth.
Start on the warm, safe haven of plain harmless classes, hike over Variance Hills and make your way to the treacherous implicit forests.

Our goal with ScalaQuest is to make it one of the least painful ways to learn Scala. This might be the first time you ask your team members to play a game during work hours.

In this talk, we will showcase our work in progress with ScalaQuest, and share our experience building it - our design decisions and the challenges we've faced. We will then focus on the technical challenges related to compiling user-submitted code on the server side while trying to keep a snappy UI.
--
(1) or will be, at some point in the future, hopefully.
The best is yet to come - State of Akka in 2017
Konrad Malawski
Akka dev. @Lightbend
Close
The best is yet to come - State of Akka in 2017
Konrad Malawski
Akka dev. @Lightbend
Konrad is a late-night passionate hakker currently living in Tokyo and still believing in his motto: "Life is Study!". At Lightbend he's part of the core Akka team, and has contributed mostly (but not only) to the core, persistence, new remoting as well as maintaining Akka HTTP. In the past he's helped startups write high performance service backends as well as huge corporations such as eBay get started with Scala. His favourite discussion topics range from distributed systems and high performance algorithms to photography and capybaras. He has founded and run multiple user groups (Java, Scala, Computer Science, ...), and is part of program committees of awesome conferences such as GeeCON and JavaOne SF. In those rare times he's not coding, he spreads the joy of computer science by helping local user groups and whitepaper reading clubs. He also holds number of titles, including the "Best ScalaDays NY talk 2016" and Java One RockStar 2015.
Thursday (1st Jun.) 18:00
The last years have brought Akka the largest changes since the initial 2.x rewrite yet it remained fully compatible across the last years. With the new exciting modules like Akka Streams, Akka HTTP (including the most recent HTTP/2 work) and the new remoting reimplementation codenamed Artery, we've stepped into the era of Akka 2.5 already. Which again, remains backwards compatible as previous releases. What's in there, and what's next for Akka in general?

In this talk we'll take a brief look back at the newest stable modules of Akka itself, as well as new projects such as Alpakka. Next, we'll continue with the (then present) 2.5 version and the stable Persistence Query, high-availability CRDT support in Distributed Data and continued work on the Artery remoting. Finally we'll have a sneak peek at what's coming in the next releases, which among other things include Akka Typed and more!
Vert.x 3 goes Scala
Jochen Mader
Lead IT Consultant @codecentric
Close
Vert.x 3 goes Scala
Jochen Mader
Lead IT Consultant @codecentric
Grew up as C64-nerd, got into Basic, C and Assembly. Found the JVM and fell in love. Since then I've been constantly wandering through the world of IT, always focusing on highly available distributed systems. Scala was definitely not love at first sight, but I got enlightened after trying a round of Haskell. Today I am happy to work with a bunch of very creative and fun people in Scala-heavy projects.
Thursday (1st Jun.) 18:00
Vert.x is a polyglott toolkit to build reactive applications on the JVM. It is based on a simple yet powerful threading concept and provides very easy cluster managed.
I will introduce the brand new Scala-stack that has just been added to the core framework and opens all its capabilities to the Scala-world. The main topics of this talk will be:
- a walkthrough for the current stack and available modules
- bootstrapping an SBT-Vert.x-project with the provided project blueprint
- running, testing and deploying of Vert.x-microservices
- how Scala enhances the Vert.x programming experience
- a full demo of an elastic Vert.x-cluster

Expect a lot of code and room for discussions.
Monad transformers down to earth
Gabriele Petronella
Software Engineer @Buildo
Close
Monad transformers down to earth
Gabriele Petronella
Software Engineer @Buildo
Functional bit flipper, building awesome things in scala and react at buildo.io

Stackoverflow addict.

Organizer of Milano Scala Group and Scala Italy conference.

When not coding or organizing events, he's either on a plane or at the basketball court.
Thursday (1st Jun.) 18:00
Monad Transformers. "WAT?" "Exactly"
In this session we'll see what monad transformers are, where their need comes from and how to use them effectively

We'll walk through this rather complicated topic guided by real-life examples, with the noble intent of making our code more readable, maintainable and pleasant to work with.

Finally we'll see how Monad Transformers are just one of possible tools to solve the "effect stacking" and hint at other possible solutions.

WARNING
This talk contains slides that some viewers may find disturbing, most of them containing words like "monad" and/or "functors".

Listener discretion advised.
18:45
Community Party sponsored by Lunatech
Close
Community Party sponsored by Lunatech
Thursday (1st Jun.) 18:45
19:30
Ignite Sessions
Close
Ignite Sessions
Thursday (1st Jun.) 19:30
Scala Days Ignite Sessions is a new feature of Scala Days for 2017! All the speakers will each give a 5 min/20 slide presentation on a topic that interests YOU.

Join us during the Community Party in Auditorium 15 for Ignite sessions. Presentations will be (not necessarily in that order):

Fabrice Sznajderman: The beauty of pictures through years
Alessandro Vermeulen: Chaos-Testing Akka Applications with Multi JVM tests
Tamer AbdulRadi: How I contributed to Scala overnight!
Javier Arrieta: Synchronous Facade with Akka remoting
Noel Welsh: Creative Scala: Programming via the Visual Arts

Grab a drink, sit down and ENJOY!
Friday (2nd Jun.)
08:00 Registration
09:00
Keynote: Open source is just about the source, isn't it?
Isabel Drost-Fromm
Affiliation: Open Source Strategist Europace.de
Close
Keynote: Open source is just about the source, isn't it?
Isabel Drost-Fromm
Affiliation: Open Source Strategist Europace.de
Isabel Drost-Fromm is Open Source Strategist at Europace AG Germany. She's a member of the Apache Software Foundation, co-founder of Apache Mahout and mentored several incubating projects. Isabel is interested in all things FOSS, search and text mining with a decent machine learning background. True to the nature of people living in Berlin she loves having friends fly in for a brief visit - as a result she co-founded and is still one of the creative heads behind Berlin Buzzwords, a tech conference on all things search, scale and storage.
Friday (2nd Jun.) 09:00
Your project's code base is rock solid, you are rolling releases early and often, your test suite is comprehensive and running regularly, your code is well performing without any glitches. Everything is in place that defines a successful open source project - or isn't it?

This talk tries to highlight some of the key questions software developers will quickly be faced with when dealing with open source: In addition to coding skills, topics like people management, naming, trademark enforcement, licensing, patents, pr and more become topics to deal with.
After years of using open source projects, running my own projects, founding meetups and conferences, watching others thrive or fail I believe that coding skills alone aren't sufficient to turn a "private play ground code base" into an open source project that other's can rely on.

Inspired by 140 characters of truth published here the talk will focus on what topics that are usually not taught as part of programming courses will cross your way when dealing with open source - either as a user or as a contributor:
  • People: Is the project willing and able to attract more contributors? Is it able to survive if the leader looses interest or time to continue contributing? How does the project deal with requests coming from the user base? How easy is it for users to get their issues fixed?
  • Trademarks: Why should you care about trademarks from the beginning? How do you deal with others infringing on your trademarks?
  • Copyright: Why should you care, exactly which license you choose?
  • PR: While writing release notes is common practice and composing changelogs is pretty easy, the resulting documents are hard to grok for editors and won't get you on the front page of any magazine. Nor will they help you get visibility on common social media systems that might be key in informing your users about recent releases.
While being excellent at all topics isn't vital from the start, answers to governance questions decide what a project looks like a few years from it's start.
10:00 Break
ROOM Aud. 11 Aud. 12 Aud. 15 A2+A3
TRACK
Track 1 - Beginner Friday
Track 2 - Intermediate Friday
Track 3 - Intermediate Friday
Track 4 - Advanced Friday
10:25
Forget what you think you know - redefining functional programming for Scala
Kelley Robinson
Team Lead, Software Engineer @Sharethrough
Close
Forget what you think you know - redefining functional programming for Scala
Kelley Robinson
Team Lead, Software Engineer @Sharethrough
Kelley has been programming in Scala since 2013, most recently managing a team of Scala developers and Data Scientists at Sharethrough in San Francisco. She is the founder of ScalaBridge, the initiative to build a more inclusive Scala community with introductory programming workshops for women. In her spare time, she enjoys testing new recipes and trying to keep her plants alive.
Friday (2nd Jun.) 10:25
Scala is often touted as a tool for Functional Programming, but Functional Programming (FP) itself is left to differing and opinionated definitions by many of its practitioners. FP is a well defined approach to writing programs that we will uncover in this talk. It is a style that long predates Scala and many of the modern abstractions that are often referred to as "essential" tools.

We will walk through the origins of FP, providing historical context through Lisp and the research that brought us this paradigm. We'll define what FP is and what it is not, looking at how tools like purity and immutability enable the expressions at the heart of FP.

Finally we'll talk about practical approaches to Functional Programming in Scala, how you can and why you would use this style in your everyday work. This will _not_ be a talk about monads and type systems, but give you a pragmatic look at how to separate the syntactic sugar from the underlying principles.
Event Sourcing and CQRS
Lutz Huehnken
Solutions Architect
Close
Event Sourcing and CQRS
Lutz Huehnken
Solutions Architect
Lutz is a freelance consultant, solutions architect and trainer. His current focus is the development of reactive applications – responsive, scalable, resilient systems – with Scala, Akka, and Lagom, mostly for financial institutions and gaming companies. He's one of the authors of the upcoming O'Reilly book "Lagom - The Definitive Guide".
Friday (2nd Jun.) 10:25
Event Sourcing and Command Query Responsibility Segregation (CQRS) have been around for a while, but only now it seems they are really becoming “mainstream”, as they are extremely useful patterns for dealing with your applications state in a scalable way. If you’ve never even heard of them, don’t worry: This talk will give an quick introduction to the concepts of Event Sourcing and CQRS from the ground up.

Once the basics are clear, we are going to have a close look on a Scala framework for these patterns: The Lagom Persistence module that comes as part of the Lagom Microservices Framework. Not only will you see how Lagom makes it easy to use these patterns with Scala, you will also understand what happens under the hood.

Lastly, we’ll look at some challenges that you may face when applying these patterns, as well as have a quick overview of alternative implementations and what to look for when comparing the approaches.
Class up your config
Andy Scott
Senior Software Engineer @47 Degrees
Close
Class up your config
Andy Scott
Senior Software Engineer @47 Degrees
Andy Scott is a Senior Software Engineer at 47 Degrees, a functional programming consulting firm. He has a background in systems engineering and a degree in Mechanical Engineering from Georgia Tech. He’s an active contributor to open source projects such as Scala Exercises, Cats, the Scala compiler, AsyncDisplayKit for iOS, and Scala Bot. And he recently authored Case Classy, a tiny framework for simplifying the process of decoding untyped structured data into case class hierarchies. In his free time, Andy teaches CrossFit and likes to travel.
Friday (2nd Jun.) 10:25
Configuring production applications is a conceptually simple task that sometimes winds up being a lot of work. It shouldn't be this way.

Case classy is a small library that makes part of this process easier. Case classy makes loading and decoding configuration data—usually strings—much easier. It prevents all-or-nothing runtime errors and instead provides a rich and comprehensive error data type for when this process goes wrong.

In this talk we will introduce Case Classy, showing how to use it and its benefits over other configuration libraries. We will dive into the functional programming foundations and how this enables us to assemble and combine decoders so that errors accumulate. And we will look at how Shapeless and generic programming can automatically assemble decoders for us and save us from an abyss of boilerplate.
Managing Consistency, State and Identity in Distributed Microservices
Duncan DeVore
Software Engineer @Lightbend
Close
Managing Consistency, State and Identity in Distributed Microservices
Duncan DeVore
Software Engineer @Lightbend
Duncan DeVore is co-author of ""Reactive Application Development"", Software Engineer at Lightbend, open source developer and frequent speaker. He has been an avid Scala developer since 2009, holds two patents for software design and led the release of one of the first large-scale Reactive applications in 2012.
 
Friday (2nd Jun.) 10:25
In the world of distributed microservices, we face many challenges: parallelism, asynchronous boundaries, state management, identity management and consistency deficiencies, to name a few. Of all these problems, consistency, state management, and identity management can be particularly challenging.

In this session, we will discuss the ins and outs of dealing with microservice consistency and distributed state, and identity coherency with techniques like idempotency, eventual and casual consistency, dealing with CAP theorem, single source of truth and distributed domain design.
11:10 Break
11:35
The Essence of Testing
Bill Venners
President @Artima, Inc.
Close
The Essence of Testing
Bill Venners
President @Artima, Inc.

Bill Venners is president of Artima, Inc., publisher of Scala books and Scala developer tools, and co-founder of Escalate Software, LLC, provider of Scala training. He is the lead developer and designer of ScalaTest, an open source testing tool for Scala and Java developers, and Scalactic, a library of utilities related to quality. Bill is also co-author with Martin Odersky and Lex Spoon of the book, Programming in Scala.

Friday (2nd Jun.) 11:35
After almost ten years of working on ScalaTest, there is still lots of potential for improvement of the library. In this talk, Bill Venners will describe what he has come to 2believe is the essence of testing, and how he wants to evolve ScalaTest as a result. He will dive into propositional and predicate logic and show how they relate to testing. He'll explain where he thinks property-based testingfits in the big picture, and give demos of some new and exciting features currently being developed for ScalaTest and Scalactic.
Finagle for Beginners
Nepomuk Seiler
Software Engineer @gutefrage.net GmbH
Close
Finagle for Beginners
Nepomuk Seiler
Software Engineer @gutefrage.net GmbH
Muki is a software engineer at Gutefrage.net building web applications with Scala and Javascript. He maintains sbt-native-packager and has contributed to various open source projects like the playframework, Eclipse and the recently started 'Gutefrage Finagle Documentation'.
Friday (2nd Jun.) 11:35
"Finagle is an extensible RPC system for the JVM, used to construct high-concurrency servers. Finagle implements uniform client and server APIs for several protocols, and is designed for high performance and concurrency." - Finagle docs

This talk gives an introduction to some Finagle core concepts and how to apply them. You will learn the basic idea behind "your server as function", how to use it, how to implement dynamic request routing with Dtabs and how to implement generic request contexts.
Chatbots in Scala: meet your new robot overlords
Sam Reghenzi
Senior Developer @Undisclosed
Close
Chatbots in Scala: meet your new robot overlords
Sam Reghenzi
Senior Developer @Undisclosed
I design, implement and maintain infrastructure for software products, trying to make life easier for everyone and release software that does't sucks. You can see my full resume along with my speaking experience on linkedin (https://it.linkedin.com/in/sammyrulez).
Friday (2nd Jun.) 11:35
What are chatbots? Why are they such a big opportunity? How do they work? How can I build one?
A chatbot is a service, powered by rules and sometimes artificial intelligence, with whom you can interact with via a chat UI interface. It leads to interesting challenges for a software engineer: natural language processing, concurrency and conversational state management. Scala offers an amazing array of tools to engage these challenges. Let's do it!
Reification and type-safety in a CQRS world
Renato Cavalcanti
Scala Dev / Architect @Strong[Typed]
Close
Reification and type-safety in a CQRS world
Renato Cavalcanti
Scala Dev / Architect @Strong[Typed]
Renato Cavalcanti is an independent Scala developer based in Belgium. Scala aficionado since 2009, he has been hacking in Scala and related technologies for fun and profit. He's the founder of BeScala, co-founder of Strong[Typed]? and author of Fun.CQRS.
Friday (2nd Jun.) 11:35
CQRS applications brings some new challenges for statically typed language lovers since a considerable amount of the modeling effort goes to the definition of Commands and Events as separated entities without direct connection with the main domain model classes.

The biggest challenge is how to model a domain as an Algebraic Data Type where its operations are modeled as Commands and Events (themselves also ADTs) and have everything defined as a cohesive, well-typed domain.

This can be achieved in different ways: using type parameters, type projection or path dependent types. Each solution has its Pros and Cons that we will visit and discuss in detail.
12:20 Lunch
12:50
Sponsor Prize Draw
Close
Sponsor Prize Draw
Friday (2nd Jun.) 12:50
Be present when the Scala Days Copenhagen sponsors raffle off their great prizes in A2+A3!
13:20
Hands-on Scala-Native
Guillaume Massé
Software Engineer @Scala Center
Martin Duhem
Software Engineer @ Scala Center
Close
Hands-on Scala-Native
Guillaume Massé
Software Engineer @Scala Center
Guillaume is a Scala Center and commiter to Scala Native. He worked on the Scala Package Index (Scaladex) and ScalaKata.com
Martin Duhem
Software Engineer @ Scala Center
Martin is a software engineer at Scala Center, and a contributor to Scala Native. Previously, he was working at Lightbend on sbt, and more specifically on the incremental compiler, Zinc.
Friday (2nd Jun.) 13:20
Scala Native is a brand new target for the Scala compiler. You can write native code without paying the cost of the c programming language.

In this presentation we will run through various code example to understand how to get going with native: Hello, World!, command line application.
Akka streams for high throughput data processing
Zack Loebel-Begelman
Senior Software Engineer @Credit Karma
Close
Akka streams for high throughput data processing
Zack Loebel-Begelman
Senior Software Engineer @Credit Karma
As a senior software engineer on the data and analytics pipeline, Zack’s work allows Credit Karma to provide tailored recommendations for each individual member’s specific financial situation. Zack joined Credit Karma after designing and launching data engines to support backend consumer services. He has a bachelor’s degree in computer science from the University of California, Davis.
Friday (2nd Jun.) 13:20
With over 60 million members, Credit Karma is one of the most trusted personal finance tools in the U.S. This scale of information demands a data transfer process designed to handle high throughput. We built an initial Akka Actor implementation but didn’t ask ourselves the key question: What happens when you have actors with vastly different performance characteristics?

We will look at how we built two distinct services using Akka Actors, how Akka helped us parallelize, parse and send data to our data ingestion service, and why we hit the limits of this system. You will walk away with a greater understanding of backpressure and Akka Streams, warning signs to look for when your actor system may be near it’s capacity, and when Akka Streams is a good choice for your data transfer system.

If you and or your company have or are building Akka Actor Systems, designed for high throughput this talk may be for you. We will provide guidance on best practices and whether optimizations can improve throughput or whether switching to Akka Streams may be necessary.
When all abstraction is lost
Daniel Jentsch
Coach and developer @Leanovate
Close
When all abstraction is lost
Daniel Jentsch
Coach and developer @Leanovate
Daniel works as a coach and developer at the Lightbend partner Leanovate in Berlin. During his studies and his later career he became a distributed system affectionado with a special interest in model checking. He is always happy to share his insights into how to apply theoretical concepts in a pragmatic fashion to real-world problems. Daniel is both a co-organizer and regular speaker at the Berlin Scala User Group.
Friday (2nd Jun.) 13:20
Did you ever implement an asynchronous/distributed algorithm or data structure and wondered whether your implementation is correct? Did you ever try to solve this problem by testing thoroughly and a little bit of reasoning with the result being “the system will probably work correctly”? If you answered to any of these question with yes then this talk is definitely for you.

In this Talk we will look at a novel approach to easily prove the correctness of concurrent/distributed systems with the help of an extension for ScalaTest. The extension offers a DSL for describing behaviors of these systems and employs explicit state model checking for the purpose of proofing those behaviors. Since, model checking isn't widely used in the Scala world we will (briefly) discuss this concept before looking at the DSL and extension itself. In the demo we will see that the extension can be used for proofing the correctness of a real-world system written in Scala.

Monads will not be mentioned during this Talk. However, the audience may be exposed to a non-painful amount of temporal logic.
Uniting Church and State: FP and OO Together
Noel Welsh
Partner @Underscore
Close
Uniting Church and State: FP and OO Together
Noel Welsh
Partner @Underscore

Noel is a partner at Underscore, a global Scala consultancy, where he uses his expertise to develop simple and scalable systems for clients. His main professional interests are programming languages and machine learning.

Friday (2nd Jun.) 13:20
In this talk we describe an underappreciated tool, Church encoding, that allows us to combine the best parts of FP and OO.
By Church encoding our program we can reatin the simple semantics that characterises FP code, while achieving performance that may seem out of reach in a pure FP system.

Late last year Maana, a Seattle based enterprise knowledge platform startup, contracted us to write a time series analysis engine.
They commonly dealt with multi-TB data, but needed to achieve interactive speed.
We recognised that providing a streaming API, similar to Monix, Akka Streams, or Reactive Extensions, would make the software accessible to data scientists already used to Spark, but there were issues about semantics and performance.
Classic FP pull-based systems are simple to use but perform poorly, while OO push-based systems are fast but tricky to reason about.
By employing Church encoding, also known as refunctionalisation, we were able to get the best of both worlds.

The user sees a straightforward API and semantics, while under the hood the system has no runtime memory allocation and is extremely efficient.
This tool is not so widely known and the purpose of our talk is to introduce it to a wider audience.

Church encoding is a general purpose tool you can apply to your own code no matter what software you build.
It provides a relationship between the classic FP tool of algebraic data types (represented in Scala using `sealed` traits) and OO-style classes.
We can use it to convert FP-style code into an OO equivalent, which can use mutable state and other optimisations without affecting the clean semantics the user sees.
Church encoding also gives us a coherent design principle to unite FP and OO.
This provides a bridge to truly unlocking Scala's multiparadigm nature while retaining an overall architecture that is simple and consistent.
14:05 Break
14:30
Scala 2.12 and the road towards 3.0
Adriaan Moors
Scala Team Lead @Lightbend
Close
Scala 2.12 and the road towards 3.0
Adriaan Moors
Scala Team Lead @Lightbend
Adriaan leads the Scala team at Lightbend. Our mission is to make Scala the most practical and productive language you've ever worked with, by providing a flexible set of simple constructs to help you build scalable and maintainable solutions for complex problems (and have fun while doing so).

Adriaan's been working on the Scala compiler for ten years, with his first contribution being support for type constructor polymorphism. More recently, he worked on support for Java 8's retro-fit of functions (single abstract method types) and internal compiler cleanups to take advantage of simplifications in our encoding enabled by Java 8's support for default methods in interfaces.
Friday (2nd Jun.) 14:30
We'll take a close look at Scala 2.12's features as well as what lies ahead in the next few years for the Scala 2.x series. I'll also take a step back and muse about what the essence of Scala is to me, why I still love working on the compiler 10 years later, and why I believe it's the best choice for statically typed functional programming on the JVM (and JS, and maybe native? :-)).
Real World Android Akka
Taisuke Oe
Engineer @BONX, INC.
Close
Real World Android Akka
Taisuke Oe
Engineer @BONX, INC.
Taisuke Oe has spent more than five years developing dozens of Android applications in Scala. He has also organized the largest international Scala conference in Asia, Scala Matsuri for five years.

Now he works for BONX,INC. in Tokyo as an engineer leading the Android team. He also works for Septeni Original, Inc. in Tokyo as a technical advisor, and for Japan Scala Association, Inc. in Tokyo as executive director and chairman of Scala Matsuri.
Friday (2nd Jun.) 14:30
Akka is a great toolkit for a concurrent and resilient system, even if it's in Android. The BONX outdoor group-talk Android app is a VoIP -Voice over Internet Protocol- client for the extreme sports scene. It is an audio stream processing client app that has unique requirements such as fewer packets and resiliency.

Since it is expected to run continuously during sports activities, which can be up to 7 hours for skiing or snowboarding, it should, therefore, minimize packets with some additional steps which may make BONX more complex. It should also be able to recover from any errors that occur during the activities, including network disconnection, hardware I/O errors and any other failures in each module. Akka works greatly to manage these types of errors. 
 
The BONX app, which is built using Akka, detects failures in each module, and suspend or restarts the connection depending on its network environment, or recover from errors immediately without spoiling the user's experience. That's why the BONX app is rated almost five stars as of January 2017 at Google Play.
 
This talk is not just an introduction to a unique use case, but also demonstrates how Akka is a powerful and easy toolkit that can be used to ensure resiliency and concurrency in a minimal system.
sbt: Beyond the Build Tool
Jeff Olchovy
Software Engineer @Tapad
Close
sbt: Beyond the Build Tool
Jeff Olchovy
Software Engineer @Tapad
Jeff Olchovy is a Staff Software Engineer at Tapad where he leads the company's Platform Practice, which is the cross-functional engineering group responsible for laying the foundation for Tapad's systems. With over nine years of development experience and having played a critical role in building Tapad's engineering team, Jeff was also recently appointed to help spearhead Tapad's engineering efforts at the company's new Oslo office.
Friday (2nd Jun.) 14:30
Anyone familiar with Scala knows both the benefits and annoyances of using sbt. On one hand, the tool is essential for features such as automatic dependency management, continuous compilation, testing, and deployment, etc. However, it’s often that we find hours are wasted on trying to fight sbt and the way it dictates our build processes. In this session, Jeff will show fellow Scala developers how to regain their productivity by both embracing sbt instead of fighting it as well as finding new ways to use sbt beyond just a build tool. Past users of Maven, Ant, and Gradle may not feel comfortable configuring and customizing their sbt build definition -- much to their own detriment -- but the potential to do so is definitely there. Accompanied by specific and compelling case studies, Jeff will challenge the audience to re-think the ways they have been using sbt all along and walk away with specific best practices to improve their overall productivity with the tool.
Impact on business and society
Sarah Aerni
Data Scientist @Salesforce
Close
Impact on business and society
Sarah Aerni
Data Scientist @Salesforce
Sarah Aerni is a Senior Manager of Data Science at Salesforce, Einstein where she leads application building on the platform. Prior to Salesforce she led the healthcare & life science and Federal teams at Pivotal. Sarah obtained her PhD from Stanford University in Biomedical Informatics, performing research at the interface of biomedicine and machine learning. She also co-founded a company offering expert services in informatics to both academia and industry.
Friday (2nd Jun.) 14:30
There is no shortage of AI startups today that are productizing methods in specific domains to solve problems in a repeatable way. While this frequently works in areas with very consistent data sources and fixed fields, many companies still struggle to create operational models in their business domains. Challenges also remain around building organizations capable of in-house development, largely due to a shortage of individuals for hire.

At Salesforce, Einstein addresses this need by truly democratizing AI. In this talk we will cover how we are reducing the human effort for our customers to solve cases in their service centers by building models on their data in Service Cloud. We will describe the underlying framework enabling models specified for each of our individual customers and return results back to massively decrease the time it takes to solve cases.

In describing the approach we will provide an overview of the platform and how it enables our customers at every step. This will include how we specify timeliness of data ingest, automation of feature engineering, model selection and tuning specific to each customer via Optimus Prime, and making the model immediately actionable by pushing the results back to Service Cloud. The platform overview will emphasize how various components function and result in scalable services by leveraging technologies such as AKKA, Spark, SparkML and the AWS lambda architecture. Through this we will demonstrate how Einstein accelerates the process of developing operational models and brings AI to all our customers.
15:15 Break
15:40
Building a Company on Scala
Dag Liodden
CTO and co-founder @Tapad
Close
Building a Company on Scala
Dag Liodden
CTO and co-founder @Tapad
Dag Liodden is Tapad’s Co-Founder and CTO. Dag oversees all technological advancements for the company, including Tapad’s notable breakthroughs in delivering targeted advertising across platforms. Prior to Tapad, he was the co-founder and CTO of Giant Leap Technologies AS, the premier Business Mobility solutions provider in the Nordic region. While there, Dag managed some of the largest wireless enterprise solution rollouts in Europe. He began programming at 6-years-old and has a Master’s Degree in Science, Industrial Economics and Technology Management from the Norwegian University of Science and Technology. Dag has also spoken at events such as Data-Driven NYC, NY Scala meet-ups, and more.
Friday (2nd Jun.) 15:40
At any company’s start, they will face of the decision of which programming language will define their technology stack. For Tapad, this was in 2010, when languages like Scala were in their very early stages and many engineers weren’t looking beyond Java. It was at that time that CTO and co-founder, Dag Liodden, made the decision to use Scala, which arguably provided the technical foundation needed to scale Tapad to what it is today -- a 200+ person company, managing 20+ PB of data, that was recently acquired for $360 million. While adoption has gained significant momentum for Scala since Tapad first embraced the language, it is still in the fairly early stages of maturity, which poses challenges for experienced and novice Scala developer teams alike. In this session, Dag will address the source of some of these challenges, how they can be resolved, and how Scala can help deliver high quality code at high velocity. Ultimately, all leading up to how engineers and entrepreneurs alike can overcome these barriers to build a team, or even a whole company, on Scala.
Building high available systems with Akka Distributed Data
Jeroen Gordijn
Coding Architect @Trivento
Close
Building high available systems with Akka Distributed Data
Jeroen Gordijn
Coding Architect @Trivento
Jeroen Gordijn is Coding Architect at Trivento and currently working for ING. He has a lot of experience with Scala and Akka and enjoys creating distributed systems.
Friday (2nd Jun.) 15:40
Distributed systems, if done right, allow for high available highly scalable systems. There is a lot said and done about consistency in a distributed system and this talk focuses on building a system that favors high availability over consistency. To build highly available systems you have to sacrifice consistency when partitioning occurs. A Conflict-Free Replicated Data Type (CRDT) is a datatype that allows nodes in a distributed system to replicate data to each other without conflicts. Akka has a module to use make use CRDT's to distribute data over your cluster. This module is called Distributed Data.

This talk will give an introduction to Distributed systems, data replication and how CRDT's work. This will serve as a basis to explain Akka Distributed Data. At the end a short demo will show it working.
Doodle: Visualisation in Scala
Noel Welsh
Partner @Underscore
Close
Doodle: Visualisation in Scala
Noel Welsh
Partner @Underscore

Noel is a partner at Underscore, a global Scala consultancy, where he uses his expertise to develop simple and scalable systems for clients. His main professional interests are programming languages and machine learning.

Friday (2nd Jun.) 15:40
In this talk I'll introduce Doodle, a Scala library for data visualisation that renders in the browser, to files, and on the desktop.

Scala is an integral part of many data analysis workflows, but when it comes to visualising the results practitioners must often turn to Javascript libraries like d3 or Highcharts, or Python libraries such as matplotlib. These libraries have several disadvantages. For a start, they require switching environments. Furthermore, they often lack useful abstractions, being either easy to use or flexible, but not both. For example, matplotlib provides a rigid system of predefined graphs, while d3 provides many low-level building blocks but lacks tools to easily combine them for common graphs.

Doodle is a new 2D visualisation library for Scala. It can render graphs on the desktop, to files (PDF and PNG), and, using Scala.js, to the browser as SVG. In this talk I will briefly describe how to use Doodle for common tasks, and then delve into its architecture. I'll show how standard functional programming techniques allows Doodle to provide powerful functionals at multiple levels of abstraction, yielding a library that is both easy to use and extremely flexible.
Easy Static Checking for Embedded DSLs in Scala with Contextual
Jon Pretty
Scala Developer @Propensive Ltd
Close
Easy Static Checking for Embedded DSLs in Scala with Contextual
Jon Pretty
Scala Developer @Propensive Ltd
Jon has been involved in the Scala community for over a decade, having launched the first commercial and open-source Scala software back in 2005.

Since then, he has successfully deployed Scala projects into small, medium and large businesses, and the UK government, but is best known these days for his work on Rapture, Contextual and the Scala World conference, and as chair of the Scala Center Advisory Board.
Friday (2nd Jun.) 15:40
Interpolated strings, like the familiar `s""`, provide a convenient way to embed external DSLs in Scala source, allowing you to construct a new value at runtime from a string literal, with Scala expressions substituted within it.

But unless you are prepared to implement the interpolator using a macro, the compiler provides no checks on the correctness or well-formedness of the embedded DSL.

Contextual is a small open-source library which does the heavy lifting work to make it trivial to write interpolators which run at compile time, without requiring any macro code. A string interpolator which parses and checks a DSL at compile-time -- with its own custom error-messages -- can be written using contextual in just a few lines of ordinary "userspace" code, calling upon parsers, regular expressions or any other means to check the interpolated string.

This opens up a smorgasbord of possibilities for adding more compile-time safety to Scala code, not least the ability to introduce your own literal-like types, ranging from checked email addresses or URLs to compile-time-checked YAML, CSS or Haskell!
16:25 Break
16:45
Closing Panel
Adriaan Moors
Scala Team Lead @Lightbend
Miles Sabin
Underscore/Typelevel
Felix Mulder
Release Manager & Compiler Engineer @EPFL
Kelley Robinson
Team Lead, Software Engineer @Sharethrough
Ólafur Páll
Engineer @ Scala Center
Close
Closing Panel
Adriaan Moors
Scala Team Lead @Lightbend
Adriaan leads the Scala team at Lightbend. Our mission is to make Scala the most practical and productive language you've ever worked with, by providing a flexible set of simple constructs to help you build scalable and maintainable solutions for complex problems (and have fun while doing so).

Adriaan's been working on the Scala compiler for ten years, with his first contribution being support for type constructor polymorphism. More recently, he worked on support for Java 8's retro-fit of functions (single abstract method types) and internal compiler cleanups to take advantage of simplifications in our encoding enabled by Java 8's support for default methods in interfaces.
Miles Sabin
Underscore/Typelevel
Miles has been doing stuff with Scala for more than fourteen years, currently with Underscore Consulting. He is a co-founder of Typelevel and his best known project, the Scala generic programming library shapeless, is the weapon of choice wherever boilerplate needs to be scrapped or arities abstracted over. Currently he is spending a lot of his time working on Typelevel Scala with the goal of improving the lives of all developers who write Scala in the Typelevel style.
Felix Mulder
Release Manager & Compiler Engineer @EPFL
Felix is the release manager for the next generation Scala compiler, Dotty, being developed by Martin Odersky's lab at EPFL. He started his foray into Scala by re-engineering the Scaladoc tool for Scala 2.12 and was subsequently hired to work on Dotty at EPFL.
Kelley Robinson
Team Lead, Software Engineer @Sharethrough
Kelley has been programming in Scala since 2013, most recently managing a team of Scala developers and Data Scientists at Sharethrough in San Francisco. She is the founder of ScalaBridge, the initiative to build a more inclusive Scala community with introductory programming workshops for women. In her spare time, she enjoys testing new recipes and trying to keep her plants alive.
Ólafur Páll
Engineer @ Scala Center
Ólafur Páll is a software engineer at the Scala Center working on devtools. He is the author of scalafmt and a scala.meta maintainer.
Friday (2nd Jun.) 16:45
Join is in room Zurich A2+A3 for the closing panel with Adriaan Moors, Felix Mulder, Kelley Robinson, Miles Sabin and Ólafur Geirsson. The closing panel will be moderated by Jon Pretty.

Conference and Training

Bella Center
Center Blvd. 5
2300 Copenhagen S

Website Map

Trainings

Want to get the most out of Scala Days Copenhagen? Register for an in-person training course before the Scala Days conference. All trainings are two-day trainings and will take place Tuesday and Wednesday May 30th -31st, 2017. The courses are designed for developers of all levels of proficiency with the Lightbend Reactive Platform.

All trainings will take place at:

Bella Center
Center Blvd. 5
2300 København S

Training schedule:

Tuesday
08:00 - 09:00 Registration - Coffee/Tea
09:00 - 10:30 Workshop
10:30 - 10:45 Coffee/Tea Break (incl. snacks)
10:45 - 12:00 Workshop
12:00 - 13:00 Lunch Break
13:00 - 14:45 Workshop
14:45 - 15:15 Coffee/Tea Break (incl. snacks)
15:15 - 18:00 Workshop

Wednesday
08:00 - 09:00 Registration - Coffee/Tea
09:00 - 10:30 Workshop
10:30 - 10:45 Coffee/Tea Break (incl. snacks)
10:45 - 12:00 Workshop
12:00 - 13:00 Lunch Break
13:00 - 14:45 Workshop
14:45 - 15:15 Coffee/Tea Break (incl. snacks)
15:15 - 16:00 Workshop

Advanced Scala

Trainers: Markus Hauck & Heiko Seeberger

The power of Scala’s type system, unleashed - advanced object functional programming, implicits, and more. Leverage rich language features to create well-designed libraries or DSL’s, utilizing proven best practices.

Participant
  • Developers who have experience and proficiency in Scala
  • Developers who want to understand advanced features in Scala
  • Managers who want to gain a deep understanding of functional programming
Benefit
  • Developers gain knowledge and skills to confidently program in Scala
  • Certified Lightbend Trainers share coding insights that lead to high-quality code
  • Advance to the limits of Scala capability!
Outline
  1. Recap of important basics
  2. Object-Functional Programming in Depth
  3. Mastering the Type System
  4. Explicitly Implicit
  5. Internal DSLs
  6. Custom Scala Collections
Logistics
  • Level: Advanced - knowledge of and practical experience with Akka is assumed
  • Length: Two days - 14 hours of classroom time, plus breaks
  • Approach: Hands-on mastery - students code through workshop case study and explore how to solve the toughest Scala challenges in their own work
  • Requirements: Students bring their own laptops with Java 6 or higher installed

SOLD OUT! Fast Track to Akka with Scala

Trainer: Eric Loots

Scalable reactive application, for the win! Experienced application developers learn the reactive Akka toolkit and runtime, along with methodologies to create real-world, actor-based systems in Scala on a single JVM.

Participant
  • Developers with basic knowledge of Scala, as covered in “Fast Track to Scala”
  • Developers who want to develop resilient, event-driven, scalable applications
  • Managers who want to learn how reactive applications drive business value
Benefit
  • Developers gain knowledge and skills to design fault-tolerant apps using Akka
  • Certified Lightbend Trainers share how to configure, test, and tune Akka apps
  • Production readiness - create asynchronous, event-driven systems
Outline
  1. Introduction to Akka
  2. Actor Basics
  3. Testing Actors
  4. Actor Lifecycle
  5. Fault Tolerance
  6. Scaling up with Routers
Logistics
  • Level: Intermediate - knowledge of and practical experience with Scala is assumed
  • Length: Two days - 14 hours of classroom time, plus breaks
  • Approach: Extensive hands-on coding - students develop a workshop case study and produce a fully functional application that is event-driven and resilient
  • Requirements: Students must bring their own laptops with Java 6 or higher installed

Apache Spark: An Introductory Workshop for Developers

Trainers: Matthias Niehoff & Florian Troßbach

This two-day workshop is designed to teach developers how to implement data analytics using Apache Spark for Reactive applications. In this workshop, developers will use hands-on exercises to learn the principles of Spark programming and idioms for specific problems, such as event stream processing, SQL-based analysis on structured data in files, integration with Reactive frameworks like Akka, as well as Hadoop and related tools, and advanced analytics such as machine learning and graph algorithms.

Participant
  • Developers with basic knowledge of Scala, as covered in “Fast Track to Scala”
  • Developers with an interest in data science looking to put theory into high-scale practice
  • Managers who want to understand how to field applications powered by fast data analytics
Benefit
  • Developers gain knowledge and skills to build Spark-based offline and event-streaming applications
  • Certified Lightbend Trainers share best practices for developing Scala-Spark applications
  • Production data - integrate Spark with Akka and Hadoop, today!
Outline
  1. Introduction to Spark
  2. Writing Spark RDD Applications I
  3. Writing Spark RDD Applications II
  4. Spark SQL and DataFrames
  5. Spark Streaming
  6. MLib, GraphX, and Others
  7. Spark Clusters (optional)
Logistics
  • Level: Intermediate - knowledge of and practical experience with Scala is assumed
  • Length: Two days - 14 hours of classroom time, plus breaks
  • Approach: Extensive hands-on coding - students develop a workshop case study and use Spark to process real-world data sets
  • Requirements: Students must bring their own laptops with Java 6 or higher installed

Advanced Akka with Scala

Trainers: Manuel Bernhardt & Thomas Hackbarth

The pinnacle of scalable, reactive applications! Experienced application developers learn to build distributed reactive applications using Akka and Scala, scaling out multiple nodes and 3rd-party systems. Remoting, clustering and the RESTful HTTP layer.

Participant
  • Developers with basic knowlege of and experience using Scala and Akka, ready to scale to new heights
  • Developers who want to develop resilient, event-driven, scalable applications
  • Managers who want to understand the value of resilient, distributed applications
Benefit
  • Developers gain knowledge and skills to design large-scale Akka applications
  • Certified Lightbend Trainers share how to configure, test, and tune multiple nodes
  • Production readiness - confidence to use Akka on a large scale!
Outline
  1. Akka Basics Reloaded
  2. Remoting
  3. Clustering
  4. Cluster Aware Routers
  5. Cluster Singleton
  6. Cluster Sharding
  7. Akka Persistence
  8. Akka Distributed Data
Logistics
  • Level: Advanced - knowledge of and practical experience with Akka is assumed
  • Length: Two days - 14 hours of classroom time, plus breaks
  • Approach: Extensive hands-on coding - students develop a workshop case study and produce a fully functional application that is event-driven and resilient
  • Requirements: Students bring their own laptops with Java 6 or higher installed

Tickets

Conference (2.5 days)

Before Jan 18 Before Mar 15 After Mar 15
€850  €900 €1000

Conference + 2 training days (4.5 days)

Before Jan 18 Before Mar 15 After Mar 15
€1750 €2000 €2150

2 Training day only

Before Jan 18 Before Mar 15 After Mar 15
€1000 €1200 €1250

Register

Please note that the registration fee is non-refundable. Once a registration has been made and the confirmation email has been sent out, the price
is set and can not be changed or adjusted. Price reductions (promotion codes) are always relative to the list price. It is not possible to combine
different price reductions.Registration includes conference materials, t-shirt, bag, and food during the conference and at all social events.
Training workshop attendees will receive training materials, breakfast and lunch and an afternoon snack.In case there is not a sufficient number
of registrations for a particular workshop, we reserve the right to cancel it one month prior to the conference. If a workshop is cancelled,
registered attendees will be contacted directly and they can register for another workshop or get a refund. All prices are subject to 25% VAT.


If you need a hotel during your stay in Copenhagen you can book and receive a discounted and price match guarantee Scala Days conference rate clicking "book hotel" below.

Book hotel

Sponsors

Interested in being a sponsor at Scala Days Chicago? Contact the Scala Days team


Platinum


Databiz Lunatech

Gold


47 Degrees Cake Solutions Evolution Gaming Humio ING Bank Jetbrains SAP Signify Technology TapadZalando

Silver

Scalac Trivento Virtuslab  Qvantel

Media

Scala Times

Produced by

Lightbend Trifork

Code of Conduct

Our Code of Conduct is inspired by the kind folks at NE Scala, who adopted theirs from PNW Scala. We think they both nailed it.

 

Nobody likes bad behavior, so please show respect for those around you. This applies to both in-person and online behavior.

 

Scala Days is dedicated to providing a harassment-free experience for everyone, regardless of gender, gender identity and expression, sexual orientation, disability, physical appearance, body size, race, or religion (or lack thereof). We do not tolerate harassment of participants in any form.

 

All communication should be appropriate for a technical audience, including people of many different backgrounds. Sexual language, innuendo, and imagery is not appropriate for any conference venue, including talks. 

 

Participants violating these rules may be asked to leave without a refund at the sole discretion of the organizers.

Crew Volunteers

Crew registration is closed. Thanks to everyone who helps.

All Crew Volunteers will be required to work on Wednesday May 30th from 12:00 PM - 6:30 PM as well as another shift of four hours on Thursday June 1st or Friday June 2nd. In return for helping with the conference, Crew Volunteers will have free access to the conference and all social events.

If you are an academic wanting to participate fully in Scala Days Copenhagen you can send an email with a copy of your student ID to Dajana Guenther, daj@trifork.com, and in return you will receive a discouted rate for conference attendance.

If you have any questions regarding crew volunteering or academic rate please contact Dajana Guenther, daj@trifork.com.