Scala Days

May 9th-13th, 2016 New York


App

Download the Scala Days App in order to see the latest version of the schedule, vote sessions, follow the #scaladays twitter stream etc.

For iOS
For Android

Keynotes

Matei Zaharia, Creator of Apache Spark & Assistant Professor of Computer Science @MIT

Spark 2.0

Wednesday May 11


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

About

Scala Days New York

Scala Days, the premier Scala Conference, will be held this year at New World Stages in New York on May 9th through 11th, 2016, followed by two days of training, May 12th - 13th, 2016, at AMA Executive Conference Center.  There will also be a Scala Days Europe at the bcc in Berlin on June 13th through 17th, 2016. 

 

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

 

Last year’s conferences in San Fancisco and Amsterdam were sold-out events! 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.

Monday (9th May.)
ROOM Stage 3
16:00
Scala's Road Ahead
Martin Odersky
Scala Creator & Co-Founder of Lightbend
Close
Scala's Road Ahead
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

Monday (9th May.) 16:00
After a fairly quiet 2015, things are heating up this year. To name
just three major developments among many: A major new release, Scala
2.12, is about to be completed. The Scala Center provides a new focus
point for community collaboration. And there's a new experimental
platform, dotty, which lets us prototype designs for the next
generation of the language.

In my talk I'd like to look a bit further ahead and focus on where I
see Scala in the next 5 years, touching topics like: What is Scala's
unique identity as a programming language? How should it evolve? What
exciting new technologies are on the horizon?
17:00
Welcome Reception: Sponsored by Cake Solutions
Close
Welcome Reception: Sponsored by Cake Solutions
Monday (9th May.) 17:00
Tuesday (10th May.)
08:00 Registration
09:00
Introducing the Scala Center
Heather Miller
Executive Director of the Scala Center, Research Scientist at EPFL
Close
Introducing the Scala Center
Heather Miller
Executive Director of the Scala Center, Research Scientist at EPFL
Heather Miller is a PhD student in Martin's group and regularly give talks at industrial conferences like Strange Loop, and academic conferences like OOPSLA and ECOOP.
Tuesday (10th May.) 09:00
10:00 Break
ROOM Stage 1 Stage 3 Stage 2 Stage 4
TRACK
Track 1 - Intermediate Tuesday
Track 2 - Intermediate Tuesday
Track 3 - Advanced Tuesday
Track 4 - Beginner Tuesday
10:25
Monitoring Reactive Applications
Henrik Engström
Senior Software Engineer @Lightbend
Duncan DeVore
Software Engineer @Lightbend
Close
Monitoring Reactive Applications
Henrik Engström
Senior Software Engineer @Lightbend
After graduating with a M.Sc degree in Computer Science in 1998 at the Royal Institute of Technology Henrik Engström has been working as a consultant up until his Lightbend employment in 2011. Henrik has not only vast experience from various types of programming but also great domain knowledge within the finance, retail and e-gaming industries. Apart from his major interest, programming languages, he is also an avid Arsenal supporter, black belt in Shotokan Karate and a hobby wine connoisseur.
 
Henrik has during the last couple of years presented at various well-known conferences such as JavaOne, OSCON, JFokus, Scala eXchange, 33 Degrees.
Duncan DeVore
Software Engineer @Lightbend
Duncan DeVore is co-author of ""Reactive Application Development"", Software Engineer at Lightbend, open source developer and frequent speaker. He has been an avid Scala developer since 2009, holds two patents for software design and led the release of one of the first large-scale Reactive applications in 2012.
 
Tuesday (10th May.) 10:25
Reactive Applications are the next major evolution of the Internet. They allow for applications to be responsive, scalable and resilient by building on a fully event-driven foundation. Lightbend’s Reactive Platform, consisting of the Play Framework, the Akka middleware and the Scala programming language embraces this new programming paradigm which allows developers to write interactive applications that are always available and which adapt to changing load by being distributed by design.
 
While the reactive approach enable us to build highly scalable and resilient applications it also introduces new challenges in how to monitor them. Almost every current monitoring tool relies on a stack frame based approach where using the stack trace can provide good answers to what caused the exceptional state. In message driven, or asynchronous, applications this approach no longer provides any good information. We therefore need to invent new approaches for how to monitor these types of applications. During this session we will cover the traditional monitoring approach, different possible ways of how to monitor asynchronous applications and finally show the way we have chosen to build a monitoring tool for reactive applications at Lightbend
Scala: The Unpredicted Lingua Franca for Data Science
Andy Petrella
Co-Founder @Data Fellas
Dean Wampler
Big Data Architect @Lightbend & O'Reilly Author
Close
Scala: The Unpredicted Lingua Franca for Data Science
Andy Petrella
Co-Founder @Data Fellas
Andy is a mathematician turned into a distributed computing entrepreneur.
Besides being a Scala/Spark trainer. Andy also participated in many projects built using spark, cassandra, and other distributed technologies, in various fields including Geospatial, IoT, Automotive and Smart cities projects.
He is the creator of the Spark Notebook (https://github.com/andypetrella/spark-notebook), the only reactive and fully Scala notebook for Apache Spark.
In 2015, Xavier Tordoir and Andy founded Data Fellas:
  • the Agile Data Science Toolkit, Shar3;
  • the Distributed Genomics product, Med@Scale.
Andy is also member of program committee of the O’Reilly Strata, Scala eXchange and Data Science eXchange and Devoxx events
Dean Wampler
Big Data Architect @Lightbend & O'Reilly Author

Dean Wampler is the Big Data Architect at Lightbend and specializes in the application of Functional Programming principles to “Big Data” applications, using Hadoop and alternative technologies. 

Tuesday (10th May.) 10:25
It was true that, until pretty recently, the language of choice to manipulate and to make sense out of the data for Data Scientists was mainly one of Python, R or Matlab. This lead to split in the communities and duplication of efforts in languages offering a similar set functionnaiity.
Although, it was foreseen that Julia (for instance) could gather parts of these communities, an unexpected event happened: the amount of available data and the distributed technologies to handle them. Distributed technologies raised out of the blue by data engineer and most of them are using a convenient and easy to deploy platform, the JVM.
 
In this talk, we’ll show how the Data Scientists are now part of an heterogeneous team that has to face many problems and have to work towards a global solution together. This is including a new responsibility to be productive and agile in order to have their work integrated into the platform. This is why technologies like Apache Spark is so important nowadays and is gaining this traction from different communities. And even though some binding are available to legacy languages there, all the creativity in new ways to analyse the data has to be done in scala. So that, the second part of this talk will introduce and summarize all the new methodologies and scientific advances in machine learning done Scala as the main language, rather than others. We’ll demonstrate that all using the right tooling for Data Scientists which is enabling interactivity, live reactivity, charting capabilities and robustness in Scala, something there were still missing from the legacy languages. Hence, the examples will be provided and shown in a fully productive and reproducible environment combining the Spark Notebook and Docker.
Data Structures of the Dark Side
Shimi Bandiel
Founder & CTO @Trainologic Ltd.
Close
Data Structures of the Dark Side
Shimi Bandiel
Founder & CTO @Trainologic Ltd.
Founder and CTO of Trainologic (outsourcing, consulting and training company). Working in the JVM ecosystem since 2000 and with Scala from 2009. Delivered more than 200 courses in the Java/Scala ecosytem including Basic Scala, Advanced Scala, Functional Programming with Scala, Spark, Akka, etc... Key speaker in Java and Scala conferences in Israel.
Tuesday (10th May.) 10:25
We are all familiar with the standard-library's data structures. However, there are some unfamiliar (to most) data structures that can be useful (especially in functional programming). In this session, we'll discuss DList (Difference List) and Zippers, their use-cases, advantages and disadvantages. We'll also cover implementation and related topics (e.g., Anamorpishms, Trampolines, the Writer monad and Co-Monads).
Lightbend Lagom: Microservices "Just Right"
Mirco Dotta
Software Engineer @Lightbend
Close
Lightbend Lagom: Microservices "Just Right"
Mirco Dotta
Software Engineer @Lightbend

Mirco is a software engineer at Lightbend. He is currently working on the Lagom framework, and has contributed to a few open source projects in the Scala ecosystem, such as the Play Framework, and the Scala IDE for Eclipse. Loves chess, good wine, and a big foosball aficionado.

Tuesday (10th May.) 10:25

Microservices architecture are becoming a de-facto industry standard, but are you satisfied with the current state of the art? We are not, as we believe that building microservices today is more challenging than it should be. Lagom is here to take on this challenge. First, Lagom is opinionated and it will take some of the hard decisions for you, guiding you to produce microservices that adheres to the Reactive tenents. Second, Lagom was built from the ground up around you, the developer, to push your productivity to the next level. If you are familiar with the Play Framework's development environment, imagine that but tuned for building microservices; we are sure you are going to love it! Third, Lagom comes with batteries included for deploying in production: going from development to production could not be easier. In this session, you will get an introduction to the Lightbend Lagom framework. There will be code and live demos to show you in practice how it works and what you can do with it, making you fully equipped to build your next microservices with Lightbend Lagom!

11:10 Break
11:35
Cancelled
Close
Cancelled
Tuesday (10th May.) 11:35
Principles of Elegance
Jon Pretty
Managing Director
Close
Principles of Elegance
Jon Pretty
Managing Director
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 UK government, but is best known these days for his work on Rapture and as the organizer of the annual Scala World conference.

Jon has spoken on a variety of topics at dozens of Scala conferences and user groups around the world over the last five years.
Tuesday (10th May.) 11:35
Scala combines a comprehensive array of syntactic features with a rich static type system. At the intersection between Scala's syntactic versatility and its reliable type-level constraints, there exists a narrow window of opportunity for designing APIs that are both expressive and safe; for writing code that is elegant.

We will explore this unique "elegance zone" offered by Scala, with useful real-world examples from Rapture, a collection of libraries for familiar everyday programming tasks, such as working with JSON, XML, HTML and CSV, time, internationalization, logging and I/O. Rapture's philosophy is to drive forwards the state of the art in typesafety, whilst at the same time maintaining the most intuitive syntax.

Ultimately, we will show that features of Scala like implicits and type inference offer some very exciting possibilities for developing software that provides both clearer code and offers more static guarantees, and that writing elegant code in Scala is within everyone's grasp—this is Scala's great chance to outshine other languages!
Roll Your Own Shapeless
Daniel Spiewak
Functional Archon @RichRelevance
Close
Roll Your Own Shapeless
Daniel Spiewak
Functional Archon @RichRelevance
Daniel Spiewak is a software developer based out of Boulder, CO. Over the years, he has worked with Java, Scala, Ruby, C/C++, ML, Clojure and several experimental languages. He currently spends most of his free time researching parser theory and methodologies, particularly areas where the field intersects with functional language design, domain-specific languages and type theory.
 
Tuesday (10th May.) 11:35
Shapeless is a remarkable framework.  It gives us the power to represent astonishingly rich constraints and generalize code over very broad structural classes, but it isn't magic!  The tools with which shapeless is crafted are present in your version of scalac just as much as they are in Miles Sabin's, and learning to take advantage of them unlocks a rich palette of expression otherwise untapped in the language.  In this talk, we will recreate some of the major elements of shapeless, learning how to harness a fully armed and operational type system, all while avoiding any hint of macro programming!  Particular focus will be given to understanding the general patterns and ideas involved, and not just the end result.
A Literally-Hands-on Introduction to Distributed Systems Concepts with Akka Clustering
David Russell
Software Developer @Hootsuite Media Inc.
Close
A Literally-Hands-on Introduction to Distributed Systems Concepts with Akka Clustering
David Russell
Software Developer @Hootsuite Media Inc.
Dave Russell is a Software Engineer on the Publishing team at Hootsuite, Amateur leatherworker, and Advocate of connecting everything to Electric Imps.
Tuesday (10th May.) 11:35
Learning the concepts of Distributed Systems can be confusing: What is cluster membership? What is a partition, and what happens to the system when it occurs? How do we scale up a system safely? What happens when you bring down a node with a baseball bat?
 
Raspberry Pi's provide an excellent mechanism to answer these questions - they are visible, tactile, portable and cheap.  Akka makes building and running distributed systems a breeze. This presentation will demonstrate a physical model of a distributed system using Akka and Raspberry Pi’s, with a gamified explanation of High Availability, Cluster Management, Gossip protocols, and Leader Election.
12:20 Lunch
13:20
Reactive Microservices with Akka and Docker
Heiko Seeberger
Fellow @Codecentric
Close
Reactive Microservices with Akka and Docker
Heiko Seeberger
Fellow @Codecentric
Heiko Seeberger is Fellow at codecentric and an internationally renowned expert on Scala and Akka. He has more than 20 years of experience in consulting and software development. Heiko tweets under @hseeberger and blogs under heikoseeberger.de.
Tuesday (10th May.) 13:20
Akka is a toolkit for building elastic and resilient distributed systems and Docker makes shipping and running those distributed systems easy as never before. In this talk we will briefly introduce you to the basics of Akka and Docker and then show how you can use these innovative technologies to build and run really Reactive micorservices. Don’t expect too many slides, but be prepared for live demos.
CBT - A New, Intuitive Build Tool for Scala
Christopher Vogt
Senior Software Engineer @x.ai
Close
CBT - A New, Intuitive Build Tool for Scala
Christopher Vogt
Senior Software Engineer @x.ai

Christopher is a Slick co-author, Compossible records author, frequent Scala conference/user group speaker, and a former member of Martin's team at LAMP/EPFL. He is based in NYC where he works as a Senior Software Engineer at x.ai.

Tuesday (10th May.) 13:20

Imagine a world where writing and maintaining build scripts is fun and not black magic. A world without axis-scoped-multi-config-multi-project builds. With fast dependency resolution. Intuitive and statically checked build configuration. Where large builds use few and simple building blocks to compose small, self-contained and easy to understand builds. Where you only need to learn a small Scala library nothing more. Welcome to CBT - fun, fast, intuitive, composable, statically checked builds written in Scala. This is not a prototype. It's ready for prime time. This talk gets you started writing your own CBT builds. We'll do live coding and explain the philosophy behind CBT. If time permits, we'll dive into CBT's actually small and easy to understand code base.

 

Dotty Linker: Precise Types Bring Performance
Dmitry Petrashko
PhD student @EPFL
Close
Dotty Linker: Precise Types Bring Performance
Dmitry Petrashko
PhD student @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 withvarious other parts of the compiler, including the pattern matcher, lazy vals, tail recursion transformations and parts of erasure and mixin composition.
He currently works on implementing the Dotty Linker, an optimizing compiler based on Dotty.
Tuesday (10th May.) 13:20
Common arguments for using more elaborate type systems include safety and documentation. But we will show how more expressive type systems can be used to drive novel powerful optimizations and make the program faster. Based on this principle, we built the Dotty Linker, a whole-program optimizer that represents a breakthrough in optimization of Scala code. We will demonstrate how the linker is capable of reducing the performance overhead of commonly-used Scala features such as generic methods and classes, lazy vals, implicit conversions and closures.
Build a Recommender System in Apache Spark and Integrate It Using Akka
Willem Meints
Technical Evangelist @Info Support
Close
Build a Recommender System in Apache Spark and Integrate It Using Akka
Willem Meints
Technical Evangelist @Info Support
Willem is a technical evangelist for Info Support where he helps projects get the most out of new innovations like Machine Learning and IoT. When not helping projects get going with new technology he works on knowNow, a social knowledge management platform.
Tuesday (10th May.) 13:20

Machine Learning to some is still very magical. The truth however is that this magic is actually much easier to use than you'd expect. Come and learn how you can use Apache Spark and Akka together to build a service that recommends items to users. In this session, I'm going to show you some of the bits that go into building a recommender system, how to actually implement one in Spark and finally how to integrate the recommender system into your application using Akka HTTP.

14:05 Break
14:30
Scala on the Move!
Shadaj Laddad
Close
Scala on the Move!
Shadaj Laddad

Shadaj loves to program. He has programmed in Ruby, Python, C, Java, Javascript, and Scala—his favorite. Shadaj hosts his projects on GitHub, and has a channel on Youtube. He has presented at OSCON 2014, Scala Days (2012, 2013, 2014), and the Bay Area Scala Enthusiast group showing his Scala projects. Besides programming, he likes Math and Science. 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. When not doing his school work or programming, he plays the sitar, and games, some of which he created.

Tuesday (10th May.) 14:30

In the past year, all of my projects have involved using Scala with some moving entity: musical notes, robots, garage doors, and so on. In this talk, I will show how Scala has been consistently helpful, no matter what I throw at it.

In a research project to categorize and identify musical recordings, Scala made a complex processing pipeline look beautiful with its collections. Processing pitches, building musical models, and applying machine learning algorithms could each be implemented as a data transformation.

On my high school robotics team, I was able to use Scala.js and Akka-HTTP to build a web-based dashboard for viewing live sensor and control loop data, as well as running automated calibration routines. The simplicity of both Scala.js and Akka-HTTP made it easy to send data produced by simple functions to clients over a WebSocket and have clients render the data as it arrives.

A combination of Akka, Play Framework, and Scala.js built Ash, a home-automation system with easy extensibility. Modeling server and client portions as actors allowed for easy communication between them. Akka also became a unifying factor for working across a diverse set of hardware -- PCs, mobile devices, and Raspberry Pis

Connecting Reactive Applications with Fast Data Using Reactive Streams
Luc Bourlier
Senior Software Developper @Lightbend
Close
Connecting Reactive Applications with Fast Data Using Reactive Streams
Luc Bourlier
Senior Software Developper @Lightbend
Luc has been working on the JVM since 2002. First for IBM on the Eclipse project, in the Debugger team, where he wrote the expression evaluation engine. After a few other Eclipse projects, he went to TomTom, to recreate their data distribution platform for over-the-air services. He joined Lightbend in 2011, to work on the Eclipse plugin for Scala. And then switched to the Spark team, with a focus on deployment and interaction with other frameworks.
Tuesday (10th May.) 14:30
A reactive application doesn't live in isolation, it has to connect with the other components, and try to keep the whole system reactive.
Spark, as an element of a Fast Data architecture, is one of these components to connect to. With the addition of the back pressure support to Spark Streaming in Spark 1.5, and the other characteristics of Spark, it is simpler than before to fully integrate it in a reactive system.
 
This talk with describe the streaming model in Spark, its support of back pressure, and show, in a demo, how to use Reactive Streams to integrate Spark Streaming and a reactive application in a reactive system.
Perfect Scalability
Michael Nash
VP Capabilities @Lightbend
Close
Perfect Scalability
Michael Nash
VP Capabilities @Lightbend
For over thirty years, Michael has designed, developed, shipped and consulted on software development projects for clients of all shapes and sizes. As an advocate for software craftsmanship with expertise in project management and architecture, Michael was amongst the earliest of adopters of the Typesafe Stack, with over 5 years experience working with Scala, Akka and Spray.
Tuesday (10th May.) 14:30

One of the great benefits of the Lightbend ecosystem is its ability to empower great scalability, and it is often considered for this very reason.Indeed, if employed correctly, Scala, Akka and the rest can make it possible to much more easily write systems that scale up (and out) to extremes. However, not every design is able to scale, and the approach and architecture can sharply limit this option, no matter how good the tools. What does ""perfect scalability"" look like? Is there even such a thing? Can systems be designed to scale virtually without limit? Where does the pattern break down, and what can you do about it?

In this session, we will examine the practical architectural constraints on systems intended to scale up in near-linear fashion. It turns out that having the ability to scale to extreme load is more about what not to do than it is about what to do. Why do some system scale up and others don't? How can you take a design that has problems and refactor to a design that has fewer limits? Our teams encounter these problems every day, and we keep track of what works and what doesn't in the real world. What have we seen in the field? What proven real-world design and architecture approaches can we use to help ensure our systems can scale, and what should we avoid? How can we leverage the power of the Lightbend platform to architect such systems? Which parts for which kinds of problems? How does Akka and the actor model fit these patterns? How does Spark, Kafka, Akka streaming?

Highly scalable systems often put together tools such as Docker, Ansible, Salt, Mesos, ConductR with techniques such as microservices, monitoring, and continious delivery. Automation of the deploy pipeline and deep performance monitoring are essential parts of highly scalable systems - we will look at examples of such systems, and which of the tools in the stack they employ, and why. In this talk, we'll examine both the practices and the pitfalls, and what combinations we have used to scale not only within single clusters, but across data centers for continent-spanning applications where required.We will use use-cases all the way from massive IoT scale wearable devices all the way to high finance, and find the commonalities in the solutions that don't limit their own expansion. If your organization needs to take your scalability to significantly higher levels, this talk will be where you need to start.

Why The Free Monad Isn't Free
Kelley Robinson
Data Infrastructure Engineer @Sharethrough
Close
Why The Free Monad Isn't Free
Kelley Robinson
Data Infrastructure Engineer @Sharethrough
Kelley is a Scala developer at Sharethrough in San Francisco, building out data pipelines and infrastructure for the company's high volume, low latency ad serving platform. In her spare time, she enjoys testing new recipes and trying to keep her plants alive.
Tuesday (10th May.) 14:30
Scala developers love to discuss Monads, their metaphors, and their many use cases. Recognizing that monadic design and development patterns have their place, this talk will discuss the price of implementing the Free Monad in your code - spoiler alert - it's not free. We will define the Free Monad (without using complicated category theory!) and give you the confidence to know when it is and is not the answer in your code. We will also discuss some alternatives and their tradeoffs in maintainability, performance and design.

15:15 Break
15:40
The Future of Scala Performance on Big Data
Carlos Abad
Datacenter Software Engineer @Intel
Close
The Future of Scala Performance on Big Data
Carlos Abad
Datacenter Software Engineer @Intel
Carlos is the Scala Performance Lead Engineer at the Intel Big Data Performance Group. Previous speaking experience includes Spark Summit 2015 (substituting Eric Kaczmarek) . He has extensive experience with Scala, Spark, Hadoop, JVM performance optimization and characterization. Previously he was part of Intel Atom Architecture Group and held a Master degree in Computer Engineering from Columbia University.
Tuesday (10th May.) 15:40
Scala is the fastest expanding language in the datacenter, big data, and cloud computing. However the lack of standardized Big Data Scala benchmarks has hindered extended performance improvements related to the datacenter. In this talk we will present a newly developed Scala Big Data Benchmark based on learnings from TCPx-BB, SparkBench, and genomic (GATK/ADAM) workloads. We'll also introduce the most impacting big data-related performance improvements for Scala developed by our group.

Trading in Futures
Viktor Klang
Deputy CTO @Lightbend
Close
Trading in Futures
Viktor Klang
Deputy CTO @Lightbend
"Himself"
Tuesday (10th May.) 15:40
Scala Futures are one of the most, if not the most, used abstractions for dealing with asynchrony and concurrency in Scala. In this session we're going to go through what's new for Future in Scala 2.12 and how to take advantage of it, and discuss common pitfalls & useful programming patterns for dealing with Futures. The session may or may not also contain rants on designing primitives for concurrency control, spontaneous rebuttals of common criticisms around Futures, and extremely poor and nonsensical analogies.
Polymorphic Record Types in a Lifted Embedding
Stefan Zeiger
Lightbend
Close
Polymorphic Record Types in a Lifted Embedding
Stefan Zeiger
Lightbend

Stefan Zeiger is the tech lead for Slick. He joined Lightbend in 2011 after developing ScalaQuery, the predecessor to Slick, in order to work on the new project full-time. He has been a user of Java and the JVM platform professionally since 1996, working on a diverse range of projects from web servers to GUI frameworks and programming language design, and moving on from Java to Scala since 2008. He is a frequent speaker at Scala Days and other conferences.

Tuesday (10th May.) 15:40
This talk gives an overview of the "lifted embedding" at the core of the Scala DSL in Slick, Lightbend's relational database library. With standard Scala language features we can provide a DSL that allows you to work with database tables using a syntax similar to Scala collections. Of particular interest are abstractions for record types, such as tuples. While earlier versions of Slick had to get by with custom types for all tuple sizes to represent flat tuples of individual columns, the "Shape" abstraction paved the way for using standard Scala tuples in the DSL, with arbitrary nesting. The same abstraction is used to support Slick's own HList implementation, and with only a few lines of code, your own custom record types or other HList implementations. The core language feature behind this design is called "functional dependencies". It was added to Scala in release 2.8 to be able to implement the "CanBuildFrom" abstraction in the new collections framework.
Mastering Scala with IntelliJ IDEA
Alexander Podkhalyuzin
Mastering Scala with IntelliJ IDEA @JetBrains
Close
Mastering Scala with IntelliJ IDEA
Alexander Podkhalyuzin
Mastering Scala with IntelliJ IDEA @JetBrains

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

Tuesday (10th May.) 15:40

Why do developers love IntelliJ IDEA? Because it takes care of all the routine and provides intelligent coding assistance. Once you master it, the productivity gains are quite surprising. In this session I'll show you the 30 hidden gems of IntelliJ IDEA that will help you become a more productive Scala developer. 

16:25 Break
16:50
Full Stack Scala
Ramnivas Laddad
Founder of @Paya Labs
Close
Full Stack Scala
Ramnivas Laddad
Founder of @Paya Labs
Ramnivas is a technologist, author, and presenter who is passionate about doing software right. He has been leading innovation in Spring Framework and Cloud Foundry since their beginning. Ramnivas has led a group in Cloud Foundry and started the Spring Cloud project. Ramnivas is the author of AspectJ in Action (1st ed, 2nd ed), the best-selling book on aspect-oriented programming that has been lauded by industry experts for its presentation of practical and innovative approach to solve real-world problems. For the last few years, Ramnivas has been using Scala as his first choice language. He has spoken at many leading industry conferences including JavaOne, ScalaDays, JavaPolis, No Fluff Just Stuff, SpringOne, and O'Reilly OSCON.
Tuesday (10th May.) 16:50
Using Scala in the backend is a fairly uncontroversial idea. Using it in the frontend, however, is a new possibility with the advent of Scala.js. It brings a fresh set of possibilities in combating complexity along with a few new challenges. Modern single-page and mobile apps feature sophisticated functionality, intuitive user experience, and  the requirement of working across various browsers and devices. This leads to significant complexity in frontend development; it is not uncommon to spend the majority of development effort on the frontend.  For such apps, you need significant machinery to keep code and developers sane! Scala.js offers one such possibility by extending the benefits of Scala to the frontend. There is a movement in JavaScript land to embrace  immutability, functional programming, and type safety--something already available in Scala. Combining this trend with good interoperability support in Scala helps to leverage JavaScript libraries in Scala.js projects with reduced philosophical friction. With all these considerations, we decided to use Scala.js for frontend development for our startup. In this talk, I will talk about how this choice has served us and lessons learned in using Scala in every layer of the stack.
Transactional Event Sourcing Using Slick (Audit Log for Free!)
Adam Warski
CTO @SoftwareMill
Close
Transactional Event Sourcing Using Slick (Audit Log for Free!)
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
 
Tuesday (10th May.) 16:50
Event sourcing is a great alternative to traditional "CRUD"-type architectures. The central concept is a persistent stream of events, which drives all changes to the read model and running any kind of business logic. There’s a lot of technical and business benefits to such an approach, such as being able to re-create the state of the system at any point in time, or keeping a detailed *audit log* of all actions. Typically, implementations of event sourcing are presented using a NoSQL data storage, which is great for many use cases (e.g. using Akka Persistence + Cassandra). However, nothing stops us from using a relational database and SQL! In many applications (especially “enterprise”), this brings many benefits, such as powerful and familiar query capabilities and higher guarantees around data consistency. In this mainly live-coding talk we’ll see one way of implementing transactional event sourcing using the 'slick-eventsourcing' micro-framework, introducing the core concepts: command handlers, read model updates and event listeners, and how to use them to build an event-sourced application. We’ll see how Slick’s 'DBAction' and Scala flexibility makes it possible to provide an elegant DSL to build the system from simple functions with minimum dependencies.
Implementing Microservices with Scala and Akka
Vaughn Vernon
Consultant & Trainer @for {comprehension}
Close
Implementing Microservices with Scala and Akka
Vaughn Vernon
Consultant & Trainer @for {comprehension}

Vaughn Vernon is a veteran software craftsman and thought leader in simplifying software design and implementation. He has been programming since 1983, consults and speaks internationally, and has taught his Implementing Domain-Driven Design classes to hundreds of developers around the globe. Vaughn is the author of the 2015 best-seller "Reactive Messaging Patterns with Actor Model--Applications and Integration in Scala and Akka" and best-seller "Implementing Domain-Driven Design",? both published by Addison-Wesley.

Tuesday (10th May.) 16:50
What are microservices all about, and are they practical for your enterprise? How granular should a microservice be, and what approach should you use to determine the proper and appropriate boundaries between microservices? How can each microservice communicate with others in a distributed computing environment to correctly fulfill business objectives? How can my microservices adhere to the tenets of reactive software, being responsive, resilient, elastic, and message driven? Using Scala and Akka to implement microservices, this talk will demonstrate how you can implement microservices while answering all of the questions posed, and more. The talk will show you how to carefully craft microservices and to model the business domain within. You will experience advanced use of Akka throughout.
One Microservice is No Microservice - They Come in Systems
Markus Eisele
Developer Advocate @Red Hat
Close
One Microservice is No Microservice - They Come in Systems
Markus Eisele
Developer Advocate @Red Hat

Markus is a Developer Advocate at Red Hat and focuses on JBoss Middleware. He is working with Java EE servers from different vendors since more than 14 years and talks about his favorite topics around Java EE on conferences all over the world. He has been a principal consultant and worked with different customers on all kinds of Java EE related applications and solutions. Beside that he has always been a prolific blogger, writer and tech editor for different Java EE related books. He is an active member of the German DOAG e.V. and it's representative on the iJUG e.V. As a Java Champion and former ACE Director he is well known in the community.

Tuesday (10th May.) 16:50

Building a complete system out of individual Microservices is not as simple as we're being told. While Microservices-based Architecture continues to draw more and more attention we're also starting to learn about the trade-offs and drawbacks. Individual Microservices are fairly easy to understand and implement, but they only make sense as systems, and it is in-between the services that the most challenging (and interesting) problems arise—here we are entering the world of distributed systems.

As we all know, distributed systems are inherently complex and we enterprise developers have been spoiled by centralized servers for too long to easily understand what this really means. Just slicing an existing system into various REST services and wiring them back together again with synchronous protocols and traditional enterprise tools—designed for a monolithic architectures—will set you up for failure.

This talk is going to distill the essence Microservices-based systems and then introduce you to a new development approach to Microservices which gets you started quickly with a guided, minimalistic approach on your local machine and supports you every single step on the way to a productive scaled out Microservices-based system composed of hundreds of services. At the end of this talk, you've experienced first hand how creating systems of microservices on the JVM is dead-simple, intuitive, frictionless and last and more importantly—a lot of fun!

 

17:35 Break
18:00
@inline and @specialized - What Do They Do? Should I Be Using Them?
Chris Birchall
The Guardian
Close
@inline and @specialized - What Do They Do? Should I Be Using Them?
Chris Birchall
The Guardian
I am the tech lead for the Content Platforms team at the Guardian in London, working on the backend APIs that power theguardian.com. Before joining the Guardian, I worked for M3 in Tokyo.
 
I am the creator of the ScalaCache library (https://github.com/cb372/scalacache) and the author of Re-Engineering Legacy Software (https://www.manning.com/books/re-engineering-legacy-software).
Tuesday (10th May.) 18:00
You may have seen the @inline and @specialized annotations used in Scala code, and have some idea that they are added for performance reasons. But the exact details of what they do is not widely known, and it's hard to estimate whether they will provide a real performance benefit to your code.
 
This talk will: explain exactly what the annotations do; provide some examples of how to use them; and use benchmarks to explore how they affect performance.
 
There will also be honourable mentions for some of the more esoteric Scala annotations such as @elidable, @strictfp, @switch and @varargs.
Microservices based off Akka cluster at iHeartRadio
Kailuo Wang
Lead Developer @iHeartRadio
Close
Microservices based off Akka cluster at iHeartRadio
Kailuo Wang
Lead Developer @iHeartRadio
I am a software engineer who is passionate about software craftsmanship, contributing to open source softwares and AI. Outside of software, I enjoy photography, music (mostly J.S. Bach), taking MOOCs and spending time with my 2 year old daughter. 
 
Tuesday (10th May.) 18:00
A talk with two main agenda items:
  1. how we came to the decision of basing our microservices off Akka cluster, and
  2. how we implemented this microservice platform - architecture, tips, lessons learned, and a couple of open source libraries we released to facilitate microservice development with Akka cluster, including a piece of reactive feature we contributed to the Akka core.
Dotty support in IntelliJ IDEA
Andrew Kozlov
JetBrains
Close
Dotty support in IntelliJ IDEA
Andrew Kozlov
JetBrains
As well as experience in software engineering and participating in several conferences I have 5 years of experience in teaching (math and programming courses for high school and university students, but mostly in russian).
Tuesday (10th May.) 18:00
The purpose of this talk is to introduce one to differences between Scala and Dotty, as well as to support for Dotty in Scala plugin for IntelliJ IDEA. First of all we will look at the differences between the type systems. Besides that one will learn which aspects of language support in IntelliJ IDEA have already been implemented or will be implemented in the near future. Among other things the talk will cover the build process of the project, the incremental compilation.
Everything You Always Wanted to Know About Pattern Matching* (*But Were Afraid to Ask)
Lutz Huehnken
Solutions Architect @Lightbend
Close
Everything You Always Wanted to Know About Pattern Matching* (*But Were Afraid to Ask)
Lutz Huehnken
Solutions Architect @Lightbend

Lutz is a Solutions Architect at Lightbend. He has worked in professional software development since 1997 and successfully deployed major web applications for clients in different fields (retail, logistics, hospitality, finance). His current focus is on the development of reactive applications – responsive, scalable, resilient systems – with Scala, Akka and Play.

Tuesday (10th May.) 18:00
Pattern Matching is a great and very popular feature in Scala - yet many are quite unsure about how it works exactly. What can I match on? How efficient is it? What do case classes have to do with it? What's an extractor? What's the deal with unapply and unapplySeq? And what exactly is the role of "::" or "+:" when matching sequences? If I build my own extractors, what exactly goes in, what comes out? This is an entry level talk for developers who'd like to look "under the hood" of pattern matching, and who haven't written their own extractors yet. 
18:45
Community Party: Sponsored by Lightbend
Close
Community Party: Sponsored by Lightbend
Tuesday (10th May.) 18:45
Wednesday (11th May.)
08:00 Registration
09:00
Spark 2.0
Matei Zaharia
Creator of Apache Spark & Assistant Professor of Computer Science @MIT
Close
Spark 2.0
Matei Zaharia
Creator of Apache Spark & Assistant Professor of Computer Science @MIT

Matei Zaharia is an assistant professor of computer science at MIT and CTO of Databricks, the company commercializing Apache Spark. He started the Spark project while he was a PhD student and serves as its Vice President at Apache. Matei has also contributed to other open source projects including Apache Hadoop and Mesos, where he is a committer. He received the 2014 ACM Doctoral Dissertation Award in recognition for his research.

Wednesday (11th May.) 09:00
Apache Spark is one of the largest Scala projects, as well as the most active open source project in big data processing. It was one of the first systems to provide a functional API in Scala and automatically distribute the work over clusters, simplifying distributed programming. In this keynote, I'll talk about how Spark's API has evolved since the first version, and in particular about new APIs in the soon to be released Spark 2.0. The largest additions have been to make the API more declarative, allowing richer automatic optimizations, and to provide a stronger link between Scala data types and a binary data format, enabling memory- and CPU-efficient processing. These ideas may be relevant to other high-performance libraries in Scala.
10:00 Break
ROOM Stage 1 Stage 3 Stage 2 Stage 4
TRACK
Track 1 - Intermediate Wednesday
Track 2 - Intermediate Wednesday
Track 3 - Advanced Wednesday
Track 4 - Beginner Wednesday
10:25
Scala.js: Beyond the Coast-to-Coast Approach
Katrin Shechtman
Senior Software Engineer @Lightbend
Close
Scala.js: Beyond the Coast-to-Coast Approach
Katrin Shechtman
Senior Software Engineer @Lightbend
Katrin has been a Scala functional junkie since 2012 and is daily using Scala at Lightbend. She spends too much free time on unsolicited coding and is a proud Torontonian Scala fighter and co-organizer of Toronto Scala meetup.
Wednesday (11th May.) 10:25
A 'taking to production' experience based talk about Scala.js, specifically tailored for Scala folks with chronic Javascript pain. People with and without Scala.js knowledge are equally invited. What to expect? Quick yet concise overview of moving Scala.js parts following by presentation of non coast-to-coast approach to Scala.js. Still not convinced to come to the talk? How about:

Spoiler #0: There will be no preaching to the choir. Huh? No slides about Javascript vs Scala. We all know the answer, aren't we?
Spoiler #1: Overview will be based on perks of Scala.js cross project. Crossbuilding knowledge is a power, you will see.
Spoiler #2: There is a strong presumption that a number of your frontend teammates willing to move to Scala.js is 0. You tell me if I'm wrong, I show you how ""my way or the highway"" is not your only Scala.js option.
Spoiler #3: It all will start making sense. See you on scala-js gitter.
Implicits Inspected and Explained
Tim Soethout
Software Platform Engineer @ING Bank
Close
Implicits Inspected and Explained
Tim Soethout
Software Platform Engineer @ING Bank

Tim Soethout is a functional programming purist in any language. During his studies, he worked a lot in Haskell using the concepts of Functional Programming. In the enterprise world, Scala is his next interest since it is an ideal mix of mainstream programming and function programming. As a true developer, he does not want to do things twice; automation is key. Lately, he has been focussing on making Scala accessible for everyone inside the enterprise by making sure all road bumps, such as training, tooling and support, are taken care of.

Wednesday (11th May.) 10:25

At the keynote at Scala Exchange, Jessica Kerr mentioned that there is very much documentation for starting and expert Scala developers but (almost) nothing in between. In this talk I want to demystify implicits. Implicits are a fairly advanced feature and a very important aspect of the Scala language. They help with writing concise code and enable lots of DSLs. On the other side, they can be very magical for an untrained eye. In this talk, we will delve into idiomatic use cases of implicits and how the Scala compiler resolves them. If time allows, we will jump into type classes as well.

Large scale graph analysis using Scala and Akka
Ben Fonarov
Full Stack Tech Lead/Sr. Manager @Capital One
Close
Large scale graph analysis using Scala and Akka
Ben Fonarov
Full Stack Tech Lead/Sr. Manager @Capital One

Ben has been full-stacking for at least 9 years. Started programming at 13 with mIRC scripts and went on to C, C++, PHP, Python, JavaScript and more recently Scala. Having built everything from SSO implementations to recommendation systems, Ben is currently focused on designing and creating bleeding-edge distributed and scalable data systems at Capital One. Contributor to several open source projects (e.g MediaWiki, Sails.js, activitystreams) he is now digging in deeper with Scala and Akka and loving every minute of it.

 

Wednesday (11th May.) 10:25

In this talk we will go over the architecture and implementation of a large-scale graph analysis engine using Scala, Akka and Hbase. Starting from the needs that led to this type of processing, we’ll go through the different implementation considerations, jump into an implementation that includes a query parser and an akka cluster to do the processing, and then see how we can produce a stream output of the results. This talk could benefit anyone that is interested in Scala, Akka, Big Data, stream processing and of course graphs.

Description

Big data and fast data are definitely the buzz words of the last couple of years, but they’re telling us something – people want to get insights out of large amounts of data, whether it’s moving (""fast"") or static. In many companies, and such is the case at Capital One, the basis for generating these insights is data analysis and model building, which requires the ability to get to the data easily.

Getting the data easily is a major pain point, especially at large enterprises – Imagine, what if you needed to integrate massive amounts of data across hundreds or thousands of different sources and then deliver that data in a variety of formats and in a specific “schema”? Add to that, what if that “schema” can change on a whim based on the needs of the business?

That’s where Scala, Akka and graphs come in, and specifically their use for integrating data, sourced from multiple locations, and then delivering that integrated data for analysis via queries, APIs and other interfaces in a distributed, stream based and highly efficient manner.

This talk will start by presenting the need, and then go through an in-depth look at how we took Scala and Akka (Cluster, Remote, Persistence), along with Spark, Kafka, Hbase and other tools to create a graph analysis engine (database) that provides a self-service data computation and delivery platform at Capital One.

Nightmare Before Best Practices
José Castro
Chief Evangelist @Codacy
Close
Nightmare Before Best Practices
José Castro
Chief Evangelist @Codacy
Technology Evangelist by day, Evil Magician by night, José actually comes from the Perl world (but he comes in peace).
 
He enjoys being on stage and has a passion for close-up magic and card cheating; feel free to ask him for a demonstration of any or both; he’ll either show you a miracle or why you should never play cards with people you don't know.
 
José works at the evangelism team at Codacy, an Automated Code Review platform.
Wednesday (11th May.) 10:25

A collection of horror stories that derive from a lack of best practices. Everything will be covered: How to make companies lose money, shutdown systems and disable payments (or worse) just from overlooking simple procedures that "take too much time" or "cost too much" to implement. We may even dim the lights at certain points in the presentation.

11:10 Break
11:35
Finagle Under the Hood
Vladimir Kostyukov
Software Engineer @Twitter, Inc
Close
Finagle Under the Hood
Vladimir Kostyukov
Software Engineer @Twitter, Inc

Vladimir started his software engineering career working on compilers and virtual machines at Intel. After several years of writing C++, he decided to switch camps and joined the Finagle team at Twitter. Today, Vladimir is an active member of the Scala community, where he is known as an author of several open source projects (e.g. Finch, Scalacaster), blog posts and talks.

Wednesday (11th May.) 11:35

Finagle is an extensible RPC system for JVM written in Scala that is used and developed at Twitter. It promotes a programming model where servers and clients might be viewed as functions, which are both easy to compose and reason about. Although, there is quite a complex logic (connection pooling, load balancing, circuit breaking and so on) hidden behind those functions. In this talk, we'll dig into Finagle internals and carefully walk through each of its modules to see what happens when we a) send a request to a Finagle client b) receive a request by a Finagle server.

 

Data in Motion: Streaming Static Data Efficiently in Akka Persistence
Martin Zapletal
Cake Solutions Inc.
Close
Data in Motion: Streaming Static Data Efficiently in Akka Persistence
Martin Zapletal
Cake Solutions Inc.

Martin is heading up Cake Solutions technical team in the US and is Apache Spark and Cassandra plugin for Akka Persistence contributor. 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.

Wednesday (11th May.) 11:35

Processing streaming data is becoming increasingly important in many areas. Scala and the Lightbend Reactive platform offer multiple solutions for processing streaming data, including Akka, Akka Streams and Apache Spark. This talk introduces the advantages and concepts of streaming data processing. It will mention differences between static data and data in motion and their usage as streaming data sources. The main goal of the presentation is detailed discussion of Akka Persistence Query and implementation of the stream production specification in Cassandra plugin for Akka Persistence (akka-persistence-cassandra) that the author participated in. Focus is on architecture and design considerations, implementation details, performance tuning and distributed system specifics such as correctness, efficiency, consistency, order, causality or failure scenario handling that are inherently part of the solution and apply to wide variety of distributed systems. Finally, other improvements to the Cassandra plugin for Akka Persistence project such as reusing the stream generation for non blocking asynchronous Akka Persistence recovery as well as application of the project and the discussed concepts to build modern reactive enterprise stream processing and asynchronous messaging distributed applications are presented.

Domain Driven Design and Onion Architecture in Scala
Wade Waldron
Senior Software Developer @Lightbend
Close
Domain Driven Design and Onion Architecture in Scala
Wade Waldron
Senior Software Developer @Lightbend

I have been a Software Developer for 11 years. I have been developing in Scala for five years and I am a Lightbend Certified trainer.

Wednesday (11th May.) 11:35

Domain Driven Design has been a game changer in my career.  Combined with Onion Architecture it has made improvements to my code, in both readability and maintainability.

Scala is ideally suited to Domain Driven Design.  Case classes and traits allow us to rapidly prototype a domain.  We can iterate over that domain quickly as we build. This makes it trivial to specify a rich description of a domain with very little code, and minimal investment of time.

Onion Architecture provides us with the tools needed to create clean package structures. It provides a framework for creating the abstraction layers to allow your code to be portable, testable, and easier to maintain.

In this code-driven talk, I will explore the techniques I developed while using Domain Driven Design and Onion Architecture in Scala.  I will discuss key features such as Repositories, Services, Aggregates, Bounded Contexts and more. I will explore how Onion Architecture can be used with Domain Driven Design to build up applications in fully portable layers.

The Structure of Programming Revolutions
Noel Welsh
Partner @Underscore
Close
The Structure of Programming Revolutions
Noel Welsh
Partner @Underscore

Noel has been using Scala for some six years and functional programming for about 15 years. He teaches Scala, helps teams adopt Scala successfully, writes books about Scala, and is an experience conference speaker.

Wednesday (11th May.) 11:35

What does it mean to think like a functional programmer? Why is it so hard to adopt functional programming if you are steeped in OO? In this talk, I'll address these questions, using ideas from the philosophy of science. The talk will give new insight into the process of becoming productive in Scala and the mindset needed to aid this process. Using the framework of "The Structure of Scientific Revolutions", we can see programming as undergoing three revolutions: Structured programming, object-oriented programming, and now, functional programming. Each revolution brings with a new paradigm - basic assumptions and values that make moving across paradigms difficult to achieve. In this talk, I'll describe the paradigm of the functional programmer: What is valued and what is considered good code. I will contrast this to the paradigm of the object-oriented programmer and finally consider if it is possible to reconcile these two approaches to programming.

12:20 Lunch
13:20
The Zen of Akka
Konrad Malawski
Akka dev. @Lightbend
Close
The Zen of Akka
Konrad Malawski
Akka dev. @Lightbend

Konrad is a late-night passionate dev living by the motto "Life is Study!". His favourite discussion topics range from distributed systems to capybaras. He has founded and run multiple user groups (Java, Scala, Computer Science, ...), and is part of program committees of awesome conferences such as GeeCON and JavaOne SF. Other than that, he's a frequent speaker on distributed systems and concurrency topics at conferences all around the world. In those rare times he's not coding, he spreads the joy of computer science by helping local user groups and whitepaper reading clubs. He also holds number of titles, the most fun of which being Java One RockStar 2015.

Wednesday (11th May.) 13:20

In order to be successful with asynchronous / reactive programming, when coming from synchronous execution models, you need to change your mindset and look at things from a slightly different perspective. In order to use Akka at it's best, you will have to change the way you think about application design (loosen coupling in space and time between components), and re-think what you've maybe learnt in the past. In this talk we uncover a number of rules that serve as a guide in designing concurrent distributed applications, how those apply to Akka and how they can help you in daily app development.

better-files: Towards a safe, sane I/O library in Scala
Pathikrit Bhowmick
Principal Engineer @Coatue Management
Close
better-files: Towards a safe, sane I/O library in Scala
Pathikrit Bhowmick
Principal Engineer @Coatue Management
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.
Wednesday (11th May.) 13:20

Doing I/O in Scala (and Java) involves either invoking some magic "FileUtil" or browsing through StackOverflow. In this talk, we will introduce better-files (https://github.com/pathikrit/better-files) - a thin wrapper around Java NIO to enable simple, safe and sane I/O in Scala. We will also discuss problems with designing an I/O library that would make everyone happy and different schools of thoughts e.g. monadic vs non-blocking vs effect-based APIs

Scala Goes Native
Denys Shabalin
EPFL
Close
Scala Goes Native
Denys Shabalin
EPFL

Denys is a research assistant at LAMP/EPFL, and has previously worked on off-heap memory, quasiquotes and macros for Scala.

Wednesday (11th May.) 13:20

Scala has historically been a JVM-centric programming language. The situation has started to change with appearance of the Scala.js that opened a door of front-end development to Scala programmers. This talk will expand the horizons of Scala even more. We’re going to announce a new ahead-of-time compiler and lightweight managed runtime designed specifically for Scala.

Distributed Real-Time Stream Processing: Why and How
Petr Zapletal
Cake Solutions Inc.
Close
Distributed Real-Time Stream Processing: Why and How
Petr Zapletal
Cake Solutions Inc.

Petr is a Software Engineer who specialises 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, he has worked for various companies from start-ups to large international corporations. Technically, Petr is SMACK (Spark, Mesos, Akka, Cassandra, Kafka) evangelist, enjoys working with Akka, and has deep knowledge of toolkit’s features. Petr is also certified Spark Developer.

Wednesday (11th May.) 13:20

In this talk, we are going to discuss various state of the art open-source distributed streaming frameworks, their similarities and differences, implementation trade-offs, their intended use-cases, and how to choose between them. I’m going to focus on the popular frameworks including Spark Streaming, Storm, Samza and Flink. In addition, I'll cover theoretical introduction, common pitfalls, popular architectures and many more.

The demand for stream processing is increasing. Immense amounts of data has to be processed fast from a rapidly growing set of disparate data sources. This pushes the limits of traditional data processing infrastructures. These stream-based applications include trading, social networks, Internet of things or system monitoring, are becoming more and more important. A number of powerful, easy-to-use open source platforms have emerged to address this. My goal is to provide comprehensive overview about modern streaming solutions and to help fellow developers with picking the best possible decision for their particular use-case. This talk should be interesting for anyone who is thinking about, implementing, or have already deployed streaming solution.

14:05 Break
14:30
Async Testing on the JVM and Scala.js
Bill Venners
President @Artima, Inc.
Close
Async Testing on the JVM and Scala.js
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.

Wednesday (11th May.) 14:30

In ScalaTest 3.0's new async testing styles, tests have a result type of Future[Assertion]. Instead of blocking until a future completes, then performing assertions on the result, you map assertions onto the future and return the resulting Future[Assertion] to ScalaTest. The test will complete asynchronously when the Future[Assertion] completes. This non-blocking way of testing requires a very different mindset and different API. In this talk, Bill Venners will show you how async testing was integrated into ScalaTest and explain what motivated the design decisions. He'll show you how to use the new features, and suggest best practices for async testing on both the JVM and Scala.js.

So, You Want to "Do Big Data?"
Jan Machacek
CTO @Cake Solutions
Close
So, You Want to "Do Big Data?"
Jan Machacek
CTO @Cake Solutions

Jan is a passionate technologist with hands-on experience with the practical aspects of software delivery (architecture, quality, CI, CD); the project management approaches (applying the principles of agile project management) and mentoring and motivating the engineering and business teams. He shares his expertise and passion for software as the editor of the Open Source Journal, regularly contributes to open source projects, and speaks at conferences in the UK and abroad. Jan is likewise the author of many open source projects (various Typesafe Activators, Reactive Monitor, Akka Patterns, Akka Extras, Scalad, Specs2 Spring and others), books and articles.

Wednesday (11th May.) 14:30

Jan's talk will give overview of the major components in a ML connected fitness system built on the Lightbend platform. Jan will then show the most exciting aspects of the Akka and Spark code: The Akka cluster and CQRS to handle the volume of users; the Spark code to compute the models for the users. Naturally, the talk will include the infrastructure code for continuous deployment and monitoring of the entire system. As usual, expect a nerve-wracking live demos! Jan closes with lessons learnt in maintaining and evolving the system, helping you avoid the typical pitfalls in Akka & Spark systems, and hopefully motivating you to "have a go" at designing and implementing similarly complex systems yourselves!

The Things Scala.js Does to Make Your Code Fast
Sébastien Doeraene
Ph.D. student @EPFL
Close
The Things Scala.js Does to Make Your Code Fast
Sébastien Doeraene
Ph.D. student @EPFL
Sébastien Doeraene is a compiler/runtime systems hacker, and the author of Scala.js. He is a Ph.D. student at EPFL in the programming methods laboratory (LAMP) led by Martin Odersky, also known as the Scala team. He holds bachelor and master degrees in computer science engineering from Université Catholique de Louvain in Belgium. When he is not busy coding, he sings in choirs and a cappella groups, or rides around on a unicycle.
Wednesday (11th May.) 14:30
One of the strengths of Scala.js is its run-time performance. Compiled Scala.js programs typically run on par with equivalent, hand-written JavaScript code. To achieve this, Scala.js features an advanced optimizer. In this talk, we will explore some typical Scala.js code snippets, and see what the optimizer makes of them. In the process, we will give insights about the code patterns that it can optimize away, as well as things it cannot (yet) eliminate. Attendees will take away keys to write efficient Scala.js code. In particular, we will see that idiomatic Scala code is not to be feared (e.g., for loops, or maps/filters). Attendees are expected to be familiar with Scala (not necessarily Scala.js) and to be able to read JavaScript. No compiler knowledge is required; we will stay at the source code level, showing what the optimizer does without explaining how.
Being Creative with Genetic Algorithms and Typeclasses
Noel Markham
Senior Developer @47 Degrees
Close
Being Creative with Genetic Algorithms and Typeclasses
Noel Markham
Senior Developer @47 Degrees

Noel started out as a Java developer in finance before moving to functional programming in startups for both games and social media. More recently, he has worked in broadcast media, and is currently working in London at 47 Degrees.

Wednesday (11th May.) 14:30

Typeclasses are a hidden gem of the Scala language. They provide an immense power not seen in imperative languages, and so their approach might be unusual or alien to those approaching Scala from an imperative background. I will show how typeclasses allow developers to effectively attach their own interfaces to code written by others. In this talk, I describe what a genetic algorithm is and provide an example implementation in Scala. Using this implementation, I will demonstrate how to define a specific typeclass for our problem. I will then derive several different implementations, showing how to get rock solid confidence in testing our algorithm - with the help of ScalaCheck - and then provide a completely different typeclass to provide a fun, visual and creative solution, illustrating the iterations and improvements as the genetic algorithm’s fitness function runs. The talk will be particularly hands-on, with plenty of examples run directly from the REPL.

15:15 Break
15:40
Deep Learning and NLP with Spark
Andy Petrella
Co-Founder @Data Fellas
Close
Deep Learning and NLP with Spark
Andy Petrella
Co-Founder @Data Fellas
Andy is a mathematician turned into a distributed computing entrepreneur.
Besides being a Scala/Spark trainer. Andy also participated in many projects built using spark, cassandra, and other distributed technologies, in various fields including Geospatial, IoT, Automotive and Smart cities projects.
He is the creator of the Spark Notebook (https://github.com/andypetrella/spark-notebook), the only reactive and fully Scala notebook for Apache Spark.
In 2015, Xavier Tordoir and Andy founded Data Fellas:
  • the Agile Data Science Toolkit, Shar3;
  • the Distributed Genomics product, Med@Scale.
Andy is also member of program committee of the O’Reilly Strata, Scala eXchange and Data Science eXchange and Devoxx events
Wednesday (11th May.) 15:40

Deep Learning is taking data science by storm. Unfortunately, most existing solutions aren’t particularly scalable.In this talk, Andy will show how to easily implement a Spark­ ready version one of the most complex deep learning models, the Long Short­ Term Memory (LSTM) neural network, widely used in the hardest natural language processing and understanding problems, such as automatic summarization, machine translation, question answering and discourse. He also shows an LSTM demo with interactive, real­time visualizations using the Spark Notebook and Spark Streaming.

Reducing Microservice Complexity with Kafka and Reactive Streams
Jim Riecken
Senior Software Developer @Hootsuite
Close
Reducing Microservice Complexity with Kafka and Reactive Streams
Jim Riecken
Senior Software Developer @Hootsuite

Jim is a Senior Software Developer on the Platform team at Hootsuite and has been writing distributed web applications in Scala for several years (and Java for many years prior). Outside of building Hootsuite’s back-end services, he loves cycling and playing music.

Wednesday (11th May.) 15:40

Transitioning from a monolithic application to a set of microservices can help increase performance and scalability, but it can also drastically increase complexity. Layers of inter-service network calls for add latency and an increasing risk of failure where previously only local function calls existed. In this talk, I'll speak about how to tame this complexity using Apache Kafka and Reactive Streams to:
- Extract non-critical processing from the critical path of your application to reduce request latency
- Provide back-pressure to handle both slow and fast producers/consumers
- Maintain high availability, high performance, and reliable messaging
- Evolve message payloads while maintaining backwards and forwards compatibility.

Metaprogramming 2.0
Eugene Burmako
Research Assistant @EPFL
Close
Metaprogramming 2.0
Eugene Burmako
Research Assistant @EPFL
Programming languages enthusiast, PhD student at EPFL, member of Scala team, Scala macros guy.
Wednesday (11th May.) 15:40
The story of better metaprogramming in Scala has started in early 2013, after we released macros 1.0 and got initial feedback from early adopters. This talk will provide an illustrated guide through the history of the improvements that we did and are planning to do to metaprogramming. We will see what worked, what didn't, and what we're excited about for the future of macros in scala.meta and Dotty.

Using Actors for the Internet of (Lego) Trains
Johan Janssen
Architect @Info Support
Close
Using Actors for the Internet of (Lego) Trains
Johan Janssen
Architect @Info Support

Johan is working as a Java architect and competence center Java lead at Info Support. He has been working for various demanding companies where rapidly delivering quality software was very important. Currently, he is working in a DevOps team in a big financial institution in The Netherlands as a Java architect. He likes sharing his knowledge about Java, continuous delivery, DevOps, software quality, and numerous other subjects. Johan regularly writes articles and gives presentations about those subject for instance at JavaOne, Devoxx, J-Fall, JavaLand, JBCNConf, Java Forum Nord, Coding Serbia, JavaCro and ConFESS.

Wednesday (11th May.) 15:40

Normally, we use Java or Scala to build applications for large organizations running on servers. We wanted to find out if we could use the same languages and tools on IoT hardware. We also wanted to investigate whether or not (remote) actors could replace REST endpoints. The Lego trains are equipped with a Raspberry Pi, camera, wireless dongle, infrared transmitter, speaker, RFID reader, and battery pack. Next to that, we have automated switch tracks a Lego Ferris Wheel and camera's again with the help of Raspberry Pi's. We also built some lightning effects with LEDs controlled by Particle Photon’s. To control the trains and other parts, we built a remote actor based application with Scala, Akka, Akka HTTP and AngularJS. We will show you when and how to use Akka HTTP and remote actors. We will also show the results of the performance tests we did to compare the two options. Next to that we will talk about our experiences and challenges and of course we will give a live demo!

16:25 Break
16:40
Closing panel moderated by Adriaan Moors
Stefan Zeiger
Lightbend
Seth Tisue
Lightbend
Adriaan Moors
Lightbend
Sébastien Doeraene
Ph.D. student @EPFL
Heather Miller
Executive Director of the Scala Center, Research Scientist at EPFL
Eugene Burmako
Research Assistant @EPFL
Close
Closing panel moderated by Adriaan Moors
Stefan Zeiger
Lightbend

Stefan Zeiger is the tech lead for Slick. He joined Lightbend in 2011 after developing ScalaQuery, the predecessor to Slick, in order to work on the new project full-time. He has been a user of Java and the JVM platform professionally since 1996, working on a diverse range of projects from web servers to GUI frameworks and programming language design, and moving on from Java to Scala since 2008. He is a frequent speaker at Scala Days 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.
Adriaan Moors
Lightbend
Sébastien Doeraene
Ph.D. student @EPFL
Sébastien Doeraene is a compiler/runtime systems hacker, and the author of Scala.js. He is a Ph.D. student at EPFL in the programming methods laboratory (LAMP) led by Martin Odersky, also known as the Scala team. He holds bachelor and master degrees in computer science engineering from Université Catholique de Louvain in Belgium. When he is not busy coding, he sings in choirs and a cappella groups, or rides around on a unicycle.
Heather Miller
Executive Director of the Scala Center, Research Scientist at EPFL
Heather Miller is a PhD student in Martin's group and regularly give talks at industrial conferences like Strange Loop, and academic conferences like OOPSLA and ECOOP.
Eugene Burmako
Research Assistant @EPFL
Programming languages enthusiast, PhD student at EPFL, member of Scala team, Scala macros guy.
Wednesday (11th May.) 16:40
Welcome to the traditional Scala Days Closing panel AMA with some of the core Scala committers and community leaders!

Conference

New World Stages

340 West 50th Street

New York, NY 10019 

Website Map

Training

AMA Executive Conference Center New York

1601 Broadway

New York, NY 10019

Website Map

Training

Want to get the most out of Scala Days New York? Register for an in-person training course after the Scala Days conference. All trainings are two-day trainings and will take place Thursday and Friday May 12-13, 2016, 9 am - 5 pm both days. The courses are designed for developers of all levels of proficiency with the Lightbend Reactive Platform.

 

All trainings will take place at: 

AMA Executive Conference Center New York

1601 Broadway

New York, NY 10019

Registration is closed because the conference is sold out. Still seats left for "Fast track to Akka with Scala" and "Advanced Scala". Register for training by writing an email to scaladays@trifork.com

Fast track to Akka with Scala (3 seats left)

Please contact scaladays@trifork.com if you want to attend this training


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

 

Prerequisites

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

After having participated in this course you should

  • know how to design scalable and fault-tolerant applications using Akka's actors
  • know how to configure, test and tune Akka applications
  • know best practices for designing asynchronous, event-driven systems using Akka
  • be confident to start using Akka in production systems 


Trainer: Katrin Shechtman

Katrin has been a Scala functional junkie since 2012 and is daily using Scala and Akka at Lightbend. She spends too much free time on unsolicited coding and is a proud Torontonian Scala fighter and co-organizer of Toronto Scala meet up.

Advanced Scala (2 seats left)

Please contact scaladays@trifork.com if you want to attend this training


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

 
Objectives
After having participated in this course you should:
  • Understand all aspects of the object-functional approach
  • Know and be able to apply advanced features of Scala's type system
  • Fully understand implicits and type classes
  • Be confident about creating libraries and DSLs with Scala
 
Audience
Application or library developers wishing to master Scala
 
Prerequisites
Students taking this course should have:
  • Full understanding of all concepts taught in Fast Track to Scala
  • At least 2 months of full-time hands-on development with Scala
  • Setup Requirements
 
To complete the exercises in this course, students need to install the following before class:

 
Trainer: Patrick Premont & Alejandro Lujan Toro

As a Functional Programming Architect at Lightbend, Patrick architects and develops software using the functional programming paradigm. He specializes in Scala, game development and AI.

As a Senior Software Developer & Training Lead at Lightbend, Alex splits his time between architecting and building web-based software using the Lightbend Stack: Scala, Akka and Play, and coaching others on how to effectively use those techologies. With a rare combination of both technical and business expertise, Alex has the ability to build extraordinary software the effectively meets the core business needs of our clients. Add to that his incredible people skills, Alex not only builds usable and functional software, but excels at training others to adopt the Lightbend Stack.

Apache Spark Workshop (SOLD OUT)

Please contact scaladays@trifork.com if you want to be on the waiting list for this training course


This two-day course is designed to teach developers how to implement data processing pipelines and analytics using Apache Spark. Developers will use hands-on exercises to learn the Spark Core, SQL/DataFrame, Streaming, and MLlib (machine learning) APIs. Developers will also learn about Spark internals and tips for improving application performance. Additional coverage includes integration with Mesos, Hadoop, and Reactive frameworks like Akka.

 

Objectives

After having participated in this course you should:

  • Understand how to use the Spark Scala APIs to implement various data analytics algorithms for offline (batch-mode) and event-streaming applications
  • Understand Spark internals
  • Understand Spark performance considerations
  • Understand how to test and deploy Spark applications
  • Understand the basics of integrating Spark with Mesos, Hadoop, and Akka

 

Audience

Developers wishing to learn how to write data-centric applications using Spark.

 

Prerequisite

  • Experience with Scala, such as completion of Fast Track to Scala course
  • Experience with SQL, machine learning, and other Big Data tools will be helpful, but not required.

 

Setup Requirements


Trainier: Petro Verkhogliad & Long Tran

Petro Vekhogliad is a certified instructor for Spark Workshop, and works at Lightbend as a software developer. He holds a MSc in Computer Science. Petro is passionate about functional programing and applications of AI.

Long has been programming and fiddling with code for about 20 years, ever since his Dad bought him an x386. The idea that he could write code to do real-world work, instead of just playing SimCity, sparked his young imagination. One of his first programs he built was a QBasic script to calculate the expected wages from his paper route.

Advanced Akka With Scala (SOLD OUT)

Please contact scaladays@trifork.com if you want to attend this training


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

 

Prerequisites

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

 

After having participated in this course you should

  • know how to use Akka's remoting and clustering features
  • understand how to integrate 3rd party systems
  • know how to create a RESTful HTTP layer
  • be confident to start using Akka on large scale

Trainer
: Wade Waldron & Michael Nash

With a Bachelor of Computer Science and Honours in Software Engineering from the University of Saskatchewan, Wade has spent the last 9 years building rock solid software and games, with a strong focus on test driven design, domain driven design, service oriented architecture, event driven architecture and agile development. Wade strives to be more than just another software developer. He is a strong believer is software craftsmanship, and his commitment to code readability and maintainability shines though in his work. He is also the author of a recently published book, Applied Akka Patterns.

For over thirty years, Michael has designed, developed, shipped and consulted on software development projects for clients of all shapes and sizes. As an advocate for software craftsmanship with expertise in project management and architecture, Michael was amongst the earliest of adopters of the Lightbend Reactive Platform, with over 5 years experience working with Scala, Akka and Spray. His wealth of knowledge, experience and unrelenting passion for software development makes him an extremely valuable trainer.

Tickets


Scala Days New York is SOLD OUT. Sign up for the waiting list 

 

Conference (2.5 days)

Before Jan 20 Before Mar 16 After Mar 16
$950  $1050 $1150

Conference + 2 training days (4.5 days)

Before Jan 20 Before Mar 16 After Mar 16
$2,100 $2,450 $2,600

2 Training day only

Before Jan 20 Before Mar 16 After Mar 16
$1,250 $1,500 $1,550

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 New York you can book and receive a discounted and price match guarantee Scala Days conference rate clicking "book hotel" below. 
 

Sponsors

Interested in being a sponsor at Scala Days New York? Contact Geeta Schmidt.

 

Platinum

 

 

Gold

 

  

Silver

Media Sponsors

Produced by

Code of Conduct

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

 

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

 

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

 

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

 

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

Crew Volunteers

 

Thank you very much for your interest in being a crew volunteer at Scala Days New York, but we now have all the volunteer crew we need.

You can sign up on our waitlist by writing an email to Dajana Guenther