Scala Days

April 18th-21st, 2017 Chicago

Keynotes


App

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



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

About

Scala Days Chicago

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

 

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

 

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

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

Wednesday (19th Apr.)
16:00 Registration
ROOM
17:00
Keynote - What to Leave Implicit
Martin Odersky
Scala Creator & Co-Founder of Lightbend
Close
Keynote - What to Leave Implicit
Martin Odersky
Scala Creator & Co-Founder of Lightbend

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

Twitter: @odersky

Wednesday (19th Apr.) 17:00
To understand a piece of program text one must also understand the con-text in which the program is to be executed. Modern programming languages offer an array of constructs to define context. In Scala, those constructs can be summed up as the three I's: Imports, Inheritance, and Implicits. Implicits in particular are a central, but also controversial part of the language.

This talk explores the different facets of implicits in Scala, as they exist now and as they might evolve in the future. It highlights their potential benefits and problems, covering aspects of design, implementation, and ergonomics.
18:00
Welcome Reception
Close
Welcome Reception
Wednesday (19th Apr.) 18:00
Thursday (20th Apr.)
08:00 Registration
09:00
Rust: confident, productive systems programming
Aaron Turon
Research Engineering Manager @ Mozilla
Close
Rust: confident, productive systems programming
Aaron Turon
Research Engineering Manager @ Mozilla
Aaron Turon is Research Engineering Manager for the Rust team at Mozilla. He received his PhD from Northeastern University, where he studied programming language design, program verification, and low-level concurrency. His dissertation was awarded the SIGPLAN John C. Reynolds Doctoral Dissertation Award in 2014. After his PhD studies, he continued his research in concurrency verification and programming techniques as a postdoc at MPI-SWS. He joined Mozilla in 2014, and has played an active role in Rust's development since then.
Thursday (20th Apr.) 09:00
Rust is a language with a new vision of systems programming. It gives you low-level control and predictability but also provides the safety and ergonomics of languages like Scala. The secret sauce is Rust's core notion of "ownership", which enables:

- Memory safety without garbage collection.
- Concurrency without data races.
- Abstraction without overhead.

In this talk, I'll explain ownership and show how Rust uses it to guarantee thread safety, amongst other things. I'll say a bit about integrating Rust code with other languages. And I'll also cover some of the lessons the Rust community has learned in how to do open, consensus-driven language evolution, so that we also achieve:

- Stability without stagnation.
10:00 Break
ROOM Zurich ABC Zurich D Zurich E Zurich FG
TRACK
Track 1 - Beginner Thursday
Track 2 - Intermediate Thursday
Track 3 - Intermediate Thursday
Track 4 - Intermediate Thursday
10:25
Functional Programming Essentials
Kelley Robinson
Team Lead, Software Engineer @Sharethrough
Close
Functional Programming Essentials
Kelley Robinson
Team Lead, Software Engineer @Sharethrough
Kelley has been programming in Scala since 2013, most recently managing a team of Scala developers and Data Scientists at Sharethrough in San Francisco. She is the founder of ScalaBridge, the initiative to build a more inclusive Scala community with introductory programming workshops for women. In her spare time, she enjoys testing new recipes and trying to keep her plants alive.
Thursday (20th Apr.) 10:25
Scala is often touted as a tool for Functional Programming, but Functional Programming (FP) itself is left to differing and opinionated definitions by many of its practitioners. FP is a well defined approach to writing programs that we will uncover in this talk. It is a style that long predates Scala and many of the modern abstractions that are often referred to as "essential" tools.

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

Finally we'll talk about practical approaches to Functional Programming in Scala, how you can and why you would use this style in your everyday work. This will _not_ be a talk about monads and type systems, but give you a pragmatic look at how to separate the syntactic sugar from the underlying principles.
Macros versus Shapeless versus Code Generation: What Works, When, and How Much?
Adam Rosien
Associate @Underscore
Close
Macros versus Shapeless versus Code Generation: What Works, When, and How Much?
Adam Rosien
Associate @Underscore
Recently moving from southern California to Seattle, Washington, Adam Rosien is an Associate at Underscore ("The Scala Specialists"), focused on building systems using functional programming. He previously helped various startups in many domains develop back-end systems and implement continuous deployment practices, and also spent five years as a developer at Xerox PARC.
Thursday (20th Apr.) 10:25
In this talk we will compare three techniques for meta-programming in Scala: macros, shapeless, and code generation. Through a sequence of simple examples we will attempt to characterise the relative pros and cons of each technique, where they are most appropriate, and where they might turn around and bite you.

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

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

The talk is aimed at intermediate Scala developers who have a basic awareness of each technique. You don't need to know shapeless or macro programming to benefit.
Visualize your data structures!
Nick Stanchenko
Software Engineer @Feedzai
Close
Visualize your data structures!
Nick Stanchenko
Software Engineer @Feedzai
Nick is a Lisbon-based Scala enthusiast with background in computer science and human-computer interaction. Previously known in the Scala community as the creator of Macroid, a composable UI DSL for Android, Nick is currently fighting fraud with machine learning at Feedzai. His interests include functional programming, usability and data visualization.
Thursday (20th Apr.) 10:25
Reftree is a Scala library for producing pretty diagrams and animations of data structures (http://stanch.github.io/reftree/demo). It can be used for documentation, live coding or as an interactive tool for understanding how stuff works.

This talk showcases Reftree and explores how functional programming techniques such as lenses and zippers can be used to implement visualizations of themselves.
Building Safe(r), More Testable Scala Production Systems at x.ai
Varun Vijayaraghavan
Andrew Phillips
Engineer @x.ai
Close
Building Safe(r), More Testable Scala Production Systems at x.ai
Varun Vijayaraghavan
Engineer @x.ai
Varun is a battle-hardened backend engineer who previously built real-time analytics systems with Python and Java. He's using Scala for the first time as a mission-critical technology to build an AI assistant that magically schedules meetings.
Andrew Phillips
Engineer @x.ai
A long-standing open-source developer and community member specializing in concurrency and high-performance applications, Andrew is currently helping build the platform for an AI assistant that magically schedules meetings.

He contributes to a number of open-source projects, co-maintains the Scala Puzzlers website and is the co-author of the "Scala Puzzlers" book. He also helps coordinate the DynamicInfraDays series of community (un)conferences.
Thursday (20th Apr.) 10:25
Scala is a very powerful language, with lots of features supporting many different development paradigms. But there’s still quite a way from there to running, real-world production applications that are easy to test and safe to work on for many developers, especially ones that may be new to Scala.

Varun and Andrew will talk about x.ai’s experience of using Scala to build an advanced production system that magically schedules meetings. Specifically, they’ll focus on some of the key coding and architecture lessons that their team learned on the way to safely building a testable application.

Andrew and Varun will introduce a number of important coding and testing patterns, and libraries that the team adopted (and open-sourced ;-)). They’ll also describe the team’s transition to a functional “I/O <-> pure” architecture, discuss how and why this approach has improved application testability at multiple levels, and share tips on how you can evolve your applications’ architecture in a similar way.
11:10 Break
11:35
Easy Static Checking for Embedded DSLs in Scala with Contextual
Jon Pretty
Scala Developer @Propensive Ltd
Close
Easy Static Checking for Embedded DSLs in Scala with Contextual
Jon Pretty
Scala Developer @Propensive Ltd
Jon has been involved in the Scala community for over a decade, having launched the first commercial and open-source Scala software back in 2005.

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

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

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

This opens up a smorgasbord of possibilities for adding more compile-time safety to Scala code, not least the ability to introduce your own literal-like types, ranging from checked email addresses or URLs to compile-time-checked YAML, CSS or Haskell!
Extending Spark Machine Learning - Beyond Linear Regression
Holden Karau
Principal Software Engineer @IBM
Close
Extending Spark Machine Learning - Beyond Linear Regression
Holden Karau
Principal Software Engineer @IBM
Holden Karau is transgender Canadian, and an active open source contributor. When not in San Francisco working as a software development engineer at IBM's Spark Technology Center, Holden talks internationally on Spark (see some selected videos at http://bit.ly/holdenSparkVideos ) and holds office hours at coffee shops at home and abroad. Holden is a co-author of numerous books on Spark including High Performance Spark (which she believes is the gift of the season for those with expense accounts) & Learning Spark. She makes frequent contributions to Spark, specializing in PySpark and Machine Learning. Prior to IBM she worked on a variety of distributed, search, and classification problems at Alpine, Databricks, Google, Foursquare, and Amazon. She graduated from the University of Waterloo with a Bachelor of Mathematics in Computer Science. Outside of software she enjoys playing with fire, welding, scooters, poutine, and dancing.
Thursday (20th Apr.) 11:35
Apache Spark is one of the most popular Big Data tools. This talk introduces & takes a deep dive on Spark's scikit-learn inspired Machine Learning pipelines.

Spark's ML pipelines provide a lot of power, but sometimes the tools you need for your specific problem aren't available yet. By integrating your own data preparation and machine learning tools into Spark's ML pipelines you will be able to take advantage of useful meta-algorithms, like parameter searching.

Even if you don't have your own machine learning algorithms you want to implement, this talk peels back the covers on how the ML APIs are built and can help you make even more awesome ML pipelines and customize Spark models for your needs.

A basic understanding of Spark will make it easier to follow along, but if this is your first Spark talk, this will still be useful and give you a broad understanding of how Spark ML functions (of course since the presenter is an author, if this is your first introduction to Spark she encourages you to buy her book "Learning Spark" & "High Performance Spark").
Flare: Scale Up Spark with Native Compilation and Set Your Data on Fire!
Tiark Rompf
Assistant Professor @Purdue University
Close
Flare: Scale Up Spark with Native Compilation and Set Your Data on Fire!
Tiark Rompf
Assistant Professor @Purdue University
Tiark was a member of the EPFL Scala team from 2008-2014, before becoming a faculty member at Purdue University. He is a regular speaker at academic and industrial conferences, including past ScalaDays, Strangeloop, and SparkSummit.
Thursday (20th Apr.) 11:35
Spark is emerging as the leading Big Data platform, and its performance has made impressive progress. But there is still a significant gap towards best-of-breed query engines or hand-written low-level C code on modern server-class hardware. We present Flare, a new back-end for Spark that yields significant speedups by compiling Spark's Catalyst query plans to native code. Flare's low-level implementation takes full advantage of native execution, using techniques such as NUMA-aware scheduling and data layouts to leverage ‘mechanical sympathy’ and bring execution closer to the metal than current JVM-based techniques on big memory machines. Thus, with available memory increasingly in the TB range, Flare makes scale-up on server-class hardware an interesting alternative to scaling out across a cluster, especially in terms of data center costs. This talk will discuss the design of Flare and will demonstrate experiments on standard benchmarks that exhibit order of magnitude speedups over Spark 2.1.
Akka Streams for High Throughput Data Processing
Zack Loebel-Begelman
Senior Software Engineer @Credit Karma
Close
Akka Streams for High Throughput Data Processing
Zack Loebel-Begelman
Senior Software Engineer @Credit Karma
As a senior software engineer on the data and analytics pipeline, Zack’s work allows Credit Karma to provide tailored recommendations for each individual member’s specific financial situation. Zack joined Credit Karma after designing and launching data engines to support backend consumer services. He has a bachelor’s degree in computer science from the University of California, Davis.
Thursday (20th Apr.) 11:35
With over 60 million members, Credit Karma is one of the most trusted personal finance tools in the U.S. This scale of information demands a data transfer process designed to handle high throughput. We built an initial Akka Actor implementation but didn’t ask ourselves the key question: What happens when you have actors with vastly different performance characteristics?

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

If you and or your company have or are building Akka Actor Systems, designed for high throughput this talk may be for you. We will provide guidance on best practices and whether optimizations can improve throughput or whether switching to Akka Streams may be necessary.
12:20 Lunch
13:20
Herding types with Scala macros
Marina Sigaeva
Software Engineer @Tinkoff
Close
Herding types with Scala macros
Marina Sigaeva
Software Engineer @Tinkoff
I graduated Faculty of Physics Lomonosov Moscow State University. Now I'm a software engineer in Tinkoff at BigData department. Scala is my first working language
Thursday (20th Apr.) 13:20
In Scala we use the term "type safety", but what it really means? In short, most applications model data types in a form suitable for storage, change, transmission, and use. During the life cycle of the data, we expect to always use the declared type. But reality is a bit more complicated. One of the main practical problems with the use of types occurs when our application interacts with outside world - in requests to external services, different databases or simply with getting data from file. In most cases, an attempt to support type safety leads to writing a lot of code that we always try to avoid. Fortunately we have macros to do all routine job for us! In this talk we will discuss how to use compile-time reflection in library for schemaless key-value database and the benefits of use of macros in production systems.
Dotty is coming: how to prepare for migration
Dmitry Petrashko
Doctoral Assistant @EPFL
Close
Dotty is coming: how to prepare for migration
Dmitry Petrashko
Doctoral Assistant @EPFL
Dmitry has been working on Scala since 2013, when he joined Martin Odersky's research lab at EPFL, working on ScalaBlitz, macro-generated collections for Scala. Since 2015 he has been working on the Dotty Compiler. He designed Mini-Phases, ported the JVM backend, implemented support for Java 8 lambdas and default methods, along with various other parts of the compiler, including the pattern matcher, lazy vals, tail recursion transformations and parts of erasure and mixin composition.
Thursday (20th Apr.) 13:20
A new Scala is coming, which will introduce new language and library features as well as deprecate some of the old ones. This talk will give advice on how to prepare your codebases to reduce effort needed to migrate, including:

– usage of what language features should you try to minimize;
– what classes in the standard library should you stay away from;
– what tools will be there to help you, and
– how you can start migration early to amortize the effort over time.
sbt: Beyond the Build Tool
Jeff Olchovy
Software Engineer @Tapad
Close
sbt: Beyond the Build Tool
Jeff Olchovy
Software Engineer @Tapad
Jeff Olchovy is a Staff Software Engineer at Tapad where he leads the company's Platform Practice, which is the cross-functional engineering group responsible for laying the foundation for Tapad's systems. With over nine years of development experience and having played a critical role in building Tapad's engineering team, Jeff was also recently appointed to help spearhead Tapad's engineering efforts at the company's new Oslo office.
Thursday (20th Apr.) 13:20
Anyone familiar with Scala knows both the benefits and annoyances of using sbt. On the one hand, the tool is essential for features such as automatic dependency management, continuous compilation, testing, and deployment, etc. However, it’s often that we find hours are wasted on trying to fight sbt and the way it dictates our build processes. In this session, Jeff will show fellow Scala developers how to regain their productivity by both embracing sbt instead of fighting it as well as finding new ways to use sbt beyond just a build tool. Past users of Maven, Ant, and Gradle may not feel comfortable configuring and customizing their sbt build definition -- much to their own detriment -- but the potential to do so is definitely there. Accompanied by specific and compelling case studies, Jeff will challenge the audience to re-think the ways they have been using sbt all along and walk away with specific best practices to improve their overall productivity with the tool.
Long-lived microservices
Jan Machacek
CTO @Cake Solutions
Close
Long-lived microservices
Jan Machacek
CTO @Cake Solutions
I help companies achieve exceptional growth and success through use of modern computing technologies; specifically large-scale machine learning and big data systems, particularly those that interact with IoT, wearables, mobiles as well as modern web applications. My experience and expertise allows me to advise on future technical strategies.

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

Come to Jan's talk if you are about to start a large-scale microservices system and wonder what potential challenges await you: learn how to make the most of the Lightbend stack ecosystem of tools and frameworks, together with the necessary infrastructure to keep the system running. The examples Jan will show, together with the code on his GitHub repository, will give you the needed boost—years of consultancy experience—to your microservices project.
14:05 Break
14:30
Effective Scala development in IntelliJ Idea
Mikhail Mutcianko
Jetbrains
Close
Effective Scala development in IntelliJ Idea
Mikhail Mutcianko
Jetbrains
Thursday (20th Apr.) 14:30
Helping a developer to stop wasting energy on routine tasks and focusing on the most important concepts is what defines an IDE - IntelliJ Idea is constantly improving its support for writing code more productively and quickly.

In this talk I'll aim to introduce people unfamiliar with the IntelliJ Platform to Scala plugin coding assistance features and broaden the knowledge of those who consider themselves already to be experienced IDEA users.
And for the most involved it will also contain a sneak peek into the future of cross-platform metaprogramming support in IntelliJ Idea using the scala.meta API.
Scala Meta Live Coding Session
Pathikrit Bhowmick
Principal Engineer @Coatue
Close
Scala Meta Live Coding Session
Pathikrit Bhowmick
Principal Engineer @Coatue
Pathikrit is a Principal at Coatue Management where he enjoys using Scala to solve complex problems in finance. He is also the author and maintainer of many popularly used open source Scala libraries like better-files and scalgos. Pathikrit's interests include functional programming, databases and algorithms.
Thursday (20th Apr.) 14:30
In this talk, we will have an interactive live coding session where we will use Scala Meta to code something useful (a code generator for your REST API). Hopefully this will embolden other Scala users to explore macros for profit and fun without fear.
Numbers every Scala programmer should know
Hunter Payne
Staff Software Engineer @Credit Karma
Close
Numbers every Scala programmer should know
Hunter Payne
Staff Software Engineer @Credit Karma
Hunter is a staff software engineer focused on data engineering and AI at Credit Karma. He specializes in natural language processing systems, systems engineering and distributed systems. Before joining Credit Karma, Hunter developed knowledge management frameworks, JDBC drivers and network stacks. He also developed the download site for Java and the Oracle product suite. Hunter graduated cum laude with a bachelor’s degree in computer science from Carnegie Mellon University.
Thursday (20th Apr.) 14:30
Writing highly performant code has always been a challenge for programmers. Techniques change and evolve in response to shifts in underlying hardware. For example, before the early '90s it was faster to XOR a register with itself than to set a register to 0. This is no longer the case. Instead, creating fast code is mostly about improving L2 and L3 cache hit rates, aligning data in memory and allowing hardware attached to the I/O bus to move data to main memory concurrently with the CPU. Now, with the advent of Scala, use of immutable data has been touted as the best practice for how to write concurrent code. In this talk, we'll discuss why using immutability may not always be the right choice. We'll also cover when to follow easier models reliant on immutability, the best times to brave the difficulties of synchronization and locks, and when blocking is the right thing to do, even inside of an actor.
Monix Task: Lazy, Async and Awesome
Alexandru Nedelcu
Lead Software Developer @Eloquentix
Close
Monix Task: Lazy, Async and Awesome
Alexandru Nedelcu
Lead Software Developer @Eloquentix
Alexandru is a software developer living in Bucharest, Romania, currently working for Eloquentix. A startup guy, by day he's been helping with projects for powering the next generation energy grid solutions and for advancing the health-care industry. By night he's fueled by his work on the Monix project, the Scala library for composing asynchronous and event-based programs. He's also a proud father, husband, has a very unhealthy sleep schedule and appreciates talking about programming over beer. Sometimes he blogs at https://alexn.org
Thursday (20th Apr.) 14:30
Scala's Future from the standard library is great, but sometimes we need more. A Future strives to be a value, one detached from time and for this reason its capabilities are restricted and for some use-cases its behavior ends up being unintuitive. Threfore, while the Future/Promise pattern is great for representing asynchronous results of processes that may or may not be started yet, it cannot be used as a specification for an asynchronous computation.

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

In this talk I'll show you its design, when you should use it and why in dealing with asynchronicity it's better to work with Task instead of blocking threads.
15:15 Break
15:40
Scala 2.12 and the road towards 3.0
Adriaan Moors
Scala Team Lead @Lightbend
Close
Scala 2.12 and the road towards 3.0
Adriaan Moors
Scala Team Lead @Lightbend
Adriaan leads the Scala team at Lightbend. Our mission is to make Scala the most practical and productive language you've ever worked with, by providing a flexible set of simple constructs to help you build scalable and maintainable solutions for complex problems (and have fun while doing so).

Adriaan's been working on the Scala compiler for ten years, with his first contribution being support for type constructor polymorphism. More recently, he worked on support for Java 8's retro-fit of functions (single abstract method types) and internal compiler cleanups to take advantage of simplifications in our encoding enabled by Java 8's support for default methods in interfaces.
Thursday (20th Apr.) 15:40
We'll take a close look at Scala 2.12's features as well as what lies ahead in the next few years for the Scala 2.x series. I'll also take a step back and muse about what the essence of Scala is to me, why I still love working on the compiler 10 years later, and why I believe it's the best choice for statically typed functional programming on the JVM (and JS, and maybe native? :-)).
Anatomy of a full-stack Scala/Scala.js Web App
Haoyi Li
Close
Anatomy of a full-stack Scala/Scala.js Web App
Haoyi Li
Thursday (20th Apr.) 15:40
This talk will explore the inner workings of a real-world, moderately-sized "Isomorphic" Scala/Scala.js web app: running Scala on the server and Scala.js in the browser.

In this talk, you will see how the Scala.js developer experience changes as an application grows, how a non-trivial Scala/Scala.js application can be structured, and how the "Isomorphic" property of the Scala/Scala.js stack affects how you write code in reality. By the end you should have seen enough to form an impression of how a real-world Scala/Scala.js application ends up looking in-the-wild, compared to what a more traditional Javascript-based web app may look like.
Fault-tolerance in Distributed Systems: A Case Study in Apache Spark
Imran Rashid
Software Developer @Cloudera
Close
Fault-tolerance in Distributed Systems: A Case Study in Apache Spark
Imran Rashid
Software Developer @Cloudera
Imran Rashid is a Committer and PMC member of Apache Spark, and a developer at Cloudera. He has used Hadoop for the past 8 years, and been closely involved in Spark even before it was an Apache project. Imran used to write Spark programs for machine learning on terabytes of data -- now he spends his time hunting down bugs that surface when Spark is pushed to 1000s of nodes.
Thursday (20th Apr.) 15:40
Apache Spark is a distributed computing platform built using Scala with fault-tolerance in mind. It has been tested rigorously and deployed in production at many companies for years. And yet, fault-tolerance issues are still surfaced. How did these faults slip through?

The purpose of this talk is not to examine Spark in detail, but rather to see what lessons can be learned for building your own systems, and what you should know as a user of one. We'll explore what a platform can reasonably guarantee, and what types of questions a user should be asking to understand their system. We'll see how Scala and FP principles are used in Spark; and also why Spark abandons some concepts, like immutability. All of these topics will be explored by looking at cases in Spark -- both how the code was designed initially, and issues that were discovered later and fixed.
Practical Eff monad for micro-services
Eric Torreborre
Software engineer @Zalando
Close
Practical Eff monad for micro-services
Eric Torreborre
Software engineer @Zalando
I am a developer coding micro-services in Scala at Zalando, where we ship fashion all across Europe.

I created the specs2 testing library (http://specs2.org) and more recently the eff library, a very cool alternative to monad transformers (https://atnos-org.github.io/eff).
Thursday (20th Apr.) 15:40
"These crazy FP concepts are very interesting but how do I apply them to my job at XYZ?" Indeed, it is one thing to learn what a "catamorphism" or a "natural transformation" is, and another one to use it in our daily programming.

In this talk you will learn how to decompose a REST microservice into several components: authentication, request to other services and database access. Then we will use the Eff monad to precisely define the interface of these components and support additional concerns like logging or asynchronous execution.

Once you get the basic idea, the possibilities are endless! Rate limiting is just another component and another set of effects involving time and state. And testing is so much easier: no execution context or mocks!
16:25 Coffee break sponsored by Two Sigma
16:50
Hands-on Scala-Native
Guillaume Massé
Software Engineer @Scala Center
Close
Hands-on Scala-Native
Guillaume Massé
Software Engineer @Scala Center
Guillaume is a Scala Center and commiter to Scala Native. He worked on the Scala Package Index (Scaladex) and ScalaKata.com
Thursday (20th Apr.) 16:50
Scala Native is a brand new target for the Scala compiler. You can write native code without paying the cost of the C programming language.

In this presentation we will run through various code example to understand how to get going with native: Hello, World!, command line application, OpenGL3 facade.
How I learned to stop worrying and love the frontend
Otto Chrons
Architect @Umbra
Close
How I learned to stop worrying and love the frontend
Otto Chrons
Architect @Umbra
I'm a long time contributor in the Scala.js ecosystem, including popular libraries like Diode and Boopickle.
Thursday (20th Apr.) 16:50
Scala.js brought Scala to web frontend development, relieving developers from many of the idiosyncrasies of JavaScript. As library support for Scala.js keeps maturing, it is becoming a very solid environment for real full-stack web development.

In this talk, you will discover the practices of frontend development in Scala and the benefits it brings. You will also explore the intriguing future of true cross-platform frontend development with Scala.js, Scala for Android and Scala Native for iOS. Scala - the one language to rule them all!
Elegant Scala builds and bootstrapping Dotty with CBT
Jan Christopher Vogt
Senior Backend Engineer @x.ai
Close
Elegant Scala builds and bootstrapping Dotty with CBT
Jan Christopher Vogt
Senior Backend Engineer @x.ai
Chris Vogt is a Senior Software Engineer at x.ai, a former member of Martin's Scala team, co-author of Slick and author of CBT
Thursday (20th Apr.) 16:50
Last year CBT, the new build tool for Scala, showed a simpler way to build Scala programs. But there were still a number of big open questions. Those have since been answered. We'll present elegant and simple solutions to task-scoping, dynamic configuration and multi-project builds. Finally we'll talk about the joined work with Scala Center to use CBT for bootstrapping Dotty and how we did it.
Top Mistakes When Writing Reactive Applications
Petr Zapletal
Lead Consultant @Cake Solutions
Close
Top Mistakes When Writing Reactive Applications
Petr Zapletal
Lead Consultant @Cake Solutions
Petr is a Consultant who specializes in the design and implementation of highly scaleable, reactive and resilient distributed systems. He is a functional programming and open source enthusiast and has expertise in the area of big data and machine classification techniques.

Petr participates in the whole software delivery life-cycle: from requirement analysis & design through to maintaining systems in production. During his career, Petr has worked for various companies, from start-ups to large international corporations.

Technically, Petr is SMACK (Spark, Mesos, Akka, Cassandra, Kafka) evangelist. Petr enjoys working with Akka and has deep knowledge of toolkit’s features like Akka Clustering, Distributed Data or Akka Persistence. Petr is also certified Spark Developer.
Thursday (20th Apr.) 16:50
Reactive applications are becoming a de-facto industry standard and, if employed correctly, toolkits like Lightbend Reactive Platform make the implementation easier than ever. But design of these systems might be challenging as it requires particular mindset shift to tackle problems we might not be used to. In this talk we’re going to discuss the most common things I’ve seen in the field that prevented applications to work as expected. I’d like to talk about typical pitfalls that might cause troubles, about trade-offs that might not be fully understood or important choices that might be overlooked including persistent actors pitfalls, tackling of network partitions, proper implementations of graceful shutdown or distributed transactions, trade-offs of micro-services or actors and more.

This talk should be interesting for anyone who is thinking about, implementing, or have already deployed reactive application. My goal is to provide a comprehensive explanation of common problems to be sure they won’t be repeated by fellow developers. The talk is a little bit more focused on Lightbend platform but understanding of the concepts we are going to talk about should be beneficial for everyone interested in this field.
17:35 Break
18:00
Deus Ex Scala: Finding a Home for Scala in the Corporate Machine
Sten Anderson
Director, Software Engineering @CME Group
Close
Deus Ex Scala: Finding a Home for Scala in the Corporate Machine
Sten Anderson
Director, Software Engineering @CME Group
I have been a JVM enthusiast, and promotor of alternate Java languages for several years. In addition to founding the AJLIG (Alternative JVM Languages Interest Group) at CME.

I am currently the Technical Director for the Pricing team at CME Group.
Thursday (20th Apr.) 18:00
Financial Exchanges are all about enabling near real-time market transactions with minimal latency and maximal predictability. In an environment where performance is king, and "zero garbage" and "lock-free" algorithms are the norm, come hear how one team decided to take a different approach using Scala.

This talk is part technical case study, part project postmortem, and part reflections on building a Scala team from the ground up. We'll talk about how Scala can succeed in a highly regulated, generally risk-averse environment, and why it can be worth that risk and lead to a happier, healthier team.

Still not sure if this talk will be worth your time? You might enjoy this talk if you believe in Life Beyond Java, but the rest of your team thinks that Java 8 Lambdas killed Scala and you are looking for moral support.

On the other hand, this talk may be less relevant for you if you believe that Java 8 Lambdas killed Scala and you’re tired of hearing from that one teammate who keeps trying to convince you otherwise. But if this is the case, why are you at a Scala conference?
The Futures are Calling and I Must Choose
Chris Phelps
Software Engineer @Tendril
Close
The Futures are Calling and I Must Choose
Chris Phelps
Software Engineer @Tendril
have been developing software on the JVM since the early days of the platform. I have used Scala for the last 4 years, including acting as an evangelist and mentor within Tendril, where we use a Scala and Finagle-based microservice architecture to supply Energy Intelligence to our clients. My current interests involve applying Typed Functional Programming techniques to manage both domain and infrastructural complexity in a microservice environment
Thursday (20th Apr.) 18:00
Scala has a Future type in the standard library, but when we use other libraries we have competing abstractions: Scala Futures, Twitter Futures, Java CompletableFutures, Guava ListenableFutures. Other libraries like Scalaz, Monix, and FS2 bring us Task abstractions, which are similar to Futures but lazily executed. How do all these variants relate to one another? When should we use one over another? How do we interoperate when we have to deal with code that uses a different variant?

Starting from the basics of how to use each variant, we'll build up an understanding of how to select the best one for a codebase, how to make them work together, and some of the pitfalls. Along the way we'll even see some other tricks for making these useful abstractions when combined with other effects.
Doodle: Visualisation in Scala
Noel Welsh
Partner @Underscore
Close
Doodle: Visualisation in Scala
Noel Welsh
Partner @Underscore

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

Thursday (20th Apr.) 18:00
In this talk I'll introduce Doodle, a Scala library for data visualisation that renders in the browser, to files, and on the desktop.

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

Doodle is a new 2D visualisation library for Scala. It can render graphs on the desktop, to files (PDF and PNG), and, using Scala.js, to the browser as SVG. In this talk I will briefly describe how to use Doodle for common tasks, and then delve into its architecture. I'll show how standard functional programming techniques allows Doodle to provide powerful functionals at multiple levels of abstraction, yielding a library that is both easy to use and extremely flexible.
Simple code for a type safe world
Jan Christopher Vogt
Senior Backend Engineer @x.ai
Close
Simple code for a type safe world
Jan Christopher Vogt
Senior Backend Engineer @x.ai
Chris Vogt is a Senior Software Engineer at x.ai, a former member of Martin's Scala team, co-author of Slick and author of CBT
Thursday (20th Apr.) 18:00
Are type safing your configuration? You are probably not, even if you think you do. Process calls? Rest calls? In this session we'll live code our way into type safing everything - conveniently and in the most simple ways. No implicits, no shapeless, no type-level programming, just vanilla Scala code. 

As it turns out Typesafe config, pure config, etc are actually not type safe. We'll see why and what to do instead. A different concept can be applied to make process and rest calls joyfully convenient and elegantly type-safe at the same time. To the point that Scala can become the more convenient choice over bash for shell scripting.
18:45
Community Party
Close
Community Party
Thursday (20th Apr.) 18:45
19:00
Ignite Sessions sponsored by Rally Health
Close
Ignite Sessions sponsored by Rally Health
Thursday (20th Apr.) 19:00
Scala Days Ignite Sessions is a new feature of Scala Days for 2017! All the speakers will each give a 5 min/20 slide presentation on a topic that interests YOU.

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

Tamás Püski: Scale up calm down @ emarsys - How we build Scala teams 
Jean-Rémi Desjardins: Counting votes!
Jonathan Crosmer: Contract Bridge: Not Just for Old People
Jonathan Crosmer: How to Start an Orchestra
Cameron Alexander: Quidditch: Not Just a Sport for Nerds
Noel Welsh: Creative Scala: Programming via the Visual Arts
Ryan Stelly: Coding, Claims, and Confusion: The Funny Side of Healthcare
Mark Greshammer: Homebrew (Beer, not Mac)

Grab a drink, sit down and ENJOY!
Friday (21st Apr.)
08:00 Registration
09:00
Keynote - Jepsen 7: Anna Concurrenina
Kyle Kingsbury
Researcher
Close
Keynote - Jepsen 7: Anna Concurrenina
Kyle Kingsbury
Researcher
Kyle Kingsbury, a.k.a "Aphyr", is a computer safety researcher working as an independent consultant. He's the author of the Riemann monitoring system, the Clojure from the Ground Up introduction to programming, and the Jepsen series on distributed systems correctness. He grills databases in the American Midwest.
Friday (21st Apr.) 09:00
Happy databases are all alike; every unhappy database is unhappy in its own way. Following Tolstoy's insight into distributed systems, we discuss the myriad ways in which the conversations of computer families can break down, leading to broken promises and broken hearts.
10:00 Break
ROOM Zurich ABC Zurich D Zurich E Zurich FG
TRACK
Track 1 - Beginner Friday
Track 2 - Intermediate Friday
Track 3 - Intermediate Friday
Track 4 - Advanced Friday
10:25
The Essence of Testing
Bill Venners
President @Artima, Inc.
Close
The Essence of Testing
Bill Venners
President @Artima, Inc.

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

Friday (21st Apr.) 10:25
After almost ten years of working on ScalaTest, there is still lots of potential for improvement of the library. In this talk, Bill Venners will describe what he has come to 2believe is the essence of testing, and how he wants to evolve ScalaTest as a result. He'll dive into propositional and predicate logic and show how they relate to testing. He'll explain where he thinks property-based testing fits in the big picture, and give demos of some new and exciting features currently being developed for ScalaTest and Scalactic.
Bootstrapping Microservices using Akka, Kafka and Spark
Alex Silva
Principal Software Architect, Data Platform @Pluralsight
Close
Bootstrapping Microservices using Akka, Kafka and Spark
Alex Silva
Principal Software Architect, Data Platform @Pluralsight
Alex Silva is a principal data architect at Pluralsight, where he leads the development of the company’s data infrastructure and services. He has been instrumental in establishing Pluralsight’s data initiative by architecting a platform that is used to capture valuable insights on real-time video analytics while integrating several data sources within the business.

Before joining Pluralsight, Alex was a principal data engineer at Rackspace, leading a team of developers responsible for building the company’s data initiative. Alex has built a reputation as a passionate and pragmatic data evangelist. He was a key asset in establishing Rackspace’s big data platform by helping architect a solution used to drive actionable insight on consumer behavior and product-usage trends. He has also designed several analytical models, APIs, and frameworks that enable Rackspace to deliver its award-winning Fanatical Support®, including a computational linguistics library used to analyze and classify support chat logs.

Alex was also a principal software engineer at ESPN Emerging Technologies. In that role, he architected and developed a distributed application to help basketball operators collect play-by-play records for data warehousing and modeling purposes. Alex has also held several senior-level engineering positions at Walt Disney World Internet Group, Pentaho, OutStart, and Travelatro.com, all based in Orlando, Florida.

Alex is Sun Certified as an Enterprise Architect for the J2EE platform and is also a web component developer and a Java 2 programmer. He earned a bachelor’s degree in molecular biology and an MBA from the University of Central Florida in Orlando.

When Alex is not programming, you’ll probably catch him with an athletic bag on his shoulders. He is a little bit of a sports junkie, particularly a CrossFit addict, who has been known to create an epidemic of fitness recovery, smoking cessation, and weight loss around him.
Friday (21st Apr.) 10:25
Compared to a traditional analysis-centric data hub, today's data platforms need to fulfill many different use cases. The need for real-time, transport-agnostic data protocols have become a crucial feature shared across many different use cases.

During this talk, we will discuss our approach to bootstrapping and bounded context subscription, leveraging a mix of open source technologies and home-grown services aimed at providing a full end-to-end solution.

We will demonstrate and discuss our use of Kafka, Spark Streaming and Akka to orchestrate a unified data transfer protocol that frees developers from having to listen to and process events within their bounded contexts. More specifically:

- Leveraging Kafka as the source of truth
- Topic formats, retention rules and derived topics
- Using Kafka's distributed commit logs to produce durable datasets
- Log compaction and its role in service bootstrapping
- Message delivery guarantees using Akka actors
- Ingestion at scale: consuming data in different formats across different teams at different latencies
- Using Spark Streaming and Akka to perform real-time analysis and implement transfer protocols
Building a Company on Scala
Dag Liodden
CTO and co-founder @Tapad
Close
Building a Company on Scala
Dag Liodden
CTO and co-founder @Tapad
Dag Liodden is Tapad’s Co-Founder and CTO. Dag oversees all technological advancements for the company, including Tapad’s notable breakthroughs in delivering targeted advertising across platforms. Prior to Tapad, he was the co-founder and CTO of Giant Leap Technologies AS, the premier Business Mobility solutions provider in the Nordic region. While there, Dag managed some of the largest wireless enterprise solution rollouts in Europe. He began programming at 6-years-old and has a Master’s Degree in Science, Industrial Economics and Technology Management from the Norwegian University of Science and Technology. Dag has also spoken at events such as Data-Driven NYC, NY Scala meet-ups, and more.
Friday (21st Apr.) 10:25
At any company’s start, they will face of the decision of which programming language will define their technology stack.

For Tapad, this was in 2010, when languages like Scala were in their very early stages and many engineers weren’t looking beyond Java. It was at that time that CTO and co-founder, Dag Liodden, made the decision to use Scala, which arguably provided the technical foundation needed to scale Tapad to what it is today -- a 200+ person company, managing 20+ PB of data, that was recently acquired for $360 million. While adoption has gained significant momentum for Scala since Tapad first embraced the language, it is still in the fairly early stages of maturity, which poses challenges for experienced and novice Scala developer teams alike.

In this session, Dag will address the source of some of these challenges, how they can be resolved, and how Scala can help deliver high quality code at high velocity. Ultimately, all leading up to how engineers and entrepreneurs alike can overcome these barriers to build a team, or even a whole company, on Scala.
Disassembling and Decompiling Scala Code
Ryan Brown
Sr Software Engineer @IBM
Close
Disassembling and Decompiling Scala Code
Ryan Brown
Sr Software Engineer @IBM
Ryan is an software architect focusing on high throughput ingestion and distributed analysis. He has worked at life-science and technology companies, focusing on algorithm and software architecture. He spoke in November 2016 to the Big Data and Madison Developers Meetup groups about challenges with data ingestion using Apache Edgent. Ryan has published academic papers on data analysis techniques and mathematics, and holds a technology patented. Ryan is currently interested in "big data" algorithms that correlate disparate information into actionable results. He has a Masters degree in Computer Science and a Bachelors degree in Mathematics.
Friday (21st Apr.) 10:25
Adoption of enterprise Scala often requires educating Java developers. The runtime implications of many Scala features may not be clearly understood. We investigate Java bytecode produced by the Scala compiler to better understand how Scala creates runnable code. We examine Scala language fundamentals, composition and inheritance, scopes, annotations, and Java interoperability. This is achieved using the javap command to disassemble the .class file to look at its signature, a decompiler, and scalac options. Our goal is to demystify language features and produce better runnable code.
11:10 Break
11:35
ScalaQuest: the Scala adventure
Alejandro Lujan Toro
Senior Developer and Trainer
Close
ScalaQuest: the Scala adventure
Alejandro Lujan Toro
Senior Developer and Trainer
As a Senior Software Developer & Trainer, I split my time between architecting and building software, and coaching others on how to effectively use the Lightbend Reactive Platform.

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

I also contribute to the Scala community by organizing Scala Up North, the first and only Scala conference in Canada.
Friday (21st Apr.) 11:35
ScalaQuest is a fun, enticing game that will take you from Zero to Hero in your path to learning Scala (1).
You will battle Goblins and Wizards and face all kinds of challenges to prove your worth.
Start on the warm, safe haven of plain harmless Classes, hike over Variance Hills and make your way to the trecherous Implicit Forests.

Our goal with ScalaQuest is to make it one of the least painful ways to learn Scala.

This might be the first time you ask your team members to play a game during work hours.

In this talk, we will showcase our work in progress with ScalaQuest, and share our experience building it - our design decisions and the challenges we've faced.
We will then focus on the technical challenges related to compiling user-submitted code on the server side while trying to keep a snappy UI.
--
(1) or will be, at some point in the future, hopefully.
Stream Away with Scala!
Shadaj Laddad
Close
Stream Away with Scala!
Shadaj Laddad
Shadaj loves to program. He is fluent in many programming languages, with Scala being his favorite for its combination of functional and object-oriented concepts. Shadaj hosts his projects on GitHub, and has a channel on YouTube. He has presented at OSCON 2014, Scala Days (2012, 2013, 2014, 2015, 2016), Scala By the Bay, and the Bay Area Scala Enthusiast group showing his Scala projects. Besides programming, he enjoys math and participates in science research competitions. Shadaj is currently the VP of Software Engineering of Lynbrook Robotics, his high school robotics team. He has interned at Khan Academy, Coursera, and Paya Labs working with technologies such as React.js, Play! Framework, and Scala.js to develop educational platforms. In addition, he is also an active member of his school community and has been Student Body President. Shadaj loves spreading his love of technology and started TechTalks — a program that brings guest speakers to share their knowledge and enthusiasm with students at his school. He also volunteers to teach programming to kids through non-profit organizations. When not doing his school work or programming he plays the sitar, an Indian classical instrument and volunteers at a local non-profit music organization.
Friday (21st Apr.) 11:35
Streaming data is found everywhere: IOT devices, self-driving cars, social media, financial markets, and more. Processing such data involves aggregation, extraction of statistical data, online learning, behavior prediction, and acting on results on-the-fly -- forming a processing pipeline. Functional Programming can be used to effectively deal with these pipelines.

In this talk, I will show how functional programming concepts can be used with streaming data, with a specific application of real-time robot control, where all data is streaming. I will introduce Potassium, a Scala framework that facilitates the use of Scala collection-like APIs for processing sensor and computer vision data and sending control signals to actuators. We will explore how robot control systems can be modeled with functional concepts such as applicative functors. The net effect is elegant decomposition of robot systems where components can be implemented and tested in isolation but easily connected in production.

Classical robot algorithms such as digital filters and controllers map directly to functional programming concepts and can be implemented concisely while maintaining high performance. We will explore streaming data used with Akka actors and streams for communication between multiple processing units on a robot and for streaming live data for diagnostics. Finally, we will take a quick look at how React can be used with Scala.js for implementing reusable components for displaying streaming data with “Funky Dashboard”, an open-source streaming data visualization tool that can be easily deployed in your own environment.
Real World Android Akka
Taisuke Oe
Engineer @BONX, INC.
Close
Real World Android Akka
Taisuke Oe
Engineer @BONX, INC.
Taisuke Oe has spent more than five years developing dozens of Android applications in Scala.
He has also organized the largest international Scala conference in Asia, Scala Matsuri for five years.

Now he works for BONX,INC. in Tokyo as an engineer leading the Android team.
He also works for Septeni Original, Inc. in Tokyo as a technical advisor, and for Japan Scala Association, Inc. in Tokyo as executive director and chairman of Scala Matsuri.
Friday (21st Apr.) 11:35
Akka is a great toolkit for a concurrent and resilient system, even if it's in Android.

The BONX outdoor group-talk Android app is a VoIP -Voice over Internet Protocol- client for the extreme sports scene.

It is an audio stream processing client app that has unique requirements such as fewer packets and resiliency.

Since it is expected to run continuously during sports activities, which can be up to 7 hours for skiing or snowboarding, it should, therefore, minimize packets with some additional steps which may make BONX more complex. It should also be able to recover from any errors that occur during the activities, including network disconnection, hardware I/O errors and any other failures in each module. Akka works greatly to manage these types of errors. 

The BONX app, which is built using Akka, detects failures in each module, and suspend or restarts the connection depending on its network environment, or recover from errors immediately without spoiling the user's experience.

That's why the BONX app is rated almost five stars as of January 2017 at Google Play.
 
This talk is not just an introduction to a unique use case, but also demonstrates how Akka is a powerful and easy toolkit that can be used to ensure resiliency and concurrency in a minimal system.
Managing Consistency, State and Identity in Distributed Microservices
Duncan DeVore
Software Engineer @Lightbend
Close
Managing Consistency, State and Identity in Distributed Microservices
Duncan DeVore
Software Engineer @Lightbend
Duncan DeVore is co-author of "Reactive Application Development", Senior Software Engineer at Lightbend on the monitoring team, open source developer and frequent speaker. He has been an avid Scala developer since 2009, holds two patents for software design and led the release of one of the first large-scale Reactive applications in 2012.

 
Friday (21st Apr.) 11:35
In the world of distributed microservices, we face many challenges: parallelism, asynchronous boundaries, state management, identity management and consistency deficiencies, to name a few. Of all these problems, consistency, state management, and identity management can be particularly challenging.

In this session, we will discuss the ins and outs of dealing with microservice consistency and distributed state, and identity coherency with techniques like idempotency, eventual and casual consistency, dealing with CAP theorem, single source of truth and distributed domain design.
12:20 Lunch
13:20
Readers vs Constructors: Dependency Injection showdown
Adam Warski
CTO @SoftwareMill
Close
Readers vs Constructors: Dependency Injection showdown
Adam Warski
CTO @SoftwareMill
I am one of the co-founders of SoftwareMill, where I code mainly using Scala and other interesting technologies. I am involved in open-source projects, such as Macwire, Supler, ElasticMQ and others. I have been a speaker at major conferences, such as JavaOne, Devoxx and ScalaDays.
 
Apart from writing closed- and open-source software, in my free time I try to read the Internet on various (functional) programming-related subjects, any ideas or insights usually end up on my blog: http://www.warski.org/blog
Friday (21st Apr.) 13:20
Like it or not, but how in-code dependencies are managed is one of the key decisions that we have to make when working on a project.

We've seen various approaches to Dependency Injection come and go. In Scala's early days, the Cake Pattern was quite fashionable; but there was just too much boilerplate. Instead, maybe we could just use plain constructors for wiring dependencies (MacWire)? Use a hybrid service locator (SubCut, Scaldi)? Or go fully functional, and use the Reader Monad; but is it really a replacement of Dependency Injection frameworks/libraries? Finally, maybe we should stick with proven Java-land solutions, like Guice (used e.g. by the Play Framework)?

In this live-coding talk I'll try to clear the above doubts (at least partially) and propose some practical solutions. We'll go through wiring a simple application using constructor-based dependency injection, reader-monad based dependency injection, and finally mixing the two for the best results.
Building Code Analysis Tools at Twitter
Stu Hood
Software Engineer @Twitter
Eugene Burmako
Software Engineer @Twitter
Close
Building Code Analysis Tools at Twitter
Stu Hood
Software Engineer @Twitter
Long term user and advocate, medium term Scala build engineer. Helping to make it as pleasant to build Scala as it is to write it.
Eugene Burmako
Software Engineer @Twitter
Member of the Scala language team, founder of Scala Macros and Scala Meta.
Friday (21st Apr.) 13:20
At Twitter, we're working with millions of lines of Scala code, and that makes intelligent developer tools especially important. Multiple aspects of our development workflow, including code browsing, code review and code evolution, can be significantly improved if we go beyond just grep and ctags. In this talk, we will present our vision and hands-on experience with a next-generation code analysis toolkit based on the newly introduced scala.meta semantic API.
Monad transformers down to earth
Gabriele Petronella
Software Engineer @Buildo
Close
Monad transformers down to earth
Gabriele Petronella
Software Engineer @Buildo
unctional bit flipper, building awesome things in scala and react at buildo.io

Stackoverflow addict.

Organizer of Milano Scala Group and Scala Italy conference.

When not coding or organizing events, he's either on a plane or at the basketball court.
Friday (21st Apr.) 13:20
Monad Transformers. "WAT?" "Exactly"

In this session we'll see what monad transformers are, where their need comes from and how to use them effectively.

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

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

WARNING

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

Listener discretion advised.
Doubt Truth to be a Liar: Non Triviality of Type Safety for Machine Learning
Matthew Tovbin
Principal Engineer, Einstein @Salesforce
Close
Doubt Truth to be a Liar: Non Triviality of Type Safety for Machine Learning
Matthew Tovbin
Principal Engineer, Einstein @Salesforce
Matthew Tovbin is a Principal Member of Technical Staff at Salesforce, engineering Salesforce Einstein AI platform, which powers the world’s smartest CRM. Before joining Salesforce, he acted as a Director of Engineering at Badgeville, implementing scalable and highly available real-time event processing services with Scala. In addition, Matthew is a co-organizer of Scala Bay meetup and an active member in numerous functional programming groups. Matthew lives in SF Bay area with his wife and kid, enjoys photography, hiking, good whisky and PC gaming.
Friday (21st Apr.) 13:20
Feature vectors – sequences of heterogenous types – are the basic unit of any machine learning algorithm. Further, feature engineering involves manipulations of these feature vectors and is a fundamental step in optimizing the accuracy of machine learning models. These manipulations may take the form of regular Scala sequence operations that can also be distributed using frameworks such as Spark or Flink. When building a general purpose machine learning framework, the types of engineered features is not known in advance, which is a problem for statically typed languages. In this talk, I will walk through possible solutions for designing type-safe feature vectors in Scala that provide compile-time type safety for feature engineering and other machine learning use cases. The solutions will demonstrate applications of Shapeless, Scala Macros, and Quasiquotes.
14:05 Break
14:30
The Last 10 Percent
Stefan Zeiger
Senior Software Engineer @Lightbend
Close
The Last 10 Percent
Stefan Zeiger
Senior Software Engineer @Lightbend
Stefan Zeiger is a member of the Scala compiler team at Lightbend. He was the tech lead for Slick since 2011 and the creator of its predecessor, ScalaQuery. 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 frequent speaker at ScalaDays and other conferences.
Friday (21st Apr.) 14:30
Have you learned Scala and just created your first Scala library (or would you like to)? How do you continue when you are finished writing the code and it does what it is supposed to do? The only remaining obstacle is to get it into the hands of others, but the technical details involved in this can be overwhelming the first time. Where do you publish it, and how? What about tests, test infrastructure, documentation, licensing, versioning, releasing? How do you perform these steps manually? Can you automate them? In this session we will look at and perform live all the necessary steps to take your code from a bunch of Scala source files to an open source Scala project.
Experiences with Scala Across the College-Level Curriculum
Konstantin Läufer
Professor and Chairperson, Department of Computer Science, Loyola University Chicago
Close
Experiences with Scala Across the College-Level Curriculum
Konstantin Läufer
Professor and Chairperson, Department of Computer Science, Loyola University Chicago
Konstantin joined the computer science faculty at Loyola University Chicago in 1992. His research interests include programming languages, software architecture, and distributed and pervasive computing. He has been using Scala regularly in teaching and research since 2010 and maintains a collection of open-source course materials and examples.
Friday (21st Apr.) 14:30
Various hybrid-functional languages, designed to balance compile-time error detection, conciseness, and performance, have emerged. Scala, e.g., is interoperable with Java and has become an early leader in adoption, especially in the start-up and open-source spaces.

As educators, we have recognized Scala’s value as a teaching language across the CS curriculum. In CS1, the read-eval-print loop and simple, uniform syntax aid programming in the small. In CS2, higher-order methods allow concise, efficient manipulation of collections. In a programming languages course, advanced constructs facilitate the separation of concerns, program representation and interpretation, and concurrent programming. In advanced applied courses, language mechanisms and suitable libraries support the development of mobile apps, web apps, and web services.

Based on our own experiences in the classroom, we discuss what works and what needs improvement, and hope to discuss the best ways for industry and higher education to partner in an effort to meet the growing demand for Scala talent.
Introduction to code generation with scalameta
Michael Pollmeier
Senior architect developer
Close
Introduction to code generation with scalameta
Michael Pollmeier
Senior architect developer
Michael has been an active member of the Scala community for >6 years and loves databases, clean code and libre software. He works for ShiftLeft security (https://shiftleft.io/) on application vulnerability detection using code property graphs, and is the creator of gremlin-scala (https://github.com/mpollmeier/gremlin-scala/) and scalameta-serialiser (https://github.com/mpollmeier/scalameta-serialiser). Follow him at @mpollmeier (https://twitter.com/pollmeier).
Friday (21st Apr.) 14:30
This talk provides an introduction to scalameta from the perspective of code generation. So far the documentation and discussion center mostly around using it for code analysis and transformation (scalafix), but code generation is an equally if not more important subject for metaprogramming.

I will do a live demo walking to walk you through the basics, demonstrate how nice and composable the scalameta DSL is, and describe some more advanced use cases / ideas. It is still very early days for scalameta, so we'll have a discussion about other potential use cases and differences to old style macros which are still more widely used and known.

I published scalameta-serialiser, an easy to use library that generates functions to serialise and deserialise any case class, and wrote a blog post about code generation with scalameta.
Uniting Church and State: FP and OO Together
Noel Welsh
Partner @Underscore
Close
Uniting Church and State: FP and OO Together
Noel Welsh
Partner @Underscore

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

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

Late last year Maana, a Seattle based enterprise knowledge platform startup, contracted us to write a time series analysis engine.
They commonly dealt with multi-TB data, but needed to achieve interactive speed.
We recognised that providing a streaming API, similar to Monix, Akka Streams, or Reactive Extensions, would make the software accessible to data scientists already used to Spark, but there were issues about semantics and performance.
Classic FP pull-based systems are simple to use but perform poorly, while OO push-based systems are fast but tricky to reason about.
By employing Church encoding, also known as refunctionalisation, we were able to get the best of both worlds.
The user sees a straightforward API and semantics, while under the hood the system has no runtime memory allocation and is extremely efficient.
This tool is not so widely known and the purpose of our talk is to introduce it to a wider audience.

Church encoding is a general purpose tool you can apply to your own code no matter what software you build.
It provides a relationship between the classic FP tool of algebraic data types (represented in Scala using `sealed` traits) and OO-style classes.
We can use it to convert FP-style code into an OO equivalent, which can use mutable state and other optimisations without affecting the clean semantics the user sees.
Church encoding also gives us a coherent design principle to unite FP and OO.
This provides a bridge to truly unlocking Scala's multiparadigm nature while retaining an overall architecture that is simple and consistent.
15:15 Break
15:40
Scary Build Tool? Automate more with sbt.
Justin Kaeser
Software Developer @JetBrains
Close
Scary Build Tool? Automate more with sbt.
Justin Kaeser
Software Developer @JetBrains
Justin always seems to end up tweaking the tooling rather than doing his actual job. Unsurprisingly, he ended up working at JetBrains, improving the sbt support for the IntelliJ Scala plugin.
Friday (21st Apr.) 15:40
Let's face it: You may be able to avoid using sbt to build your Scala projects, but you probably don't want to. It's the de-facto standard for Scala projects and is programmed and configured in Scala itself.

We'll develop a simple sbt plugin together and explore some of the concepts of an sbt build's architecture. The goal is to help you better automate your builds in a single environment rather than stringing together scripts and tools.
Understanding distributed system optimizations
Martin Zapletal
CTO @Cake Solutions
Close
Understanding distributed system optimizations
Martin Zapletal
CTO @Cake Solutions
Martin is heading up Cake Solutions technical team in the US, is Apache Spark and Cassandra plugin for Akka Persistence contributor and a researcher in the field of distributed systems and machine learning.

Martin focuses on distributed systems, parallel and distributed approaches to data processing as well as machine learning, data mining in large volumes of data, and big data in general. These fields seem to be increasingly important in the industry and Martin has been promoting Scala, functional programming, and Reactive approaches as they provide very useful tools to solve these problems.
Friday (21st Apr.) 15:40
Scalability and performance are critical for many business use cases. This talk focuses on techniques for achieving optimized high performance in distributed systems while dependably providing required guarantees and ideally keeping the costs for resources, including CPUs, GPUs, memory and storage low.

Firstly, the presentation introduces and in depth explains selected optimization techniques used in state of the art large scale stream and fast data processing frameworks such as Akka Streams, Spark or Flink, including configuration, deployment, logical and physical level optimizations. Consequently, powerful optimization concepts applicable to general distributed systems, including those built using Akka, are presented and demonstrated on examples. Finally the role of machine learning and artificial intelligence in the optimizations area is highlighted.

The attendees will gain understanding of the available optimization approaches and tradeoffs and ultimately will be able to apply some of the techniques to optimize their own system, whether general distributed systems written in Scala, systems based on Akka or any of the aforementioned technologies.
Akka Support in IntelliJ IDEA
Andrew Kozlov
JetBrains
Close
Akka Support in IntelliJ IDEA
Andrew Kozlov
JetBrains
Andrew has been a JetBrains employee since graduating with a B.Sc. degree in Computer Science. After falling in love with Scala joined the Scala plugin team. Currently is working on Akka and Dotty support in IntelliJ IDEA. Besides programming is interested in public speaking: has participated in several conferences (including ScalaDays), has been teaching programming courses for high school and university students for more than 5 years.
Friday (21st Apr.) 15:40
Since Akka is one of the most popular Scala related frameworks, its support in IntelliJ IDEA has been just a matter of time. The purpose of the talk is to introduce one to Akka specific features of IntelliJ IDEA. Moreover this talk could be considered as an opportunity to suggest a killing feature that may be soon introduced.
Class up your config
Andy Scott
Senior Software Engineer @47 Degrees
Close
Class up your config
Andy Scott
Senior Software Engineer @47 Degrees
Andy Scott is a Senior Software Engineer at 47 Degrees, a functional programming consulting firm. He has a background in systems engineering and a degree in Mechanical Engineering from Georgia Tech. He’s an active contributor to open source projects such as Scala Exercises, Cats, the Scala compiler, AsyncDisplayKit for iOS, and Scala Bot. And He recently authored Case Classy, a tiny framework for simplifying the process of decoding untyped structured data into case class hierarchies. In his free time, Andy teaches CrossFit and likes to travel.
Friday (21st Apr.) 15:40
Configuring production applications is a conceptually simple task that sometimes winds up being a lot of work. It shouldn't be this way.

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

In this talk we will introduce Case Classy, showing how to use it and its benefits over other configuration libraries. We will dive into the functional programming foundations and how this enables us to assemble and combine decoders so that errors accumulate. And we will look at how Shapeless and generic programming can automatically assemble decoders for us and save us from an abyss of boilerplate.
16:25 Break
16:50
Closing Panel
Adriaan Moors
Scala Team Lead @Lightbend
Dmitry Petrashko
Doctoral Assistant @EPFL
Jon Pretty
Scala Developer @Propensive Ltd
Stefan Zeiger
Senior Software Engineer @Lightbend
Seth Tisue
Lightbend
Eugene Burmako
Software Engineer @Twitter
Bill Venners
President @Artima, Inc.
Close
Closing Panel
Adriaan Moors
Scala Team Lead @Lightbend
Adriaan leads the Scala team at Lightbend. Our mission is to make Scala the most practical and productive language you've ever worked with, by providing a flexible set of simple constructs to help you build scalable and maintainable solutions for complex problems (and have fun while doing so).

Adriaan's been working on the Scala compiler for ten years, with his first contribution being support for type constructor polymorphism. More recently, he worked on support for Java 8's retro-fit of functions (single abstract method types) and internal compiler cleanups to take advantage of simplifications in our encoding enabled by Java 8's support for default methods in interfaces.
Dmitry Petrashko
Doctoral Assistant @EPFL
Dmitry has been working on Scala since 2013, when he joined Martin Odersky's research lab at EPFL, working on ScalaBlitz, macro-generated collections for Scala. Since 2015 he has been working on the Dotty Compiler. He designed Mini-Phases, ported the JVM backend, implemented support for Java 8 lambdas and default methods, along with various other parts of the compiler, including the pattern matcher, lazy vals, tail recursion transformations and parts of erasure and mixin composition.
Jon Pretty
Scala Developer @Propensive Ltd
Jon has been involved in the Scala community for over a decade, having launched the first commercial and open-source Scala software back in 2005.

Since then, he has successfully deployed Scala projects into small, medium and large businesses, and the UK government, but is best known these days for his work on Rapture, Contextual and the Scala World conference, and as chair of the Scala Center Advisory Board.
Stefan Zeiger
Senior Software Engineer @Lightbend
Stefan Zeiger is a member of the Scala compiler team at Lightbend. He was the tech lead for Slick since 2011 and the creator of its predecessor, ScalaQuery. 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 frequent speaker at ScalaDays and other conferences.
Seth Tisue
Lightbend
Likes: compilers, interpreters, functional programming, open-source, teaching, learning. Co-host, Scalawags podcast. Coding Scala daily since 2008; on the Scala team at Lightbend since 2015. Previously worked on NetLogo, a language for simulations and games.
Eugene Burmako
Software Engineer @Twitter
Member of the Scala language team, founder of Scala Macros and Scala Meta.
Bill Venners
President @Artima, Inc.

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

Friday (21st Apr.) 16:50
Join is in room Zurich ABCD for the closing panel with Adriaan Moors, Bill Venners, Eugene Burmanko, Stefan Zeiger. The closing panel will be moderated by Jon Pretty.

Ask your questions on Twitter: https://twitter.com/propensive/status/855444840208793600

Conference and Training

Swissôtel Chicago

323 E Upper Wacker Dr.

Chicago, IL 60601

Website Map

Training 

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

All trainings will take place at:

Swissôtel Chicago
323 E Upper Wacker Dr
Chicago, IL 60601

Fast Track to Scala

Trainer: Yury Gribkov

Object-oriented meets functional—elegant class hierarchies, seamless Java interoperability, maximum code reuse and extensibility, built to solve difficult concurrency challenges. Take your first steps in Scala with the best trainers!

Participant

  • Developers who have experience and proficiency in Java, C++, C# or Ruby
  • Scala programmers with minimal experience looking for a refresher
  • Managers who want to gain an understanding of functional programming

Benefit

  • Developers gain knowledge and skills to confidently program in Scala
  • Certified Lightbend Trainers share coding insights that lead to high-quality code
  • Re-discover a passion for software - Scala is fun

Outline

  1. Language fundamentals
  2. Tools for Scala Development
  3. Collections & Functional Programming
  4. For-Expressions & Loops
  5. Inheritance & Traits
  6. Pattern Matching & Optional Values

Logistics

  • Level: Introductory - no previous knowledge of Scala is assumed
  • Length: Two days - 14 hours of classroom time, plus breaks
  • Approach: Beyond education - students code through a training case study and discover how to effectively apply Scala in their work environment
  • Requirements: Students must bring their own laptops with Java 6 or higher installed

 

SOLD OUT - Advanced Scala 

Trainers: Wade Waldron, Alejandro Lujan Toro

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

Participant

  • Developers who have experience and proficiency in Scala
  • Developers who want to understand advanced features in Scala
  • Managers who want to gain a deep understanding of functional programming

Benefit

  • Developers gain knowledge and skills to confidently program in Scala
  • Certified Lightbend Trainers share coding insights that lead to high-quality code
  • Advance to the limits of Scala capability!

Outline

  1. Recap of important basics
  2. Object-Functional Programming in Depth
  3. Mastering the Type System
  4. Explicitly Implicit
  5. Internal DSLs
  6. Custom Scala Collections

Logistics

  • Level: Advanced - knowledge of and practical experience with Akka is assumed
  • Length: Two days - 14 hours of classroom time, plus breaks
  • Approach: Hands-on mastery - students code through workshop case study and explore how to solve the toughest Scala challenges in their own work
  • Requirements: Students bring their own laptops with Java 6 or higher installed

 

Fast Track to Akka with Scala

Trainer: Ryan Case

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

Participant

  • Developers with basic knowledge of Scala, as covered in “Fast Track to Scala”
  • Developers who want to develop resilient, event-driven, scalable applications
  • Managers who want to learn how reactive applications drive business value

Benefit

  • Developers gain knowledge and skills to design fault-tolerant apps using Akka
  • Certified Lightbend Trainers share how to configure, test, and tune Akka apps
  • Production readiness - create asynchronous, event-driven systems

Outline

  1. Introduction to Akka
  2. Actor Basics
  3. Testing Actors
  4. Actor Lifecycle
  5. Fault Tolerance
  6. Scaling up with Routers

Logistics

  • Level: Intermediate - knowledge of and practical experience with Scala is assumed
  • Length: Two days - 14 hours of classroom time, plus breaks
  • Approach: Extensive hands-on coding - students develop a workshop case study and produce a fully functional application that is event-driven and resilient
  • Requirements: Students must bring their own laptops with Java 6 or higher installed

 

Apache Spark: An Introductory Workshop for Developers

Trainer: Petro Verkhogliad

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

Participant

  • Developers with basic knowledge of Scala, as covered in “Fast Track to Scala”
  • Developers with an interest in data science looking to put theory into high-scale practice
  • Managers who want to understand how to field applications powered by fast data analytics

Benefit

  • Developers gain knowledge and skills to build Spark-based offline and event-streaming applications
  • Certified Lightbend Trainers share best practices for developing Scala-Spark applications
  • Production data - integrate Spark with Akka and Hadoop, today!

Outline

  1. Introduction to Spark
  2. Writing Spark RDD Applications I
  3. Writing Spark RDD Applications II
  4. Spark SQL and DataFrames
  5. Spark Streaming
  6. MLib, GraphX, and Others
  7. Spark Clusters (optional)

Logistics

  • Level: Intermediate - knowledge of and practical experience with Scala is assumed
  • Length: Two days - 14 hours of classroom time, plus breaks
  • Approach: Extensive hands-on coding - students develop a workshop case study and use Spark to process real-world data sets
  • Requirements: Students must bring their own laptops with Java 6 or higher installed

Tickets


Conference (2.5 days)

Before Jan 18 Before Mar 15 After Mar 15
$950  $1050 $1150

Conference + 2 training days (4.5 days)

Before Jan 18 Before Mar 15 After Mar 15
$2100 $2450 $2600

2 Training day only

Before Jan 18 Before Mar 15 After Mar 15
$1250 $1500 $1550

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


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

Book hotel

Sponsors

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


Gold

47 Degrees Cake Solutions Jetbrains Tapad

Silver


Rally Health Virtuslab

Partner


Produced by

Lightbend Trifork

Code of Conduct

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

 

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

 

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

 

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

 

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

Crew Volunteers

Crew registration is closed. Thanks to everyone who helps.

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

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

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