Scala Days

  June 8-10th, Amsterdam

 

Download the Scala Days Amsterdam App

For iOS
For Android 

 

Keynotes

Martin Odersky, Chief Architect & Co-Founder at Typesafe

Scala - where it came from, where it's going

Monday June 8

Jonas Bonér, Co-founder and CTO of Typesafe

Life Beyond the Illusion of Present

Tuesday June 9

Adam Gibson, Co-founder of Skymind and Creator of Deeplearning4

The Future of AI in Scala, and on the JVM

Wedneday June 10

About

Scala Days Amsterdam

Scala Days Amsterdam 2015 conference tickets are now SOLD OUT. But don't panic - we still have a few seat left for trainings!


Sign up for our wait list and get contacted if we get a spare conference seat.


Scala Days, the premier European Scala Conference, will be held this year at the Beurs Van Berlage in Amsterdam on June 8th through 10th, 2015.


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.


Last year’s conference in Berlin was a sold-out event at 800 attendees, and for 2015 we have added two annual events: San Francisco and Amsterdam. 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.


Scala Community Event Calendar

We want to give all Scala enthusiasts the opportunity to attend and share Scala related events before, during and after Scala Days Amsterdam 2015. Add our Scala Community Event Calendar for Scala Days Amsterdam 2015 where non-Scala Days meetups and trainings will be posted by community members. Please also share your Scala event in this calendar by sending information about the event to info@scaladays.org. This way we can get together and share knowledge and passion about Scala.

Monday (8th Jun.)
16:00 Registration Open
ROOM Effectenbeurszaal (Ground Floor)
TRACK
Keynote
17:00
Keynote: Scala - where it came from, where it's going
Martin Odersky
Scala Creator and Typesafe Co-Founder
Close
Keynote: Scala - where it came from, where it's going
Martin Odersky
Scala Creator and Typesafe Co-Founder

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

Monday (8th Jun.) 17:00
The talk will give a quick history of the design motivations behind Scala, summarize its current status, and point out future directions for the language and its ecosystem. Scala was intended from the start to be a simple and powerful language for software components. Today, we see a large number of interlinked components and open source systems that make use of it. However, extensive collaboration and re-use are sometimes hampered by binary compatibility issues. I will argue that the logical next step to overcome these issues is to make Scala a true Software platform, which can operate on a number of different host platforms. This step will also lead to a much-needed separation of concerns between stable interfaces and changing implementations.
18:30
Welcome Reception: Grotezaal
Close
Welcome Reception: Grotezaal
Monday (8th Jun.) 18:30
We would like to invite all attendees, sponsors and speakers to the Welcome Reception! The reception will take place Monday from 18:30-20:30 in Grotezaal. Come and say hello to colleagues, other attendees, speakers and all the sponsors. Refreshments will be provided.
Tuesday (9th Jun.)
08:00 Registration Open
09:00
Tuesday Keynote: Life Beyond the Illusion of Present
Jonas Bonér
Typesafe
Close
Tuesday Keynote: Life Beyond the Illusion of Present
Jonas Bonér
Typesafe
Jonas is the co-founder and CTO of Typesafe building a platform for Reactive Systems—implementing the principles of the Reactive Manifesto, a manifesto that Jonas initiated and co-authored.
Tuesday (9th Jun.) 09:00
The idea of the present is an illusion. Everything we see, hear and feel is just an echo from the past. But this illusion has influenced us and the way we view the world in so many ways; from Newton’s physics with a linearly progressing timeline accruing absolute knowledge along the way to the von Neumann machine with its total ordering of instructions updating mutable state with full control of the “present”. But unfortunately this is not how the world works. There is no present, all we have is facts derived from the merging of multiple pasts. The truth is closer to Einstein’s physics where everything is relative to one’s perspective. As developers we need to wake up and break free from the perceived reality of living in a single globally consistent present. The advent of multicore and cloud computing architectures meant that most applications today are distributed systems—multiple cores separated by the memory bus or multiple nodes separated by the network—which puts a harsh end to this illusion. Facts travel at the speed of light (at best), which makes the distinction between past and perceived present even more apparent in a distributed system where latency is higher and where facts (messages) can get lost. The only way to design truly scalable and performant systems that can construct a sufficiently consistent view of history—and thereby our local “present”—is by treating time as a first class construct in our programming model and to model the present as facts derived from the merging of multiple concurrent pasts. In this talk we will explore what all this means to the design of our systems, how we need to view and model consistency, consensus, communication, history and behaviour, and look at some practical tools and techniques to bring it all together.
10:00 Break
ROOM Effectenbeurszaal (Ground Floor) Administratiezaal (1 st Floor) Berlagezaal (1 st Floor) Veilingzaal (1 st Floor)
TRACK
Enterprise (Big Data, Reactive, Security, etc.) Tuesday
Cool Stuff, IoT Tuesday
Tools web, best practices Tuesday
Core Scala (Functional Programming, Academic) Tuesday
10:25
GraphX: Graph analytics for insights about developer communities
Paco Nathan
Databricks
Close
GraphX: Graph analytics for insights about developer communities
Paco Nathan
Databricks
Director of Community Evangelism at Databricks. O'Reilly author (ʺJust Enough Mathʺ, ʺEnterprise Data Workflows with Cascadingʺ, and the upcoming ʺSpark: The Definitive Guideʺ. Frequent speaker at Strata, OSCON, Spark Summit, Hadoop Summit, other confs and meetups -- including popular keynote talks at regional confs. Program committee member for Strata, Spark Summit. Experienced instructor (Stanford, etc.) currently leading Training team @Databricks, personally teaching several large (200-500) tutorials, and teaching thousands of students per year
Tuesday (9th Jun.) 10:25
Case study / demo of a large-scale graph analytics project, leveraging GraphX in Apache Space to surface insights about open source developer communities, based on data mining of their email forums. The project works with any Apache email archive, applying NLP and machine learning techniques to analyze message threads, then constructs a large graph. Graph analytics, based on concise Scala coding examples in Spark, surface themes and interactions within the community. Results are used as feedback for respective developer communities, such as leaderboards, being used to help refine developer certification exams, etc. As an example, we will examine analysis of the Spark developer community itself.
Project Gålbma: Actors vs. Types
Roland Kuhn
Typesafe Inc.
Close
Project Gålbma: Actors vs. Types
Roland Kuhn
Typesafe Inc.
Dr. Roland Kuhn is leading the Akka project at Typesafe, a co-author of the Reactive Manifesto and the book «Reactive Design Patterns», co-teaching the Coursera course «Principles of Reactive Programming» and a passionate open-source hakker. He also holds a PhD in particle physics and has worked in the space industry for several years.
Tuesday (9th Jun.) 10:25
The Actor Model describes precisely what it means for computation to be distributed: encapsulated and isolated behaviors process messages that are sent asynchronously between them. Akka’s implementation of this model has been widely successful, but for a long time it had the restriction that Actor interactions were not statically type-checked. With the addition of the akka-typed module we have finally found a formulation that brings Actor messaging to the same type-safety as normal method invocation—if not beyond—while being simple and intuitive. In this presentation we will look at why this addition has taken so long, how it works, and what we can express with it.

Actor-skeptics beware: this may shift your world-view!
Type-safe off-heap memory for Scala
Denys Shabalin
EPFL
Close
Type-safe off-heap memory for Scala
Denys Shabalin
EPFL
Denys is the author of Scala 2.11's quasiquotes, a project aimed at making AST manipulation a pleasure. He is also an active contributor to scala/scala repository, hacking on compiler internals, reflection API and macros. At the moment he is working as a PhD student at EPFL performing research in compilers and programming languages.
Tuesday (9th Jun.) 10:25
Wide adoption of Scala has led to it being used in a vast variety of scenarios ranging from simple apps to massively concurrent distributed services handling millions of requests per second. Scaling doesn't come for free and at certain stage one becomes limited by the underlying platform. A common scaling problem on the HotSpot JVM is performance of garbage collection on large heaps. Past certain heap sizes GC pauses become completely unacceptable for latency-critical applications. In this talk, we are going to present an alternative approach for type-safe off-heap memory management that doesn't rely on JVM garbage collection. We believe that it can vastly simplify development of latency-critical applications which suffer from GC pauses. Our framework provides tools for allocation and automatic deterministic deallocation of off-heap memory and other system resources without performance overhead.
Yoyak : Static analysis framework for Scala
Heejong Lee
Close
Yoyak : Static analysis framework for Scala
Heejong Lee
Heejong Lee is a software engineer and a static analyst who has been working in a static analysis industry since 2008. He is also a Scala evangelist and an open source contributor.
Tuesday (9th Jun.) 10:25
Yoyak is a generic static analysis framework implemented in Scala. As far as we know, a few static analyzers[00,01,02] already exist in Scala world. While most of them only provide syntactic error checking[00] or pattern matching[01,02] for Scala sources, Yoyak can evaluate semantics of any input programs i.e. finding a fixed-point based on the theory of abstract interpretation. Static and semantic analysis technology is a key to many applications ranged from finding security vulnerabilities to improving software quality. As a solid example, we implement Android malware analyzer Dotbogey on our Yoyak framework. Dotbogey analyzes what hosts the given app connects to by simple string analysis, then checks whether the found hosts are malicious or not. In this talk, we will focus on what is Yoyak and how users can make their own semantic analyzer on it and present the working demo of Dotbogey.
11:10 Break
11:35
From Java to Scala in Less Than Three Months
Daniel Nowak
Zalando
Alexander Kops
Zalando
Close
From Java to Scala in Less Than Three Months
Daniel Nowak
Zalando
Daniel Nowak has been Head of Logistics Software at Zalando, Europe's leading online fashion platform for men, women and children, since 2012 after serving as backend team lead and senior developer for two years. During his time with Zalando he has guided logistics from a zero- to 80-person team--working on topics such as warehouse automation, smarter item distribution and efficiency. He has rewritten the whole system twice and recently introduced Scala and Play Framework for Zalando’s curated shopping platform, Project Z. Besides that he was responsible for the first Zalando open source contribution: an OR Mapper that supports a PostgreSQL typing system. A 2006 graduate of Freie Universität Berlin, Daniel lives in Berlin and spends his free time coding, reading, watching TV shows and drinking beer.
Alexander Kops
Zalando
As Delivery Lead, Brand Solutions at Zalando, Alexander Kops oversees development related to core functions important to Zalando's brand partners--from analytics to user services. This is his second stint with Zalando: In his previous turn with the company, he completely rewrote its PHP-based system to a modular Java-based architecture. As a Scala and Play Framework enthusiast, he is driving adoption of these technologies within Zalando. He has experience leading both front- and back-end engineering teams and has also helped lead Zalando’s intensive mentoring initiatives.
Tuesday (9th Jun.) 11:35
Many people suggest that Scala is difficult to learn and adopt quickly. Based on our experiences as team leaders, however, a bit of groundwork-laying and communication can make a huge difference in speeding up the onboarding process and achieving success in implementing Scala at large scale. In this talk, one of us (Daniel Nowak) will explain how Zalando’s logistics engineering team used Scala and Play Framework--despite never having before used either technology--to build a brand-new platform connecting external fashion stylists with millions of customers, in just two months. Daniel will also focus on how the team created a build system to make Zalando’s front-end engineers--also complete Scala newbies--comfortable with using Scala and Play; this was the most difficult, but perhaps the most important part, of the development process. The other one of us (Alexander Kops) will describe the Scala implementation process for Zalando’s brand solutions team--highlighting some of the difficulties of learning three things (functional programming, a new language and a new tooling system) simultaneously, and ways to overcome them. Finally, we’ll wrap up by providing tips on how to ease Scala onboarding within your organization, so you can achieve the same fast results.
Lambda Architecture with Spark Streaming, Kafka, Cassandra, Akka and Scala
Helena Edelson
DataStax
Close
Lambda Architecture with Spark Streaming, Kafka, Cassandra, Akka and Scala
Helena Edelson
DataStax
Helena is a committer on several open source projects including Akka (Akka Cluster), Apache Spark, the Spark Cassandra Connector, Spring Integration and Spring AMQP. She has been a Senior Software Engineer, Senior Cloud Engineer, Principal Engineer and Architect over the last 15 years. Her primary academic background is in science, specifically biology, where her studies of energy pathways in large-scale dynamic systems and biological system modeling led her to tech. For the last several Helena has been working in big data in the domains of cyber security and technology, and in Scala for 6 years. She is currently a Senior Engineer on the Analytics team at DataStax, working with Apache Spark, Cassandra, Kafka, Scala and Akka. Most recently she has been a speaker at international Big Data and Scala conferences including Strata, Spark Summit, Emerging Technologies (ETE) and Code Neuro.
Tuesday (9th Jun.) 11:35
This talk will start by addressing what we need from a distributed big data pipeline in terms of performance, reliability and scalability. From there I will step into how this particular set of technologies addresses these requirements and the features of each which support them. Then we step into Spark (Spark Streaming, Spark MLLib and Spark SQL), Kafka, Cassandra and Akka to show how they actually work together, from the application layer to deployment across multiple data centers, in the framework of Lambda Architecture. Finally, I will show how to easily leverage and integrate everything very cleanly in your Scala code for fast, streaming computations in asynchronous event-driven environments.
Performance Testing Crash Course
Dustin Whittle
AppDynamics
Close
Performance Testing Crash Course
Dustin Whittle
AppDynamics
Dustin Whittle is a Developer Evangelist at AppDynamics where he focuses on helping organizations manage application performance. Before joining AppDynamics, Dustin was CTO at Kwarter, a consultant at SensioLabs, and developer evangelist at Yahoo!. He has experience building and leading engineering teams and working with developers and partners to platforms. When Dustin isn't working he enjoys flying, sailing, diving, golfing, and traveling around the world. Find out more at dustinwhittle.com or follow him @dustinwhittle.
Tuesday (9th Jun.) 11:35
The performance of your application affects your business more than you might think. Top engineering organizations think of performance not as a nice-to-have, but as a crucial feature of their product. Those organizations understand that performance has a direct impact on user experience and, ultimately, their bottom line. Unfortunately, most engineering teams do not regularly test the performance and scalability of their infrastructure. Dustin Whittle shares the latest performance testing tools and insights into why your team should add performance testing to the development process. Learn how to evaluate performance and scalability on the server-side and the client-side with tools like Siege, Bees with Machine Guns, Google PageSpeed, WBench, and more. Take back an understanding of how to automate performance and load testing and evaluate the impact it has on performance and your business.
Meerkat parsers: a general parser combinator library for real programming languages
Ali Afroozeh
Centrum Wiskunde & Informatica (CWI Amsterdam)
Anastasia Izmaylova
Centrum Wiskunde & Informatica (CWI Amsterdam)
Close
Meerkat parsers: a general parser combinator library for real programming languages
Ali Afroozeh
Centrum Wiskunde & Informatica (CWI Amsterdam)
Ali Afroozeh is a PhD student at Centrum Wiskunde & Informatica (CWI) in Amsterdam. His research is about general parsing algorithms. During the last three years he has been busy implementing a practical GLL parser (called Iguana) in Java. Recently he got interested in functional programming and worked on general parser combinators (Meerkat parsers). He has given talks at academic conferences.
Anastasia Izmaylova
Centrum Wiskunde & Informatica (CWI Amsterdam)
Anastasia Izmaylova is a PhD student at Centrum Wiskunde & Informatica (CWI) in Amsterdam. Her research is about language semantics, language design and implementation and compiler construction. She is also interested in functional programming and recently in general parsing. She has given a number of scientific presentations, the most recent one is the preview of Meerkat parsers at the parsing workshop at SLE'14.
Tuesday (9th Jun.) 11:35
Parser combinators are an attractive approach to parsing in which grammars are directly executable. Parser combinators are easy to use and enable fast language prototyping and experimentation. The seamless integration with the host programming language makes them flexible and extensible. Parser combinators, like other recursive-descent parsers, have two major shortcomings: they do not directly support left recursive rules and can be worst-case exponential due to backtracking. Grammars of real programming languages, however, often contain left-recursive rules (expressions) and are not deterministic. How can we write a grammar of a real programming language, such as Java, in its most natural form and easily get a working, correct and efficient parser? In this talk we present the Meerkat library, a general parser combinator library written in Scala, that combines the flexibility of traditional, monadic parser combinators and the expressivity and worst-case performance guarantees of state-of-the-art general parsing algorithms, such as GLL and GLR. Using the Meerkat library, it is possible to directly encode any context-free grammar, including the ones with direct and indirect left recursion, in Scala. Meerkat parsers support ambiguity, by producing a parse forest in cubic time and space, and can behave nearly linear on grammars of real programming languages. We demonstrate Meerkat’s embedded DSL, and discuss a number of core challenges in parsing real programming languages. We introduce custom combinators, for example, for layout and disambiguation, that address these challenges. We also tackle more advanced parsing problems such as parsing indentation-sensitive languages.
12:20 Lunch
13:20
From Source: Scala at Twitter
Stu Hood
Close
From Source: Scala at Twitter
Stu Hood
Stu has been working on production Scala services at Twitter for about 4 years. His background is in search and databases, but he's currently working on Twitter's build team to help make building Scala as pleasurable as it is to write Scala.
Tuesday (9th Jun.) 13:20
In the six years that Twitter has been using Scala, the way that we build, share, and ship code has changed drastically. Along the way we found 10,000 ways that didn't work, but we think we've come up a with a pretty decent approach to keeping more than 1500 engineers productive in a codebase of more than 3 million lines of Scala code.

This talk will cover the past and future of Scala tooling at Twitter. And in particular, it should show why we are eager and able to participate in exciting platform advancements like Dotty.

5 minute Microservices
Christopher Hunt
Typesafe
Close
5 minute Microservices
Christopher Hunt
Typesafe
Tuesday (9th Jun.) 13:20
In this talk, we'll code up a microservice from scratch and then deploy into Typesafe ConductR, a new product for rapid deployment and management of reactive applications.
Fixing Reactive Code at 100 Miles per Hour: Five Techniques to Improve How You Debug Scala and Akka
Tal Weiss
Takipi
Close
Fixing Reactive Code at 100 Miles per Hour: Five Techniques to Improve How You Debug Scala and Akka
Tal Weiss
Takipi
Tal Weiss is the CEO of Takipi - God Mode in Production Code. Tal has been designing scalable, real-time Java, Scala and C++ applications for the past 15 years. Previously, Tal was co-founder and CEO at VisualTao, acquired by Autodesk in 2009. Following the acquisition Tal was the Director of the AutoCAD web & mobile product line, used by 17 million professional users worldwide. Prior to VisualTao, Tal worked as a software architect at IAI Space Industries focusing on real-time satellite tracking systems. He still enjoys analyzing a good bug and instrumenting JVM code. In his free time Tal plays Jazz drums.
Tuesday (9th Jun.) 13:20
Production debugging is hard, and it’s getting harder. With architectures becoming more distributed and code more asynchronous and reactive, pinpointing and resolving errors that happen in production is no child’s game. This session covers some essential tools and more advanced techniques Scala developers can use to debug live applications and resolve errors quickly. It explores crucial techniques for distributed debugging - and some of the pitfalls that make resolution much harder, and can lead to downtime. The talk also touches on some little-known JVM tools and capabilities that give you super-deep visibility at high scale without making you restart it or attach debuggers.
Making your Scala applications smaller and faster with the Dotty linker
Dmitry Petrashko
EPFL LAMP
Close
Making your Scala applications smaller and faster with the Dotty linker
Dmitry Petrashko
EPFL LAMP
Dmytro Petrashko is a programming languages and algorithms researcher and a doctoral assistant at EPFL. He is currently working on a doctorate as a research assistant in the School of Computer and Communication Sciences at the EPFL in Switzerland, on experimental Dotty compiler for Scala and ScalaBlitz - macro generated collections for Scala.
Tuesday (9th Jun.) 13:20
Making your Scala applications smaller and faster with the Dotty linker
   
Have you ever dreamed of Scala having collections as fast as C++? Or asked yourself, why you should depend on whole 5 Mb-standard library jar if you just write a “HelloWorld”? Or wanted your application to start faster? Or, maybe, you are Scala-android developer and hitting 65k method limit?
 
Scala was made to be run on JVM, but JVM is not made to run Scala. JVM isn’t aware of Scala semantics and misses optimization opportunities. In recent years several projects proved that there is a big potential in applying Scala-specific optimizations inside the compiler: ScalaBlitz showed that optimizing collections operations makes them quite a few times faster, Miniboxing introduced ways to improve both memory footprint and performance.

In Dotty we're exploring a radically new approach to optimization. We're planning to enhance the usual Scala development workflow with an optional linking step that will have previously unseen powers to make programs as fast as possible. By analyzing entire applications with all their dependencies at once, the Dotty linker can strip swaths of unused code, specialize polymorphic methods and classes to their concrete instantiations, and much-much more.

Our talk will present the design of the Dotty linker and the vision of improvements to Scala ecosystem that will be enabled by this new core tool. On an example of Scala collections, we will see how linker can provide reliable performance gains for non-trivial abstraction-rich code that was previously very hard to optimize.
14:05 Break
TRACK
Cool Stuff, IoT Tuesday
Enterprise (Big Data, Reactive, Security, etc.) Tuesday
Tools web, best practices Tuesday
Core Scala (Functional Programming, Academic) Tuesday
14:30
Distributed Machine Learning 101 using Apache Spark from the Browser
Xavier Tordoir
Andy Petrella
NextLab
Close
Distributed Machine Learning 101 using Apache Spark from the Browser
Xavier Tordoir
After completing a Ph.D in experimental atomic physics, Xavier focused on the data processing part of the job, with projects in finance, genomics and software development for academic research. During that time, he worked on timeseries, on prediction of biological molecular structures and interactions, and applied Machine Learning methodologies. He developed solutions to manage and process data distributed across data centers. Since leaving academia a couple of years ago, he provides services and develops products related to data exploitation in distributed computing environments, embracing functional programming, Scala and BigData technologies.
Andy Petrella
NextLab
Andy, aka noootsab, is a mathematician turned into a distributed computing engineer, mainly in the Geospatial world.
When the Big Data age came in, he decided to enjoy it at most and created NextLab, a Big/Smart Data oriented company.
Since then, he had fun working for IoT, Genomics, Automotive and Smart cities projects. Building Spark jobs, feeding Cassandra rings and shooting data with machine learning guns. He's also a certified Scala/Spark trainer and wrote the Learning Play! Framework 2 book for Packt Publishing.
Tuesday (9th Jun.) 14:30
While machine learning has been used for decades, accessibility to these methods is undergoing a radical shift, with the rise of simple interfaces and implementations on distributed systems. In practice it means that more players can afford to take advantage of Machine Learning and at larger scales.
In this talk we're going to review some Machine Learning concepts, principles and illustrate them with use cases.
Based on simple examples put into a business context, we will demonstrate how to apply different Machine Learning methods, Apache Spark as the distributed processing engine.
These demonstration cases will be controlled from a notebook (browser based editor), showing that accessing Machine Learning methods can be really simple and fun, even in a distributed environment.
Hiring & Onboarding for your Scala Team
Ronnie Chen
Will Palmeri
PayPal
Close
Hiring & Onboarding for your Scala Team
Ronnie Chen
Ronnie is a recovering theoretical physicist who left her job as a Sous Chef in a Michelin-starred restaurant to learn how to code. She is an avid deep sea technical diver and rock climber who enjoys writing Scala in her day job as an engineer at PayPal.
Will Palmeri
PayPal
Will is an Engineering Manager at PayPal with the heart of a startup engineer. He co-founded StackMob in 2010 where he built one of the world's first backend-as-a-service for mobile apps. He has experienced the catharsis of converting a java codebase to scala and the pain of debugging monad transformers in the 2.9 compiler. Since joining PayPal he has taken enjoyed mentoring new engineers with the scala/akka/spray stack.
Tuesday (9th Jun.) 14:30
We asked the question of our own engineering team, "Who here joined with Scala experience"?. Of a group of fifteen, only two hands went up. Our team started with Java, Python, Ruby, JavaScript, Haskell, and more in their personal toolkits, but Scala for us has been largely a mixed-in trait.
 
After four consecutive years of shared Scala experience, we present here a handful of working practices surrounding the process of seeking, interviewing, hiring, and onboarding new developers into a Scala codebase and workflow. These include: clear team documentation, a shared "Scala Style Guide" to maintain a uniform codebase, a common repository of useful patterns collected, and the best Scala tutorials for n00bs.
 
The talk will be given by both an experienced Scala hiring manager as well as a recent hire so we can speak from both perspectives. We will present an example interview question that can surface an intuition for functional programming, even if the candidate has never heard of `flatMap`. We will look to our own git history for common pitfalls for an imperative programmer. We will also present several admonishments from our own experience, as we have learned and grown as a Scala team coming from a Java world.
 
By sharing our growing pains, we hope you can hire great Scala engineers and have them writing production code in days.
The Twelve Factor App: Best Practices for Scala Deployment
Joe Kutner
Heroku
Close
The Twelve Factor App: Best Practices for Scala Deployment
Joe Kutner
Heroku
Tuesday (9th Jun.) 14:30
Twelve Factor apps are built for agility and rapid deployment. They enable continuous delivery and reduce the time and cost for new developers to join a project. At the same time, they are architected to exploit the principles of modern cloud platforms while permitting maximum portability between them. Finally, they can scale up without significant changes to tooling, architecture or development practices.
 
In this talk, you’ll learn the principles and best practices espoused by the Twelve Factor app. We’ll discuss how to structure your code, manage dependencies, store configuration, run admin tasks, capture log files, and more. You’ll learn how modern Scala deployments can benefit from adopting these principles, and why they fit nicely within the cloud.
Options in Futures, how to unsuck them
Erik Bakker
Lunatech
Close
Options in Futures, how to unsuck them
Erik Bakker
Lunatech
Erik Bakker has been a full-time Scala developer for for years, and is enthusiastic about functional programming. He has been teaching Scala to team members of the various teams he has been in over the years. Erik Bakker occasionally speak about Scala for various audiences, from basic introductions to Scala for non-Scala programmers at several companies looking to adopt Scala, to advanced talks and hands-on sessions about iteratee fundamentals or functional concepts like monad transformers to people with a Scala background and recently to a group of mostly Academic Haskell users at the Dutch Functional Programming day. Erik Bakker co-authored the book Play for Scala, published by Manning.
Tuesday (9th Jun.) 14:30
Many libraries are asynchronous, and will return everything in a Future. For-comprehensions is a nice way to deal with the contents of Futures, but when the content is wrapped in a container like Option or Either, for-comprehensions alone are not enough. The result is often ugly nested code. This talk will show you how to make for-comprehensions work nicely with such structures. You'll learn how to fuse a Future and an inner container together, and nicely work with them in for-comprehensions. In an asynchronous application, this will give great readability benefits. Finally, we'll see that these friendly and easy to understand things are actually monad transformers.    Additional notes  ---  This talk is a condensed version of a successful longer hands-on session that I did with multiple groups of Scala programmers at companies and a Scala user group event. Most of them really liked this content, because they run into this problem of deeply nested code in practice, usually caused by Future[Option[X]] values. In this talk we don't start with an off-the-shelve monad transformer, but we build one ourselves, by first building a monadic wrapper specialized for Future[Option[X]]. To most people that's surprisingly simple, and immediately after this step we can . We then generalize that into a proper monad transformer for Option inside any other monad, which is also a nice introduction to monads in itself.  Finally we highlight a couple use cases for this, one of them being Play Framework action methods, than can often be written as a single for-comprehension, given a proper monad stack.
15:15 Break
TRACK
Core Scala (Functional Programming, Academic) Tuesday
Cool Stuff, IoT Tuesday
Tools web, best practices Tuesday
Enterprise (Big Data, Reactive, Security, etc.) Tuesday
15:40
State of the Meta, Summer 2015
Eugene Burmako
EPFL
Close
State of the Meta, Summer 2015
Eugene Burmako
EPFL
Programming languages enthusiast, PhD student at EPFL, member of Scala team, Scala macros guy.
Tuesday (9th Jun.) 15:40
scala.meta is the culmination of our experience with metaprogramming in Scala. Our design provides an elegant model of the language and solves the problems of compatibility across compilers and tools. Since the announcement of scala.meta at ScalaDays 2014, we've been working hard turning it into reality.    In the talk, we will demonstrate how existing metaprograms can be migrated to our new platform and highlight the benefits that scala.meta brings to macro users, library designers and tool authors. Curious to see how the unification of trees, symbols and types is working? What additional capabilities do our new quasiquotes have? And have we really managed to allow macros to be defined in the same project that uses them? Come over and see for yourself!
YAB: Yet Another Build tool
Christos KK Loverdos
Close
YAB: Yet Another Build tool
Christos KK Loverdos
Christos KK Loverdos holds a BSc in Computer Science and an MSc in Advanced Information Systems. He dropped out of PhD. He is a passionate computer software professional with 15+ years of expertise in strategic software decisions, technical project management, team coordination and the architecture, design and implementation of flexible, resilient and scalable software. He is a co-author of the book ʺSteps in Scalaʺ, published by Cambridge University Press. He is an active contributor and maintainer of Open-Source software (https://github.com/loverdos). He discovered Scala in 2004 and was a speaker at the first Scala Days in 2010. He occasionally speaks at local user groups, Java & Scala.
Tuesday (9th Jun.) 15:40
I will present the semantics, design and implementation of YAB: a developer-friendly, extensible and fun-to-develop build tool. Build tools, like make, maven, ant, sbt etc are at the heart of the software creation process and they are the pieces that as developers we trust and rely heavily upon. But the existing mainstream build tools have their shortcomings; engineers stumbling on their corner cases and their often not well-designed UI can become frustrated and annoyed. Unfortunately, we have to live with the compromises; or maybe not? Guided by my experience building software for 15+ years, YAB embodies design decisions and wishes for a tool that treats developers as end-users: it is there to get the “job” done in a friendly, predictable way and gives a balanced combination of freedom and semantic precision to define what the “job” is. Building with YAB is liberating and enjoyable.

Yab became ?self-aware? on 2013-11-17, two months after the first commit.
WatchDog: How PagerDuty uses Scala for end-to-end functional testing
Kenneth Rose
PagerDuty
Close
WatchDog: How PagerDuty uses Scala for end-to-end functional testing
Kenneth Rose
PagerDuty
Kenneth Rose is a Principal Software Engineer at PagerDuty in Toronto. Ken's career has taken him over the development spectrum: from working on the C# compiler at Microsoft, to 3D graphics tools and libraries at Autodesk, to most recently writing highly available systems at PagerDuty that keep its notification pipeline running smoothly. He is a recovering C++ developer who has discovered the virtues of Scala while working at PagerDuty.
Tuesday (9th Jun.) 15:40
PagerDuty recently completed a continuously run, end-to-end functional testing suite that externally verifies all aspects of PagerDuty's functional definition. From the outset, a major requirement for this suite was developer user experience. Good library design dictates that the client's experience with your library is paramount, so we needed a mechanism that would allow for tests that were short, easy to write, and easy to understand. Additionally, given that the suite is continuously run against our live production servers, we needed to ensure that it did not introduce significant additional load that could affect our customers.
 
This talk will review how we used ScalaTest, sbt, and various Scala design patterns to implement this system and achieve our goals. In particular:
 
  * How we made defining resources with dependencies, like Schedules and Escalation Policies, quick and painless
  * How we hacked the builder pattern to prevent melting our servers with millions of new entities
  * How account provisioning was made super simple for test authors
  * Our DSL for succinctly expressing expected outcomes from tests
  * New Scala bindings for our REST API
  * How we isolated tests so that smaller, faster tests could run more often than larger, slower tests
Understanding the Back-End of Big Data
Michael Hausenblas
Mesosphere
Close
Understanding the Back-End of Big Data
Michael Hausenblas
Mesosphere
Michael is a Datacenter Application Architect with Mesosphere where he helps developers to build scalable and elastic distributed applications. His background is in large-scale data integration, Hadoop and NoSQL, the Internet of Things, as well as Web applications and he's experienced in advocacy and standardization. Michael is contributing to open source software at Apache (Myriad, Drill) and shares his experience on the Datacenter OS and large-scale data processing through blog posts and public speaking engagements.
Tuesday (9th Jun.) 15:40
 As a rule, Scala developers have a strong appetite for big data frameworks. But often the limits of “what’s possible” have less to do with the frameworks themselves and more to do with the operations of the underlying resources for managing them. In this talk Michael Hausenblas will describe new approaches to managing Spark and Hadoop big data clusters - including a curtain raiser on Project Myriad (a new open source framework for managing Hadoop jobs alongside other applications and services in production). The talk will provide the Scala developer with a clear understanding of different resource management strategies, including a look at Docker Containers, Google Kubernetes, Apache Mesos, the emergent “datacenter operating system” category - and all the context required to help developers come up with a coherent operations strategy to compliment their big data development efforts.
16:25 Break
16:50
Function-Passing Style, A New Model for Asynchronous and Distributed Programming
Heather Miller
EPFL
Philipp Haller
Close
Function-Passing Style, A New Model for Asynchronous and Distributed Programming
Heather Miller
EPFL
Heather Miller is a PhD student in Martin's group and regularly give talks at industrial conferences like Strange Loop, and academic conferences like OOPSLA and ECOOP.
Philipp Haller
Philipp Haller is an assistant professor in the theoretical computer science group at KTH Royal Institute of Technology, the leading technical university in Sweden. Philipp is co-author of Scala's async/await extension for asynchronous computations, and one of the lead designers of Scala's futures and promises library. Main author of the book "Actors in Scala," he created Scala's first widely-used actors library. More recently, he led a research project on Akka actors for Scala.js. Philipp was also co-chair of two editions of the Scala Workshop, and is co-chair of the 2015 Scala Symposium. Previously he has held positions at Typesafe, Stanford University, and EPFL. He holds a PhD in computer science from EPFL.

Tuesday (9th Jun.) 16:50
In this talk, I'll present some of our ongoing work on a new programming model for asynchronous and distributed programming. For now, we call it ?function-passing? or ?function-passing style?, and it can be thought of as an inversion of the actor model – keep your data stationary, send and apply your functionality (functions/spores) to that stationary data, and get typed communication all for free, all in a friendly collections/futures-like package!
Scala needs YOU!
Dick Wall
Typesafe
Close
Scala needs YOU!
Dick Wall
Typesafe
Dick Wall is co-founder and CEO of Escalate Software, LLC, provider of Scala training and consulting. He has been developing primarily in Scala since 2008, developing both commercial and open source projects. Dick contracts as a developer advocate with Typesafe, also co-hosts the Scalawags podcast and founded the Bay Area Scala Enthusiasts, one of the first Scala programming user groups in the world.
Tuesday (9th Jun.) 16:50
Enlist now!    Ask not what your Scala can do for you, but what you can do for your Scala!    Never, in the field of developing Scala, has so much been owed by so many to so few.    Yes, this is a propaganda talk. It's a talk about getting involved, what you can do to help Scala development, and how to do so. We will cover:    - Documentation submissions  - Bug fixes  - Library contributions  and  - Larger Scala language changes (SIPs, etc)    It might be propaganda, but it will not be technically light. Instead we will have practical demos and details of how to contribute each of the above, and why you should do so.    If you have ever thought about volunteering some time on the Scala compiler, Libraries, Documentation or anything else in the Scala-verse, come and find out how.    CODE, FOR VICTORY!
What's new since "Programming in Scala"
Marconi Lanna
Originate
Close
What's new since "Programming in Scala"
Marconi Lanna
Originate
Marconi has been writing software for fun and profit since last century, when the Internet was still black & white and silent. He loves computers, Internet, curly braces, angle brackets, Scala, and working with great people. Marconi is Senior Software Innovator at Originate in Toronto and spends most of his free time trying to finish reading the Internet or getting his little daughter out of trouble. He has been programming in Scala since 2010 and is not afraid of knowing what is a monad anymore.
Tuesday (9th Jun.) 16:50
"Programming in Scala", by Martin Odersky et al., is one of the most comprehensive and the de facto reference for Scala.
 
However, the book, originally published in 2008 for Scala 2.7.2, has not been updated since its second edition in 2010, covering up until Scala 2.8.1. In the meantime, Scala had 3 major releases with numerous fresh and advanced features.
 
While we wait for a third edition of ?Programming in Scala? to describe all the latest and greatest Scala features introduced in the last 4 years, this talk presents the main features introduced in Scala 2.9, 2.10, and 2.11:
 
 * Parallel collections
 * Value classes, implicit classes, and extension methods
 * String interpolation
 * `Futures` and `Promises`
 * Akka actors
 * Macros and quasiquotes
 * Reflection
 * Modularization
 * Dynamic types
 * Error handling with `Try`
 * The `App` trait
 * New methods in collections
 * Case classes with more than 22 parameters
 * `Predef.???`
 * sbt incremental compilation
 * 2.12 and beyond: what's in Scala future?
Large volume data analysis on the Typesafe Reactive Platform
Martin Zapletal
Cake Solutions Limited
Close
Large volume data analysis on the Typesafe Reactive Platform
Martin Zapletal
Cake Solutions Limited
Martin Zapletal is a full time software engineer, currently working in Cake Solutions Limited and using mostly Typesafe technologies. Both currently and in his previous occupations he have had the opportunity to work with large amounts of data and events and participate on data analytics. At the same time he is a PhD. student focusing on distributed systems and big data from both theory and practice point of view. Lately he has been focusing on distributed approaches to processing as well as machine learning and data mining in large volumes of data. Both these fields seem to increasingly important in the industry and the Typesafe stack and Reactive approaches provide very useful tools to solve these problems.
Tuesday (9th Jun.) 16:50
Distributed systems running on cheap hardware or in a cloud and recent progresses in distributed computing theory, frameworks, databases and deployment tools provide a price efficient way to develop data processing pipelines. It allowed many new companies to enter the Big Data market or start using the value of data for internal purposes. But the amount of tools and frameworks can cause confusion and their their proper usage is still not common.
 
Tools running on Typesafe platform such as Spark, GearPump, Reactive Streams or Akka are just some of the tools suited for large volume data processing. How do they relate? What use cases do they cover? How to use them properly and efficiently to build applications?
 
This talk focuses on processing of large volumes of data, mainly to utilize machine learning algorithms, in parallel or distributed environment.
 
It aims to explain different parallel and distributed programming models, use cases, developer considerations, internals and important ideas and concepts behind mentioned frameworks in developer level detail. This includes description of the programming model, work it actually translates to in the background with regards to inter-process communication, how the data are partitioned and distributed, explanation of the coordination and fault tolerance, data locality and movement, query optimisations and more.
 
And finally it offers a peek into how to get most value from the data using these approaches to employ machine learning algorithms demonstrated on a large scale sensor event processing application use case from practice (using Scala, Akka Cluster, CQRS, event sourcing, Spark, machine learning and more).
 
The talk aims at providing insights to developers who are planning to or are already using these tools to be able to choose the right tool for their use case and mainly to help them deeply understand how these systems work internally to be able to make proper considerations during their use.
17:35 Break
TRACK
Enterprise (Big Data, Reactive, Security, etc.) Tuesday
Cool Stuff, IoT Tuesday
Tools web, best practices Tuesday
Core Scala (Functional Programming, Academic) Tuesday
18:00
Kamon: Metrics and traces for your reactive application
Ivan Topolnjak
Kamon OSP
Close
Kamon: Metrics and traces for your reactive application
Ivan Topolnjak
Kamon OSP
Ivan Topolnjak is a passionate software developer working with Scala for a couple years now with some Java and .Net background. During these two years, besides developing real world, high performance applications with Akka and Spray, Diego Parra and I started the Kamon open source project seeking to build a open alternative to the practically inexistent monitoring ecosystem for reactive applications. Today, many big companies are either using or exploring how to use Kamon with their apps, making us want to spread the work further within the Scala community.



Tuesday (9th Jun.) 18:00
Join us and explore what Kamon brings to the table as the de facto open source tool for monitoring reactive applications built with Akka, Spray and Play!. During this session we will review the motivations for some of the core design decisions in Kamon, how those decisions affect the quality and relevance of the information that Kamon can collect from your application and how that can help you make your application better (live demo included).
Exercise in machine learning
Jan Machacek
Close
Exercise in machine learning
Jan Machacek
Jan Machacek is a passionate technologist with hands-on experience with the practical aspects of software delivery (architecture, quality, CI, CD); the project management approaches (applying the principles of agile project management); mentoring and motivating the engineering & business teams. He shares his expertise and passion for software as the editor of the Open Source Journal, regularly contributes to open source projects and speaks at conferences in the UK and abroad. Jan is the author of many open source projects (various Typesafe Activators, Reactive Monitor, Akka Patterns, Akka Extras, Scalad, Specs2 Spring and others), books and articles.
Tuesday (9th Jun.) 18:00
Jan will build a system that collects data from a wearable fitness tracker, communicating through a mobile app to an actor system, which processes the data, looking for type of exercise, effort and checks for proper form. The core of the talk is the actor system in Akka and Scala that—with help from Spark—analyses the data, and exposes appropriate REST APIs. The rest of the codebase includes some C and C++ for the wearables, and Swift in the mobile application. Come to Jan's talk to learn how to make the most of Scala, Akka and Spark, and to see how to combine them to build a fitness tracking and analysis application—all in 60 minutes!
Write once, deploy everywhere
Nepomuk Seiler
Close
Write once, deploy everywhere
Nepomuk Seiler
Nepomuk Seiler is a java developer for 6 years and a scala developer for 3 years. During his spare time he maintain sbt-native-packager and write about java/scala on my blog http://mukis.de
Tuesday (9th Jun.) 18:00
In this talk I will present the main features of sbt-native-packager, which are (at the current moment)
 
 - rpm packaging
 - debian packaging
 - docker packaging
 - msi packaging
 - java application archetype
 - java server archetype
 
Each topic will have a short introduction of the packaging system and a demo how to setup your sbt build to build this package.
 
Finally, if time, I'll show how to implement your own packaging format
Essential Scala: Six Core Principles for Learning Scala
Noel Welsh
Underscore
Close
Essential Scala: Six Core Principles for Learning Scala
Noel Welsh
Underscore
Noel is a partner at Underscore, the leading Scala consultancy. Noel has over fifteen years experience in software architecture and development, and over a decade in machine learning and data mining.
Tuesday (9th Jun.) 18:00
In this talk I will discuss six fundamental concepts that underly effective Scala.
 
How can programmers quickly and effectively learn to write idiomatic Scala? This is a question we at Underscore had to answer when developing our own training material. We knew we wanted to go beyond teaching syntax and give developers the concepts and techniques they needed to develop Scala in a systematic and idiomatic way.
 
We identified six core concepts that cover a wide range of Scala programs. These concepts give programmers a reproducible way to create code -- once the problem domain is understood the code follows through a series of systematic and reproducible steps. The resulting code is robust and easily maintained.
 
In this talk I will describe these six concepts, which are:
 
 - expressions, values, and types;
 - objects and methods;
 - algebraic data types;
 - structural recursion;
 - functors and monads; and
 - type classes.
 
I will show how they let us create code in a systematic manner, and how we can go about teaching the concepts to new Scala developers. This talk should be of interest to anyone who is transitioning to, or leading a team that is transitioning to, Scala, and anyone interested in guidelines for idiomatic Scala code.
18:45
Community Party, Beer sponsored by Bold Radius: Graanbeurszaal
Close
Community Party, Beer sponsored by Bold Radius: Graanbeurszaal
Tuesday (9th Jun.) 18:45
We would like to invite all attendees, sponsors and speakers to the Community Party which will be held at the venue in Graanbeurszaal from 18:45 - 22:00! This is a great chance to network with speakers and other members of the Scala Community. Food and drinks will be provided.  Thanks to Bold Radius who will be sponsoring beer for the party.
Wednesday (10th Jun.)
08:00 Registration Open
09:00
The Future of AI in Scala, and on the JVM
Adam Gibson
Co-founder of Skymind and Creator of Deeplearning4
Close
The Future of AI in Scala, and on the JVM
Adam Gibson
Co-founder of Skymind and Creator of Deeplearning4

Adam Gibson is the cofounder of Skymind and creator of several open-source libraries including Deeplearning4, a distributed deep Learning on the JVM, and ND4J, scientific computing on the JVM, which has a DSL in Scala for different matrix libs (GPUs, native). He is also the author of "Deep Learning: DL4J and Beyond" by Oreilly (forthcoming summer 2015). Adam has a strong track record of doing big data ranging from teaching at the (now acquired) Zipfian Academy to working on terabyte-or-more search indexes.

Wednesday (10th Jun.) 09:00

AI, and deep learning in particular, has made huge advances in both accuracy and speed in recent years, breaking record after record in classifying a range of datatypes, including images, sound, time series and text. Deep learning is essentially machine perception, recognizing patterns in sensory data. With time, it will be implemented more and more on the edge, in low-memory devices in handsets, automobiles and other devices. Scala's speed and versatility put it in a position to dominate numerical computing and therefore AI. The Scala ecosystem, which includes some of the fastest distributed run-times, makes it easy to process the computationally intensive operations that AI requires quickly. So the future of AI on Scala is very fast (real-time streaming data processing). With the JVM, it is also ubiquitous, ranging from Linux servers, to Windows and OSX desktops, to Android phones.

10:00 Break
ROOM Effectenbeurszaal (Ground Floor) Administratiezaal (1 st Floor) Berlagezaal (1 st Floor) Veilingzaal (1 st Floor)
TRACK
Enterprise (Big Data, Reactive, Security, etc.) Wednesday
Cool Stuff, IoT Wednesday
Tools web, best practices Wednesday
Core Scala (Functional Programming, Academic) Wednesday
10:25
Why Spark Is the Next Top (Compute) Model
Dean Wampler
Typesafe
Close
Why Spark Is the Next Top (Compute) Model
Dean Wampler
Typesafe
Dean Wampler is the Big Data Architect for Typesafe. He builds scalable, distributed, ʺBig Dataʺ applications using Spark, Hadoop, and other tools. He is the author of ʺProgramming Scala, Second Editionʺ, the co-author of ʺProgramming Hiveʺ, and the author of ʺFunctional Programming for Java Developersʺ, all from O'Reilly. Dean is a contributor to several open-source projects and he is the co-organizer of several technology conferences and Chicago-based user groups.
Wednesday (10th Jun.) 10:25
Spark is an open-source computation platform for Big Data that has emerged as the successor to MapReduce, the aging standard Hadoop. This talk explains why this change was necessary.
 
Spark provides a concise core API that enables large MapReduce programs to be rewritten as small ?scripts?. Spark has excellent performance, often 100 times better than MapReduce. The core abstractions of Spark facilitate special-purpose APIs, such as SparkSQL, that combines SQL-based queries for asking questions with the core API for general-purpose programming. Other examples are the machine learning library, MLlib, and the graph algorithms library, GraphX. Finally, Spark supports event stream processing.
 
Using examples, we'll also see that the secret to Spark's success is its roots in the Scala programming language and the ?combinators? from Functional Programming, which together provide concise, powerful primitives for composing a wide variety of high-performance applications.
Embedding a language into a string interpolator
Mikhail Limanskiy
Scala enthusiast
Close
Embedding a language into a string interpolator
Mikhail Limanskiy
Scala enthusiast
Mikhail Limanskiy is a software developer from Russia. His professional working experience was started in 2004. The company he works for is called SymphonyTeleca. They supply software services. So, as an engineer he was involved in different projects with Motorola, Nokia, BlackBerry and some other companies. The last three years he participated several Scala + Lift + Akka projects and created several open source Scala libraries.
Wednesday (10th Jun.) 10:25
We all know that Scala is a great language to create DSLs. And in many situations DSL is a best solution. However, in some cases you may want to embed some existing language as is. I suppose string interpolation is a way to do it.
I'm the author of MongoQuery library, which provides string interpolators for creating MongoDB objects. The interpolators are implemented as macros, so the queries syntax is checked at compile time.
So, when you should prefer to use string interpolation instead of DSL or other API? If you have existing language and you need to keep it as is you could consider string interpolators using.
There are several problems you might encounter when you implementing macro based interpolator: How to parse the string? How to implement interpolator as macro? What if you need to pass a type parameter into interpolator? How to be type safe? How to test it?
I hope these tips will be useful for people who going to use Scala macros for the first time.
Delimited dependently-typed monadic checked exceptions in Scala
Jon Pretty
Propensive
Close
Delimited dependently-typed monadic checked exceptions in Scala
Jon Pretty
Propensive
Jon is a longstanding contributor to the Scala community, having launched the first commercial applications written in Scala over ten years ago. He is best known for his work on Rapture, and his contributions to Typelevel Scala.
Wednesday (10th Jun.) 10:25
Scala does not have checked exceptions: the compiler will not consider a failure to handle exceptions as an error. This is, perhaps, the single area in which Java offers better static safety than Scala, but offers no way for this checking to be turned off when it's not wanted, which frequently leads to the compiler being a hindrance rather than a help to developers. Jon will demonstrate how Scala's type system can be persuaded to enforce checked exceptions, with negligible syntactic burden at the call site, supporting validation-style aggregation of exceptions, and with the flexibility to be turned on and off as desired.
Types vs Tests : An Epic Battle?
Amanda Laucher
Close
Types vs Tests : An Epic Battle?
Amanda Laucher

Amanda Laucher has been working with technology her entire life. Some of her favorite childhood memories include working with punch cards alongside her grandmother or learning Morse code from her dad. Solving complex business problems with code is her passion. She is currently working for Neo Technology and using the graph database Neo4j. You are likely to find her discussing intricacies of languages and type systems, development processes or American football.

Twitter: @pandamonial

Wednesday (10th Jun.) 10:25

Becoming a professional programmer in the days of Test Driven Development, many are led to believe that there is only one approach to software design and that everyone else is wrong. But what if you’re also a Type fanatic like me? Can these two methods live in harmony? Should they? In this talk we’ll take a rational look across the spectrum of Test and Type driven design, examining the benefits and limitations of these approaches, as well as the language and library features that best serve these differing needs.

11:10 Break
11:35
The Reactive Streams Implementation Landscape
Mathias Doenitz
Close
The Reactive Streams Implementation Landscape
Mathias Doenitz
Original author of spray.io, current Akka HTTP team member.
Wednesday (10th Jun.) 11:35
One of the most exciting developments of the last 12 months has been the advent of ?Reactive Streams?, a powerful new abstraction for defining and scaling pipelined processing logic in a fully asynchronous, non-blocking and generally *reactive* fashion.
A primary goal of the Reactive Streams project is thereby to allow for and encourage the co-existence of potentially many different implementations which, by conforming to the open Reactive Stream Standard API, are guaranteed to all be fully interoperable.
For users this has the advantage of being able to mix and match any number of tools in a single application, according to their individual strengths, without the risk of incompatibilities or any significant interfacing cost.
 
This talk will take you on a tour through the current landscape of Reactive Streams implementations on the JVM, comparing and contrasting their general approaches, design principles and implementation choices.
 We'll look at the overall feature sets, individual user DSLs and also basic benchmark and performance figures.
 
So the next time you are faced with the question of which Reactive Streams implementation to pick for a particular task, choice paralysis won't be a problem.
SimpleFX a new Scala DSL for W.O.R.A.
Florian Kirmaier
CTO and Co-Founder of SANDEC
Hans-Henry Sandbaek
CEO and Co-Founder of SANDEC
Close
SimpleFX a new Scala DSL for W.O.R.A.
Florian Kirmaier
CTO and Co-Founder of SANDEC
Florian Kirmaier's mission is to bring UI-Programming to a new level. To achieve this, he co-founded SANDEC and created SimpleFX as the Leading-Developer.  SimpleFX is a DSL to write cross-platform UI's which promotes a style of programming, which can be called "Binding Oriented Programming". This is much more precise and elegant, than classical UI-code. The program becomes much closer to the way we think.  His goal is to evangelize these benefits and make them our every day tool.
Hans-Henry Sandbaek
CEO and Co-Founder of SANDEC
Hans-Henry has a long track record in providing top notch multimedia technology for the TV industry.  As being his specialty most successful European TV news systems on the market today are bearing his signature.  As a seasoned computer scientist he took the initiative in 2014 to found SANDEC to build his own DSL, which he uses as the central tool for building his new generation of multimedia products.  His lifetime experience of being an entrepreneur and an innovative software strategist has resulted in the creation of SimpleFX, which allows you to write efficient and concise code and to run it on almost any platform available.
Wednesday (10th Jun.) 11:35
SimpleFX is about a new DSL for cross platform development.  It contains a disruptive feature-set for, but not limited to, UI development, with an elegant and expressive syntax.  This DSL significantly simplifies dealing with issues like Animations, Expression Binding, Event-Logic and Invariants.  You will see some heavy use of Scala Macros, enabling syntax elements which you have not seen in Scala before. 
In some practical samples and live coding you will see new programming paradigms, such as Extension Classes(going a step further than Implicit Classes), Imply-statements, Progressive Bindings, as well as a new invariant-based and declarative programming style.  With SimpleFX the W.O.R.A. paradigm has been truly implemented, providing a Scala-based platform for writing one piece of source-code, which can run basically anywhere.  We will show samples written in the Scala-based SimpleFX, which run on Desktops, iOS, Android, Embedded Devices and in plugin-free  Standard-Browsers.

Ensime - why would anybody build another Scala IDE?
Sam Halliday
Rory Graves
Close
Ensime - why would anybody build another Scala IDE?
Sam Halliday
Sam Halliday - Chartered mathematician and software engineer with a love for technology innovation. I have a decade of delivery experience
to customers such as: UK MoD, European Space Agency, Tesco Bank, RBS, Morgan Stanley, Motorola and BBC. Has landed on the Mun.
Rory Graves
Rory is passionate about building great software building everything from mobile phone games to real time pricing engines far too long.
- previously taught university level courses and has spoken at professional conferences.
Wednesday (10th Jun.) 11:35
Ensime (https://github.com/ensime/ensime-server) is a tool for
bringing IDE features to any text editor.
 
Although originally designed to support Emacs, we aim to bring ENSIME
to any editor that supports extension.
 
ENSIME has a fundamental goal of lowering the bar for contribution. An
aggressive continuous integration and deployment process means that
community-contributed features can be in users hands within hours
compared to the weeks and months of traditional IDEs.
 
During the talk we will cover a number of key areas:
 * ENSIME as an IDE, the editing and debugging features it has and how it compares to Eclipse and IntelliJ
 * ENSIME's design model (a separate process) and the advantages/disadvantages this gives.
 * Our continuous test/deployment pipeline and how this supports rapid evolution and developer contribution.
 
The final part of the talk will focus on Ensime as a API. Using ENSIME
as an API allows a developer to ask and answer deep questions about a
codebase and we will show some of the cool things it is possible to
build on top of the toolset.
A purely functional approach to building large applications
Noel Markham
ITV
Close
A purely functional approach to building large applications
Noel Markham
ITV
Noel Markham started out as a Java developer in finance, before moving to functional programming in startups for both games and social media. He is currently creating microservices using Scala for ITV, a national TV broadcaster in the UK.
Wednesday (10th Jun.) 11:35
One of the challenges of using a functional language, particularly when coming from an imperative one is how to work with an immutable, fully typed language, and make the most of those features.
This talk aims to highlight some useful approaches and patterns to create modular, easily testable applications in Scala by building a small, toy application from scratch covering:
  * Scalaz’s Reader and ReaderT monads
  * Abstraction over monads, and why this is useful
  * Using the ScalaCheck library with non-trivial code
  * An alternative, fully type-safe approach to creating application configuration
12:20 Lunch
13:20
Reactive Slick for Database Programming
Stefan Zeiger
Typesafe
Close
Reactive Slick for Database Programming
Stefan Zeiger
Typesafe
Stefan Zeiger is the tech lead for Slick. He joined Typesafe in 2011 after developing ScalaQuery, the predecessor to Slick, in order to work on the new project full-time. He has been a user of Java and the JVM platform professionally since 1996, working on a diverse range of projects from web servers to GUI frameworks and programming language design, and moving on from Java to Scala since 2008. He is a prolific speaker at Scala and Java conferences, with talks about Slick and more general Scala-related topics.
Wednesday (10th Jun.) 13:20
When it comes to using relational databases in a reactive, scalable and non-blocking application design, Java's standard JDBC API and the way in which it is traditionally used has always been a sore point. Scoping database sessions correctly and configuring a connection pool in an efficient way were already non-trivial in blocking JEE-style applications, but if you try to fit the inherently blocking JDBC API into a Play or Akka app, it gets even harder. In the newest version of Slick, Typesafe's database library, we provide a different way of sequencing database actions, based on the ideas of Haskell's IO monad. This talk will show you how to use this new API to safely compose and execute database calls, returning Futures and Reactive Streams from them. Bridging the gap between the blocking JDBC API and your non-blocking applications also requires a very different threading model and connection pool configuration than in a blocking app. You will learn what Slick does behind the scenes to take care of these issues in order to give you good scalability and performance out of the box.
Towards Browser and Server Utopia with Scala.JS: an example using CRDTs
Richard Dallaway
Underscore Consulting
Close
Towards Browser and Server Utopia with Scala.JS: an example using CRDTs
Richard Dallaway
Underscore Consulting
Richard is a partner at Underscore, the UK-based Scala consultancy. He has worked as a software engineer and consultant, for web, data mining and visualisation projects across the publishing, financial, and manufacturing industries. He's the author of the Lift Cookbook (O'Reilly, 2013).
Wednesday (10th Jun.) 13:20
This session demonstrates the practical application of Scala.JS using the example of a collaborative text editing algorithm, written once in Scala, but used from the JVM and JavaScript.
 
Scala.JS is a compelling way to build JavaScript applications using Scala. It also addresses an important and related problem, namely using the same algorithm client-side and server-side.
 
After this session you'll have an appreciation of:
 
 - where Scala.JS can help with mixed environment projects;
 - some of the gotchas you might encounter; and
 - an understanding of collaborative text editing and CRDTs.
 
This session is relevant to anyone wanting to execute Scala code in JavaScript. In particular I'll focus on exposing Scala code for use from JavaScript, rather than a complete application written solely in Scala. This mitigates the risk of adopting Scala.JS, while still benefiting from shared code usage.
 
The demonstration will be based around a CRDT. CRDTs are an important class of algorithms for consistently combining data from multiple distributed clients. As such they are a great target for Scala.JS: the algorithms and data-structures involved will typically need to run on browsers and servers and we'd like to avoid implementing the (moderately complex) code twice. The specific algorithm will be WOOT, a text CRDT for correctly combining changes (think: Google Docs).
Almost Zen: Reflections on Four Years of Scala in Practice
Alex Yakushev
Andrew Harris
Close
Almost Zen: Reflections on Four Years of Scala in Practice
Alex Yakushev
PayPal
Alex Yakushev has over 10 years of experience with production code on the JVM, from simple web apps to huge backend services. For the last four years Alex has been focused on creating great Scala services at StackMob and later PayPal.
Andrew Harris
Andrew has worked on backend services with Scala at StackMob and PayPal for three years. Before this, he studied human-computer interaction and social computing at the University of Illinois at Urbana-Champaign, with research in crowd engagement, aphasia and empathy, and autism in children.
Wednesday (10th Jun.) 13:20
Our team at StackMob (and now PayPal) started using Scala in the early 2.9.x days and we thought we had mastered it. We had not. Fast forward to today, we're four years, three Scala versions, lots of hiring, and an acquisition later. All of these things have impacted the way we build systems in Scala. We’ll explore this evolution with actual code samples pulled from our git history to highlight our move from writing Java (in Scala) to Haskell (in Scala) to a happy medium. We’ll discuss code clarity in the context of Scala and the way we evolve our style guidelines in order to maintain consistency throughout our codebases and why it’s important. Most importantly, we’ll highlight the errors we made so that others may avoid them.
Program Functionally, Execute Imperatively: Peeling abstraction overhead from functional programs
Alexander Slesarenko
Huawei Technologies, Russian Research Center, Moscow
Close
Program Functionally, Execute Imperatively: Peeling abstraction overhead from functional programs
Alexander Slesarenko
Huawei Technologies, Russian Research Center, Moscow
Alexander is a principal engineer at Huawei Research Center in Moscow. He is leading the Scalan project - a framework for creating high-performance DSLs in Scala. He also worked in the IT industry as software architect for several years.
Wednesday (10th Jun.) 13:20
Functional programming is quite popular in Scala community as it allows to write software in
a composable and reusable way. Unfortunately functional abstractions often introduce a substantial overhead at the execution time.

In this presentation we will look at Scalan - a generic DSL development framework in Scala which is designed to solve this performance problems in many FP use cases.

Well known FP abstractions and combinators can be implemented in Scalan and then compiled into efficient executable code - a composition of a predefined core primitives like scalar operations, loops, operations on lists, IO etc.
Using simple examples from FP we will look at compilation pipeline of Scalan in action. We start from DSL embedding, then discuss transformation and specialization techniques based on staged evaluation, then generation of efficient imperative code using LMS and finally performance evaluation and speedups. 

14:05 Break
TRACK
Cool Stuff, IoT Wednesday
Enterprise (Big Data, Reactive, Security, etc.) Wednesday
Tools web, best practices Wednesday
Core Scala (Functional Programming, Academic) Wednesday
14:30
Scala.js Semantics - and how they support performance and JavaScript interop
Sébastien Doeraene
EPFL
Close
Scala.js Semantics - and how they support performance and JavaScript interop
Sébastien Doeraene
EPFL
Ph.D. student in M. Odersky's lab at the EPFL. I am the author of Scala.js.
I have spoken at Strange Loop in 2012, at Scala Days 2013 and 2014, at Scala eXchange 2013 and 2014, at JAX Con Germany 2014. I have also given various talks in local Scala and JavaScript user groups.
Wednesday (10th Jun.) 14:30
Getting a language to compile to JavaScript is relatively easy. What's not so easy is: a) making it efficient and, most importantly, b) interoperating with JavaScript. For the latter, in particular, too many languages fail to provide consistent, easy to use and understand interoperability with JavaScript.
 
Scala.js is an exception to this rule: interoperating with JavaScript blends in the language itself and its semantics, up to the point where, seeing a piece of Scala.js code, you can hardly tell what is Scala.js and what is JavaScript. Basically similar to how Scala interoperates with Java.
 
In this talk, we will precisely explore the semantics of Scala.js, how they differ from those of Scala, and how they are, perhaps unexpectedly, equivalent to those of Scala. During this journey, we will see how they support almost transparent JavaScript interoperability. We will also cover the most important trade-offs that were made to allow the compiler to emit extremely efficient code for production, while retaining easy debugging during development.
 
No previous knowledge of Scala.js is required to follow this talk, although it's definitely most useful if you use or plan to use Scala.js. However, we assume a working knowledge of Scala, and basic knowledge of JavaScript.
So how do I do a 2-phase-commit with Akka then?
Lutz Huehnken
Typesafe
Close
So how do I do a 2-phase-commit with Akka then?
Lutz Huehnken
Typesafe
Lutz Huehnken is a Solutions Architect at Typesafe. He has worked in professional software development since 1997, and has successfully deployed major web applications for clients in different fields (retail, logistics, hospitality, finance). After 15 years of Java development, Lutz has made the switch to Scala in 2012 and has made it his ongoing task to help others to do the same.
Wednesday (10th Jun.) 14:30
 Among the first questions I had when I discovered Play and Akka were: ?How do I deploy the app on an application server?? ?How can I use a distributed transaction??.
 
Only to discover that the answer is: You don't want to.
 
Many developers - the speaker included - have developed applications in a ?Java Enterprise Edition? fashion for 10 years or more and are sometimes stuck in a certain way of thinking.
 
We are going to explore some patterns that we assume to be ?the way of doing things?, take a critical look at them, and see how they translate - or don't translate - to a more distributed, asynchronous, reactive mindset.
 
Talk talk will focus on
 - Threads in Java EE- one thread per request, keeping data in ThreadLocal - vs. sub-thread concurrency
 - Distributed transactions, 2-phase-commit - ?all-or-nothing? in a distributed, asynchronous world
 
Audience:
This talk is targeted at developers new to Play and Akka.
Building your first REST API in less than 30 minutes
Thomas Meijers
Lunatech
Close
Building your first REST API in less than 30 minutes
Thomas Meijers
Lunatech
Thomas Meijers is a part-time software developer at Lunatech, while still pursuing a bachelor degree in Information Technology. With his passion for writing complex software, he mostly focusses on the combination of Scala with the Play Framework. With this basis he further fills his toolbox with practices such as functional programming, REST, reactive programming and NoSQL databases.
Wednesday (10th Jun.) 14:30
Play is fundamentally a framework for writing REST APIs. Therefore writing such a REST API, is very easy using Play. With the use of ScalikeJDBC, a tidy SQL-based DB access library, and the reverse engineering tool that comes with it, most of the work gets done for you. After this talk you’ll be able to build your first REST API in under 30 minutes, with model classes that are fully tested as well!
Project Valhalla: Part 2 – Value Types in the JVM
Simon Ochsenreither
Close
Project Valhalla: Part 2 – Value Types in the JVM
Simon Ochsenreither
Hack on the Scala compiler, standard library and related things. Organizer of the Functional Programming User Group in Karlsruhe, Germany and give talks on a semi-regular basis, for instance at ScalaDays 2014 in Berlin.
Wednesday (10th Jun.) 14:30
Work is currently underway in OpenJDK's Project Valhalla to add value types and specialized generics to the Java Virtual Machine.

This talk focuses on value types, as specialized generics have already been covered in depth in Vlad Ureche's talk Project Valhalla: The Good, the Bad and the Ugly at ScalaDays San Francisco.

First-class support for value types in the JVM will enable better performance for Scala's AnyVal types and make it possible to drop certain restrictions: for instance defining value types which wrap more than a single value, or working with arrays of value types without the boxing overhead.

It also has the potential to decrease the semantic mismatch between Scala's view of value types and the resulting bytecode – which has to obey the JVM's restrictions and limitations.

In this talk, we first dive into the technical details of value types and explore the design documents as well as the specification drafts. Then we have a look at the current state of the implementation in OpenJDK. After that, we investigate the advantages and disadvantages of this approach, the impact on the classfile format, and how value types and specialized generics fit together.

The goal of this talk is to present some of the ongoing improvements currently being worked on by Oracle and show how Scala can benefit from them.

15:15 Break
15:40
The road to sbt 1.0 is paved with server
Eugene Yokota
Typesafe
Josh Suereth
Typesafe
Close
The road to sbt 1.0 is paved with server
Eugene Yokota
Typesafe
Eugene Yokota works on sbt at Typesafe. He has also written and maintained sbt plugins like sbt-assembly and sbt-buildinfo. When he can find time, he also works on personal projects like scalaxb, scopt, and treehugger.scala and writes blog articles on eed3si9n.com, 'learning Scalaz' series, and translates Scala documentations into Japanese.
Josh Suereth
Typesafe
Josh Suereth is a Senior Software Engineer at Typesafe and the author of “Scala In Depth”. He started his professional career as a software developer in 2004 using programming languages like C++, Perl and Java. In 2009 he began writing the book “Scala In Depth” which provides practical support for using Scala in every day applications. Josh regularly shares his expertise in articles and talks.
Wednesday (10th Jun.) 15:40

This talk details the technical outline of the sbt as a server/service. We start of with an architectural discussion of what the sbt server is and who it is for, along with how it will help the entire scala ecosystem.

Next we look into the fun details including guides for various users:

 

  • Details of the client API design for IDEs and other consumers of sbt
  • Details for how existing plugin authors can interact with IDEs
  • Example usages in the wild (Play, Activator)

 

Easy Scalability with Akka
Michael Nash
BoldRadius Solutions
Close
Easy Scalability with Akka
Michael Nash
BoldRadius Solutions
For over thirty years, Michael has designed, developed, shipped and consulted on software development projects for clients of all shapes and sizes. As an advocate for software craftsmanship with expertise in project management and architecture, Michael was amongst the earliest of adopters of the Typesafe Stack, with over 5 years experience working with Scala, Akka and Spray.
Wednesday (10th Jun.) 15:40
Every enterprise developer these days needs to be an expert in building REST API systems to enable mobile applications, SOA architectures and single page javascript web apps. The challenge is that most REST API backends can’t quickly scale to the numbers of requests needed in a modern enterprise. In this talk, we will introduce enterprise developers to Akka in an engaging and simple way and give them the confidence that they could quickly and easily build an enterprise web service that scales in their own workplace.
 
 This live coding session will showcase Akka’s power by taking an existing REST API and improving its throughput drastically by introducing a distributed actor system.
 
Starting from a simple RESTful application exposing read and write operations, we’ll introduce a series of Akka features and patterns, scaling the performance and reliability of the system progressively.
 
We will introduce the Actor pattern, and show how Akka brings this pattern easily and simply to the JVM.
 
A simple actor system will separate concerns and serve as the basis of the exercise. Clustering will allow the system to grow and shrink dynamically, across one or more machines, with messages being passed transparently between nodes as needed. CQRS (Command-Query Response Separation) will decouple writes from reads and introduce non-blocking message handling, and Akka Persistence will make nodes tolerant to failure and avoid data loss.
 
We’ll show how simple decoupling via message-passing of the system components allows you to scale each part of your service to match changing load.
 
If you need more write performance, you can increase the number of nodes handling writes. Need more REST-API capability, increase the nodes binding to HTTP. Each element is independently elastic for full tuneability.
 
Throughout the process, we’ll use Gatling to gauge our results in the form of handled requests per second. Watch our application go from Fast to Enterprise-Level Web Scale in 45 minutes or less, with very little code.
 
The talk will be accompanied by an Activator Template combined with a comprehensive tutorial that will allow anyone to replicate the evolution and results shown on stage. No need to worry about dependencies.
 
We also talk about the real-world concerns of deployment, uptime and monitoring: What you need to actually take your application all the way to production.
 
Combined with your own front-end, you’ll have everything you need to build a web application or service that easily handle tens of thousands of concurrent requests on commodity hardware.
Low-Friction Microservices with Scala and Play
Toby Sullivan
Hootsuite
Close
Low-Friction Microservices with Scala and Play
Toby Sullivan
Hootsuite
Toby Sullivan is an engineering lead on Hootsuite's Data Lab team. He and the team are responsible for all things big data at the company.
Wednesday (10th Jun.) 15:40
We build APIs constantly. Any truly scalable system is built from service upon service upon service. Near-infinite scaling is the promise of service oriented architectures. Until recently, however, there has always existed varying amounts of friction in launching a new service/API for new functionality. Instead, the path of least resistance has been to tack new functionality into existing services. This threatens our ability to scale and is major technical debt.
 
Now the tables have flipped. With the introduction and maturity of the Play framework, it's easier to launch a new independent service than it is to try a wedge functionality into an existing one.
 
In this talk, the audience will witness the building of a new service, complete with JSON endpoints, caching, actors and asynchronous calls to a third-party web service in under an hour.
Functional Data Validation (or How to Think Functionally)
Dave Gurnell
Underscore
Close
Functional Data Validation (or How to Think Functionally)
Dave Gurnell
Underscore
Dave is a Scala consultant and developer working for Underscore in London, UK. He has been a Scala developer since 2010 and a functional programmer for nearly a decade, and has spoken at numerous conferences including ScalaDays, Scala Exchange, Scala Lift-Off, and ICFP.
Wednesday (10th Jun.) 15:40
Sooner or later, all developers have to deal with data validation: reading input from the user, checking it, and reporting errors back to the UI. For such a ubiquitous task, validation is surprisingly subtle and complex. Fortunately it also serves as an excellent demonstration of using a functional approach to library design.
 
In this talk, aimed at beginner-to-intermediate Scala developers, Dave will build a simple, powerful, composable data validation library from the ground up, explaining at each stage the design choices made and the benefits gained from the Scala programming language.
 
The talk will cover such topics as:
 
How do we model errors and warnings?
How do we bind validation to our data and the user interface?
How do we make validation modular and composable?
How do we deal with cross-cutting concerns such as async and dependency injection.
16:25 Break
TRACK
Enterprise (Big Data, Reactive, Security, etc.) Wednesday
Cool Stuff, IoT Wednesday
Tools web, best practices Wednesday
Core Scala (Functional Programming, Academic) Wednesday
16:50
Don't Block Yourself
Flavio Brasil
SoundCloud
Close
Don't Block Yourself
Flavio Brasil
SoundCloud
Flavio W. Brasil is a backend engineer at SoundCloud whose daily work involves scaling systems to support the growth of the world's leading audio platform. He is an experienced developer that has specialized in Scala development and performance analysis on the JVM over the four last years. He has experience with a wide range of technologies, from the PalmOS's network stack in C to billing systems using Smalltalk, contributing to several open source projects and creating how own, including the Activate Persistence Framework, a high-peformance persistence solution, and Clump, a free monad that addresses the problem of knitting together data from multiple sources in an elegant and efficient way.
Wednesday (10th Jun.) 16:50
Finagle is a fault tolerant, protocol-agnostic RPC system created by Twitter. It is widely used to power the SoundCloud's microservices architecture. This talk is an overview about the library and how non-blocking IO helps you to build scalable applications.
Scala Puzzlers: "In the Matrix, anything is possible!"
Andrew Phillips
Scala Puzzlers
Nermin Serifovic
Close
Scala Puzzlers: "In the Matrix, anything is possible!"
Andrew Phillips
Scala Puzzlers
A long-standing open-source developer and community member specializing in concurrency and high-performance applications, Andrew builds tools for Continous Delivery and Devops at XebiaLabs, contributes to a number of open-source projects and co-maintains the Scala Puzzlers website.
Nermin Serifovic
Wednesday (10th Jun.) 16:50
The Scala roadmap may have declared war on puzzlers, but there's still plenty of head-scratching moments to be had for now. As previously, we will present a new set of seemingly innocent examples of Scala code that behave in highly surprising ways, give you a chance to guess the result, and explain what actually happens.
 
We will also look at common patterns underlying many puzzlers, and outline some approaches to avoiding these pitfalls. Laugh, learn and take a few steps on the fun path to deeper Scala understanding!
A next generation tool for Scala code review
Alexander Podkhalyuzin
JetBrains
Close
A next generation tool for Scala code review
Alexander Podkhalyuzin
JetBrains

Alexander graduated from Saint-Petersburg State University in 2010, department of mathematics, he has a lot of prizes from international and regional mathematical competitions. In 2008, Alexander started to work for JetBrains, where he became Scala plugin for IntelliJ IDEA team leader. From 2012 he started teaching Scala in Saint-Petersburg Academic University.

Wednesday (10th Jun.) 16:50
One of the projects JetBrains is working on is Upsource, an online code review tool based on IntelliJ Platform. This tool supports many languages, including Scala. Since the product is based on IntelliJ Platform, it inherits all of its coding assistance features, including advanced navigation which is really important when you try to make sense of code. In my talk I’ll walk you through the most awesome feature of Upsource to show how it may help you as you review Scala code. In addition to demonstrating code review features, we’ll also try Upsource as an full-featured IDE to edit our code from a browser. As a bonus, you’ll get the latest update on Scala support in IntelliJ IDEA: what we’re working on and what awesome new features are coming soon, including better macros support, a debugger and so on.
Functional programming with arrows
Yuriy Polyulya
Workday Ltd
Close
Functional programming with arrows
Yuriy Polyulya
Workday Ltd
Yuriy Polyulya bring over 10 years of experience in various technology fields: software development, software architecture, high performance computation and algorithmic research. Over the past four years he has focused on delivery of functional programming principles and practices to real-world projects. And in the last four years Scala has become his language of choice when coming to develop new projects.
Wednesday (10th Jun.) 16:50
If you're using a structure that's very like a monad, but isn't one, maybe it's an arrow. Arrows a general interface to computation, so widely popular in Haskell but they are undeservedly forgotten in FP technics in Scala.   Short talk and study case about: functions and syntax extension for them; arrow type-class; what is arrows and how to use them; arrows and categories; arrows and monads.
17:35 Break
18:00
Closing Panel and Thank You
Close
Closing Panel and Thank You
Wednesday (10th Jun.) 18:00

Venue

Beurs van Berlage

Damrak 243

1012 ZJ, Amsterdam

Website Map

Hotel

NH Amsterdam Grand Hotel Krasnapolsky and NH Amsterdam Barbizon Palace

Website Map

Training

Want to get the most out of Scala Days Amsterdam. Register for an in-person training course prior to the Scala Days conference on Saturday June 6 & Sunday June 7 . The courses are designed for developers of all levels of proficiency with the Typesafe Reactive Platform.


All trainings will take place at:
ING
Bijlmerplein 888
1102 MG Amsterdam

Fast Track to Scala

Saturday June 6 & Sunday June 7

This two-day course is designed to give experienced developers proficient in Java, C++, C# or Ruby the know-how to confidently start programming in Scala. The course ensures you will have a solid understanding of the fundamentals of the language, the tooling and the development process as well as a good appreciation of the more advanced features. If you already have Scala programming experience, then this course could be a useful refresher, yet no previous knowledge of Scala is assumed.


Instructor: Jean Helou
Jean has been a professional developer for over ten years. He currently works as a freelance Scala developer in Lyon where he is involved in multiple Scala, Play! and Akka projects. Jean is a passionate programmer who loves sharing, about Scala but also application design, code quality and all software engineering topics. In the spirit of sharing his passion, he created and co-organizes the Lyon Scala User Group, helps organize a yearly Scala community conference in Paris and regularly facilitates workshops around Scala and/or software engineering either at user groups or at conferences.


Prerequisites: Students should bring their own laptop with Java 6 or higher installed. 

Advanced Scala

Saturday June 6 & Sunday June 7

If you already have programming experience with Scala and want to understand its advanced features, this two-day course is for you. It is designed to help developers fully understand topics such as advanced object-functional programming, the power of Scala's type system, implicits, etc. The course also covers how to leverage these features to create well-designed libraries or DSL's utilizing proven best practices.


Instructor: Jerzy Müller
Jerzy is a functional programming passionate, currently evangelist of Scala. He also likes to dwell into software engineering topics like code quality, peer review or architecture design. At his day job in VirtusLab he is involved in multiple Scala projects using Akka, Play! and Scala IDE. After hours he is co-organizer of Kraków Scala User Groups, attends several other meetup groups, dances and reads a lot of books.


Co-instructor: Heiko Seeberger
Heiko Seeberger has been a Scala enthusiast ever since he came to know this fascinating language in 2008. Deeply interested in distributed computing he became a contributor to the amazing Akka project in 2010. Heiko has more than 15 years of professional expertise in consulting and software development on the Java platform and regularly shares his expertise in articles and talks. He is also the author of the German Scala book "Durchstarten mit Scala". Heiko tweets as @hseeberger and blogs under heikoseeberger.de.


Prerequisites: A basic knowledge of Scala as covered in the "Fast Track to Scala" course with at least two months practical experience in developing with Scala. Students should bring their own laptop with Java 6 or higher installed. 

Fast Track To Akka With Scala

Saturday June 6 & Sunday June 7

This two-day course introduces experienced application developers to the reactive Akka toolkit and runtime and the methodologies that enable the creation of real-world actor-based systems in Scala on a single JVM. This course has extensive hands-on work and successive exercises build upon prior lessons learned to produce a fully functional application that is both event-driven and resilient by the conclusion of the course.


Instructor: Eric Loots
After signing up for and completing the first instantiation of the ‘Functional Programming with Scala’ course, Eric instantly fell in love with Scala. With over 30 years experience in IT, Eric is once again enjoying the pleasure of putting great technologies such as Scala and Akka to practical use while solving real customer business problems.


Prerequisites: Code examples and exercises will be written in Scala, so a basic knowledge of Scala as covered in the "Fast Track to Scala" course is required. Students should bring their own laptop with Java 6 or higher installed.

Advanced Akka With Scala - Sold out

Saturday June 6 & Sunday June 7

This is a two-day advanced course on building distributed reactive applications using Akka and Scala. It is intended for developers who already have a strong understanding of the fundamentals of building applications using Akka and Scala on a single JVM and are looking to learn how to scale out to multiple nodes and 3rd party systems. This course has extensive hands-on work and successive exercises build upon prior lessons learned to produce a fully functional application that is both event-driven and resilient by the conclusion of the course.


Instructor:Brendan McAdams
Brendan is a Senior Consultant at BoldRadius, where he works directly with clients to help them find success through consulting and training on the Typesafe Reactive Platform. With over 15 years of software development experience, Brendan boasts an impressive resume that has seen him work at Netflix, Typesafe, and MongoDB. Brendan is a renowned speaker and luminary in the Scala community, and is a regular presenter at industry leading conferences such as ScalaDays and Scala eXchange. His deep technical knowledge coupled with his outgoing and approachable personality not only make him a great speaker, but also a phenomenal trainer on the Typesafe Reactive Platform.

Instructor: Michael Nash
For over thirty years, Michael has designed, developed, shipped and consulted on software development projects for clients of all shapes and sizes. As an advocate for software craftsmanship with expertise in project management and architecture, Michael was amongst the earliest of adopters of the Typesafe Stack, with over 5 years experience working with Scala, Akka and Spray. Michael brings his wealth of knowledge, experience and unrelenting passion for software development to his training courses, as he loves to help others learn new technologies. 


Prerequisites: A basic knowledge of Akka as covered in the "Fast Track with Akka and Scala" course as well as a basic knowledge of Scala as covered in the "Fast Track to Scala" course with at least two months practical experience in developing with Akka and Scala. Students should bring their own laptop with Java 6 or higher installed.

Fast Track To Play With Scala 

Saturday June 6 & Sunday June 7  

This two-day course introduces experienced web-developers to the design-patterns and methodology essential to building reactive, scalable web applications with Play Framework and Scala. In this course, successive exercises build upon prior lessons learned to produce a fully functional application by the conclusion of the course.


Instructor: Peter Hilton
Peter Hilton is a software developer, writer, speaker, trainer, and musician. Peter’s professional interests are web application development, functional design, agile software development and project management. He has extensive experience on projects for large customers in the logistics, government, financial services, energy, utilities, pharmaceutical, transport and space industries. Peter’s software development interests include JVM web application frameworks, software development methodology and practices, and web-based collaboration. Peter’s speciality is database-backed intranet web application architecture, design and build. He currently builds web applications using Scala, Play Framework and Slick. Previously, Peter gained significant experience with Java EE web technology and middleware, such as Drools.


Prerequisites: Code examples and exercises will be written in Scala, so a basic knowledge of Scala as covered in the "Fast Track to Scala" course is required, as is experience with HTML and JavaScript. Students should bring their own laptop with Java 6 or higher installed.

Apache Spark: An Introduction Workshop for Developers - Sold out

Sunday June 7

This one-day workshop is designed to teach developers how to implement data analytics using for Reactive applications. Apache Spark is a distributed computing system written in Scala and developed initially as a UC Berkeley research project for distributed data programming. It has grown in capabilities and it recently became a top-level Apache project. 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.


Instructor: Andy Petrella
Andy is a mathematician turned into a distributed computing engineer with an entrepreneurship trait. Andy is a certified Scala/Spark trainer and wrote the Learning Play! Framework 2 book. He participated in many projects, building on top of spark, cassandra, and other distributed technologies, in various fields including Geospatial, IoT, Automotive and Smart cities projects. He is the creator of one of the top projects on GitHub related to Apache Spark and Scala, the spark-notebook (https://github.com/andypetrella/spark-notebook/). He enjoyed his contribution to the processing and data science teams of the notable and successful start-up Virdata. He now develops genomics and heath data services, Med@Scale, within the Data Fellas company he co-founded with Xavier Tordoir.


Co-instructor: Paco Nathan
Paco Nathan is a "player/coach" data scientist, with expertise in distributed systems, machine learning, functional programming, cloud computing, and 30+ years technology industry experience ranging from Bell Labs to early-stage start-ups. He is an O'Reilly author, and an advisor for Amplify Partners and GalvanizeU. Cited in 2015 as one of the Top 30 People in Big Data and Analytics by Innovation Enterprise.

Tickets

Scala Days Amsterdam 2015 conference tickets are now SOLD OUT. But don't panic - we still have a few seat left for trainings!


Sign up for our and get contacted if we get a spare conference seat.


VAT Regulations & Refund Policy

Ticket prices listed below are exclusive of VAT. Dutch companies paying for the conference and training registrations will not be charged VAT. For everyone else tickets are subject to 21% VAT. Scala Days Conference and Training registrations are non-refundable.  

   

Conference (2.5 days)- sold out

Before March 23 Before April 20 After April 20
€650 €700 €800

Conference Academic rate(2.5 days)- sold out

Before March 23 Before April 20 After April 20
€400  €400 €400

Conference + 2 training days(4.5 days)- sold out

Before March 23 Before April 20 After April 20
€1550 €1800 €1900

Conference + Spark Training - 1 training day (3.5 days) - sold out

Before March 23 Before April 20 After April 20
€1100 €1250 €1350

Spark Training, 1 training day only -sold out

Before March 23 Before April 20 After April 20
€450 €550  €550

2 Training days only

Before March 23 Before April 20 After April 20
€900 €1100 €1100
Purchase Training Tickets

Wait List

Sponsors

 

Platinum

Gold

  

Silver

 

 

Hosted by

 

Interested in being a sponsor at Scala Days Amsterdam? Contact us at info@scaladays.org.

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 a jerk, 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

We already have the crew we need for Scala Days Amsterdam!

If you want to be on the waiting list please contact Dajana Günther  

Volunteer as a Crew Volunteer and receive a FREE pass to Scala Days 2015.  

All crew volunteers will be required to work on Monday June 8th from 12:00 PM - 5:00 PM as well as another shift on Tuesday June 9th or Wednesday June 10th (in total about 15 hours). In return for helping with the conference, crew volunteers will have free access to the conference and all social events. Register to be crew by entering "crew" in the promotion code field on the registration form.