Dave Gurnell Adventures in Meta-Programming

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 each technique, where they become appropriate, and when 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, however, the code becomes verbose or unwieldy, and we search for ways to make our code cleaner and more maintainable. “Meta-programming” is a broad term describing techniques for generating code using code, but the meta programming techniques listed above could not be more different. Sometimes, being able to identify the correct technique may save hours of frustration attempting to go down blind alleys. This is the problem we are trying to 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.

Andrea Lattuada Typeclasses — a type system construct

Typeclasses are widely in use on advanced Scala code and yet they are not a first class citizen of the language. This talk will introduce the concept of typeclasses from the ground up by looking at languages such as Haskell and Rust.

Typeclass coherence (multiple instances of the same typeclass for the same type), effective namespacing and implicit resolution (in Scala) are some of the challenges that arise for extensive usage of this concept and language feature. We'll explore those issues and how to apply the learnings from other languages to improve the readability and usability of typeclasses in Scala by defining conventions (inspired by the Cats library) and relying on tools (e.g. Simulacrum).

Workshop: Justin Kaeser Scary Build Tool? Automate more with sbt.

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.

John A. De Goes Quark: A Purely-Functional Scala DSL for Data Processing & Analytics

Quark is a new Scala DSL for data processing and analytics that runs on top of the Quasar Analytics compiler. Quark is adept at processing semi-structured data and compiles query plans to operations that run entirely inside a target data source. In this presentation, John A. De Goes provides an overview of the open source library, showing several use cases in data processing and analytics. John also demonstrates a powerful technique that every developer can use to create their own purely-functional, type-safe DSLs in the Scala programming language.

Gabriele Petronella Practical Monad Transformers

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

WARNING

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

Listener discretion advised"

Jan Pustelnik Conscious consistency with Akka Cluster, CRDTs and Distributed Data

Did you know that Akka Cluster contains tools for distributing your data making conscious decisions about the level of required consistency guarantees? Let's make a deep dive together into the world of Distributed Data with akka-distributed-data and its CRDTs.

Workshop: Marcin Matuszak The dark side of the moon. The introduction to optics.

The aim of this workshop is to get familiar with optics in Scala. It will cover basic functional optics using Monocle library.

Heiko Seeberger Learn you Akka Streams for great Good!

Stream processing has become ubiquitous and Akka Streams, an implementation of the Reactive Streams specification, is one of the hottest kids on the block. In this talk we cover the essentials you have to know to get started. As we strongly believe in writing code as the best way to learn coding, we show zero slides, but a lot of live code and live demos instead.

Niko Will Akka cluster management and split brain resolution

Akka is a toolkit that brings the actor model to the JVM and helps developers to build scalable, resilient and responsive applications. With location transparency and asynchronous message passing it is designed to work distributed from the ground up.

While distributed systems help to solve some problems like availability, a new set of problems arise. For example how do we scale the cluster up or down? What happens if the network is at least partially not available? Akka provides a comprehensive set of cluster features that enable developers to monitor and manage the cluster manually or in most cases even automatically.

In this talk I will introduce some of these features and explain what you need to be aware of. You will learn how to start a cluster correctly and add / (gracefully) remove nodes to / from a running cluster. Additionally I will show how to handle failure scenarios like network partitions by using an existing or implementing a custom split brain resolver.

Raam Rosh Hai Tracing Akka Streams

The google dapper paper laid the groundwork for distributed tracing systems. I will show how I implemented these ideas using htrace and zipkin and show a live demo of the library I wrote for easy integration into your akka streams & http applications.

Piotr Guzik Real-time anomaly detection made easy

Detecting anomalies is a quite hot topic right now. There are many algorithms to do so, yet they are difficult to reason about and math beyond them is complex. I will present simple statistical soultions that you can understand without phd in maths. I will show you how we did anomaly detection @Allegro in scale. I will talk about how to measure anomalies and how to apply proper machine learning in the streaming way. Last but not least I will present sample demo as a code.

Maciej Gorywoda Artificial Neural Networks in Akka

A presentation planned as food for thought: How we can use Akka for something totally different, achieve practical results, explore interesting features, as usage of time gaps between signal as a source of information, and still not to work our socks off.

Andrzej Ludwikowski Gatling distilled

In 30 minutes I would like to show:

1. Why is it worth to spend some time and learn Gatling - a tool for integration/performance test of your web application?

2. Under what circumstances it is necessary to have Gatling in your toolbox?

3. What are Gatling cons and what kind of problems can you expect?

For sure there is no silver bullet in testing tools area, but you will definitely love Gatling DSL.

Ionuț G. Stan Modularity à la ML

Scala might be a gateway drug to Haskell and a sizeable part of the community is trying to adopt and improve upon existing Haskell practices in Scala code. But Scala isn't Haskell and was never meant to be, instead it's more of an improvement over the ML family of languages than anything else.

One salient feature of languages in the ML family is the module system — a tool for specifying and grouping collections of types and functions — which helps with programming in the large. Scala inherits this feature too, just under a different name: objects.

During this talk we'll explore the ML module system — its features and limitations — and Scala's take on it.

Daniela Sfregola Random Data Generation with ScalaCheck

ScalaCheck is a well-known library for property-base testing. However, property-base testing is not always possible when side effects are involved, for example when writing an integration test that involves data being stored in a database. When writing non-property-base tests, we often need to initialise some data and then verify some assertions on it. However, manual data generation can make our data biased and preventing us from spotting bugs in our code. Having our data generated randomly not only it would make our test less biased, but it will also make it a lot more readable by highlighting what part of our data are actually relevant in our test.

In this talk we will discuss how to reuse some of the existing ScalaCheck code to generate random instances of given types and how these can be combined to generate random case classes. We will analyse the properties of a ScalaCheck generator and provide examples of how we can manipulate existing generators to meet our needs.

George Leontiev Case study for a real-world type-level programming

For a lot of people, type-level programming is a fascinating topic. It makes your brain work harder, opens new interesting possibilities where you did not expect them. One question that comes up more and more frequently though is – "so where and how exactly do I use this in my day job as a scala programmer?". In this talk, we will explore one such use case: generating json serializers/deserializers at compile-time, with the help of shapeless library.

Workshop: Michał Matłoka Machine learning by example

Are the machines learning on their own? Wait, is Skynet already here? During this session we will tackle an easy Machine Learning problem, show how can it be processed on Spark including data cleaning, normalization and a learning process. Workshop-coding session, but only if the machines don’t rise against us.

Rüdiger Klaehn Designing data structures for the typelevel ecosystem

The radixtree library provides a generic data structure for the typelevel ecosystem. Using this library as an example, I am going to show how to write data structure libraries that work well with typelevel typeclasses such as the ones from the cats library.

Tomasz Kogut Taking your side-effects aside

Scala as a hybrid language does not impose purity on us and the responsibility of keeping rigor lays on the programmer. In this talk, we’re going to explore how to build a special type that allows controlling when side-effects happen. We'll start with a simple naive implementation, make it stack-safe, and on top add support for asynchronous processing. We'll also compare it with what the open source has to offer in that regard and explain why some of the implementations just don't cut it. The listener needs to understand Scala syntax to make the most of the presentation.

Paweł Szulc Getting more Mileage from your Monads with MTL

MTL stands for Monads Transformers Library, but it has barely little in common with monad transformers. Well that's confusing, right? To be honest, in the ancient times, in some long forgotten, prehistoric version of Haskell, MTL was a library holding monad transformers - but those times are long forgoten.

In a nutshell, MTL provides set of abstractions (defined as typeclasses) over many useful patterns that can be applied to types. This allows to write a lot more generic & maintainable code, with noticeably less amount of boilerplatte. MTL brings a a breath of fresh air to pure FP projects that heavly rely on effectful computations closed over monads.

Intrigued? Confused? Or maybe both? You should see my talk, it will be fun & instructive.

Workshop: Dave Gurnell Shapeless beginner workshop

This workshop will introduce shapeless, a library for generic programming in Scala. We will discover how to use shapeless to automatically create instances of type classes ("JSON encoder", "Equals", "Show", and so on) for any algebraic data type (case class or sealed trait) using a very small kernel of library code.

The workshop is aimed at established Scala developers who haven't yet got to grips with shapeless. It will use material from Dave's open source ebook "The Type Astronaut's Guide to Shapeless", which you can download for free fromthe Underscore web siteor fromGithub. The book is not required reading for the workshop, but it is a useful resource if you want to get into this fascinating and powerful style of Scala programming.

You will need: a laptop, a copy of Scala, and a clone of theexercises repo. Setup instructions are in the README on Github. Please grab these before the workshop if you can, to avoid unexpected last minute technical problems.

Kamil Owczarek Continous Applications with Spark 2.0

Spark 2.0 comes with a new, powerful feature - Continous Applications. Unifying the broad choice of inputs and data virtualization with streaming, it enables streaming structured and semi-structured data as DataFrames or Datasets. This, along with the recent developmenets in Spark ML and the introduction of GraphFrames, gives us new, exciting possibilities like building on-line and time-windowed machine learning pipelines and running analysis on graphs updated in real-time. During the presentation, I will present the broad possibilities of Continous Applications on an end-to-end example, from obtaining data to running it through a machine learning pipeline.

Daniel Westheide kontextfrei: A new approach to testable Spark applications

Apache Spark has become the de-facto standard for writing big data processing pipelines. While the business logic of Spark applications is often at least as complex as what we have been dealing with in a pre-big data world, enabling developers to write comprehensive, fast unit test suites has not been a priority in the design of Spark. The main problem is that you cannot test your code without at least running a local SparkContext. These tests are not really unit tests, and they are too slow for pursuing a test-driven development approach.

In this talk, I will introduce thekontextfrei library, which aims to liberate you from the chains of the SparkContext. I will show how it helps restoring the fast feedback loop we are taking for granted. In addition, I will explain how kontextfrei is implemented and discuss some of the design decisions made and look at alternative approaches and current limitations.

Szymon Matejczyk How to extend map? ... or why we need collections redesign?

The talk will be based on a puzzle that should be simple even for beginners: extend Map[(Int, Int), T] with method row(r: Int) -> Iterable[T].

Turns out it's not. In Scala it's tricky in at last 3 places: understanding MapLike, GenLike, CanBuildFrom and type bounds.

At the end I'll introduce some concepts of the new collections planned for Scala 2.13.

Alan Johnson Building a Real-time Auction Engine Using Event Sourcing

In barely half a year, my team of four launched a product that lets Artsy users bid in global sales hosted by our auction house partners in real-time. One of the core pieces of this system is a bidding engine, written in Scala and the Akka Framework. We created small open source library called Atomic Store, which builds upon Akka Persistence, to process bids in the event sourcing paradigm. This talk discusses how all the pieces fit together, in a use case in which consistency trumps availability.

Renato Cavalcanti Functional Foundation of Event Sourced Application

It's often said in the CQRS community that frameworks are not needed because the basic operations are quite trivial. This is true, as we are going to see during the talk. However, it's not that trivial to deal with failure, asynchronicity, concurrency, IO, etc.

It turns out that functional programming offers many constructs that can help us to deal with all those aspects while staying pure and principled.

We are convinced that a solid functional foundation for CQRS/ES can lay the path for better abstractions and more expressive modelling.

Valentin Kasas Carpenters and Cartographers

To help themselves deal with complexity, programmers have a long tradition of using metaphors that map the abstract concepts they wield onto concrete object and activities of the everyday life.

Some of these metaphors are so powerful that they gave birth to entire programming cultures — like Object Oriented Programming — or programming techniques — like the Actor Model.

However, an overused metaphor can end up hiding the reality it was supposed to help grasp in the first place ; it becomes an illusion.

In this talk, I try to describe how the construction-related metaphors — the “carpenter’s mindset” — can mislead us into believing that programming is a creative activity, and why this can lead to unwanted effects. In contrast, I’ll introduce the “cartographer's mindset”, the idea that programming is first and foremost a matter of discovering abstractions, and show how we can make both the carpenter and the cartographer to work together and produce better software.

Jarosław Ratajski Lambda Core – HardCore

You all use lambda expressions. But what does it mean... Lambda? The talk will be about story behind this term, from a little bit more scientific point of view. Church Lambda calculus, Entscheidungsproblem and incompleteness theorem. Almost all of that will be presented in Scala. And of course you can later impress your friends with some impressive math tricks. There are going to be shown some very crazy code pieces such as perfectly unusable implementation of boolean (based on lambda expressions). Come and see what purely functional really means.