Jon Pretty Advanced Type Mechanics (2 days)

Scala’s type system is a fundamental bedrock upon which the entire language rests. Advanced Type Mechanics is a comprehensive study into all aspects of the Scala Type System, treating it as a collection of tools to be utilized for solving common problems, with a focus on how each feature or quirk of the type system may be employed for practical benefit, particularly for API designers, helping us to create software which is correct and also intuitive. Advanced Type Mechanics combines theory with practical and compelling examples, designed to start small and demonstrate composition into larger examples.Course material will remain available to view for 30 days after the training session.

John A. De Goes, with participation from Wiem Zine Elabadine atomically { delete your actors }

Moore's Law may be dead, but CPUs acquire more cores every year. If you want to minimize response latency in your application, you need to use every last core - without wasting resources that would destroy performance and throughput. Traditional locks grind threads to a halt and are prone to deadlocks, and although actors provide a saner alternative, they compose poorly and are at best weakly-typed.

In this presentation, created exclusively for Scalar Conf, John reveals a new alternative to the horrors of traditional concurrency, directly comparing it to other leading approaches in Scala. Witness the beauty, simplicity, and power of declarative concurrency, as you discover how functional programming is the most practical solution to solving the tough challenges of concurrency.

Mateusz Kubuszok Explain FP like Richard Feynman

The way we talk about FP make it sounds hard and academic. It doesn't have to be this way!

Łukasz Byczyński FS2 - Crash course

Streams are often underestimated nowadays, but this is silly. In many cases, streams solutions are more readable, simple and faster than imperative counterparts.

So, I have only 10 minutes to present power and orthogonality of the FS2 library. See ya!

Justin Kaeser Integrating Developer Experiences - Build Server Protocol and beyond

IDEs - Integrated Development Environments - traditionally provide out of the box support for many of the tasks that go into making working software out of source code. But increasingly, developers expect to be able to use any one of a variety of special-purpose tools for each task. This shifts the focus of the IDE from "Integrated" to "Integrating" external tools into a coherent experience. I have been focusing on one aspect of this - build tools - and will talk about challenges integrating tools with the IDE and how the Build Server Protocol makes it possible for IntelliJ to interface with any build tool.

Valentin Kasas The last frontier and beyond

Have you ever written some boilerplate code for handling your application’s communication with the outside world? You know, that JSON (de)serializer that once was nicely generated at compile-time but broke when you had to evolve your business model.

Of course you have!

But there may be a way to abstract away this repetitive, low-value code that sneaks into every project. Maybe it can also allow for our business classes to evolve without breaking compatibility, while keeping the necessary boilerplate to a minimum. Maybe it would even give us many other cool things for free, far beyond mere serialization concerns.

Let’s find out!

Andrzej Ludwikowski Event Sourcing in Akka Persistence - what could possibly go wrong?

Yet another presentation about Event Sourcing? Yes and no. Event Sourcing is a really great concept. Some could say it’s a Holy Grail of the software architecture. I might agree with that, while remembering that everything comes with a price. This session is a summary of my experience with ES gathered while working on 3 different commercial products. Instead of theoretical aspects, I will focus on possible challenges with ES implementation based on Akka Persistence library. What could explode (very often with delayed ignition)? How and where to store events effectively? What are possible schema evolution solutions? How to achieve the highest level of scalability and live with eventual consistency? And many other interesting topics that you might face when experimenting with ES.

Vladimir Pavkin Aecor — Purely functional event sourcing in Scala

Aecor is a purely functional eventsourcing library, written in Scala. It provides composable building blocks to define eventsourced behaviors, deploy them into a cluster, run projections to get benefits of CQRS and so on. And you get all of that without compromising a single line of you purely functional code.

This talk is going to be a 30min crash course on how to build eventsourced applications with Aecor.

Przemysław Pawelec Events on Acid

I would like to present a solution to keeping consistent state in microservices, which is more streamlined for event sourced architectures than the gold standard of Saga pattern. The solution brings some simplicity and other benefits.

Markus Jura Things I wish I knew when I started with Akka

Using Akka the "right way" is non-trivial. At its 10 years anniversary, I'd like to share my early pitfalls and misusage of this great toolkit and how you can master it to write fault-tolerant and elegant programs. Based on my bias opinion, you'll learn how to structure actors inside an application and when advanced cluster techniques such as Sharding, Persistence and Distributed Data should be used or not.

Andrzej Kopeć ActorRef[Typed]

Typed Actors is a topic that thrills Scala community for a long time. There were several attempts (that I know of) to implement them but the last one seem to be the one that succeeds. Moreover - despite of status "May change" recently a course on Coursera was published. In my presentation I'm going to show how the API looks like and solutions to common problems.

Jacek Kunicki ScalaTest: you're asserting it wrong

Being arguably the most popular test framework for Scala, ScalaTest offers a lot of nice syntax for expressing assertions in your tests. However, a lot of people who are new to the library end up using just the basic matchers.

In this live coding session we’re going to walk through some of the less known parts of the matchers DSL and see how they can enhance the error messages in your failing tests, and make your assertions sound even more like English than before.

Maciej Gorywoda Cellular Automata: How to become an artist with a few lines of code

It’s a theoretical topic. I imagine the audience have just attended talks on issues specific to their jobs, and they plan to attend more of them, but now they look for something a bit different.

I will talk a bit about history of Cellular Automata, what can be practically done with them, and how can we code them in Scala. I will introduce the "engine", which runs CA code, and then go through two-three examples, showing how much of the code is always the same and all the difference in the outcome depends only on a few functions. There will be some visually pleasing (I hope) pictures and animations. And maybe I will be able to summon a bit of nostalgia for the times where we all wanted to program video games.

You can take a look at the project here: https://github.com/makingthematrix/ca_art

Piotr Gawryś Functional Concurrency in Scala 101

Have you heard about all of these breathtaking, purely functional, principled and blazingly fast libraries that handle purity and concurrency in Scala? Interested but lacking foundations and Google doesn’t help much? You’re in luck because that’s what this talk aims to address!

Using IO Monads for concurrency gains a lot of recognition in Scala. However, Functional Programming and JVM’s concurrency model can be challenging to learn and the learning resources are lacking. There are many terms like green threads, thread shifting, or fairness thrown around but what are these and why should we keep them in mind?

Let's dispel some of the magic, answer these questions and see how they relate to each other and Functional Programming.

Gabriel Volpe Up your MTL game with classy optics

2017 and 2018 were undoubtedly the years of Tagless Final and MTL in Scala. Continuing with the trend I will show you how to go a step further to truly leverage this kind of applications by introducing classy optics as an error handling technique, configuration passing and state management.

Description:

I’ll share as well some real-life experiences of using these techniques in production applications as we have been using it since September 2018.

At the end you will have an understanding of classy optics and how it can help you bring business value by solving problems elegantly.

Krzysztof Otrębski State vs Stateful Actors

During this talk I will show you how we can move the logic from actors into a monad state. We will see the benefits of the logic implemented in composable, side-effect-free way.

The talk is based on a project that keeps all of the business logic inside actors. Our goal is to refactor actors into a monad state. The changes will make the application more testable and comprehensible.

Jon Pretty Eleven Little Life-enhancing Libraries

A microlibrary should do one thing and do it well. It's a recipe for composability. This talk will be a rapid-fire tour-de-force of eleven Propensive microlibraries, each given exactly two minutes to demonstrate its uniqueness and usefullness for everyday tasks. You will see new ways to: execute shell processes, work with CSV, calculate digests, use annotations, pattern match on strings, abstract over monads, work with lenses, interpolate strings safely, compose static async graphs, generate valid HTML and diff ADTs. Each one comes with a firm focus on typesafety, elegant syntax and a humorously magniloquent name.

Mikołaj Koziarkiewicz Taming your herd of cats

cats is a very useful library, not only for those who go whole hog for functional programming. However, not all of its features and idioms are always obvious, especially those useful for day-to-day coding. In this presentation I will give several tips and show how to avoid some gotchas while - and thanks to - using cats.

Jakub Kozłowski Conquering Concurrency with Functional Programming

Some people claim functional programming is useless because in the end there will be side effects - or else your program won't do anything useful. That's not true, and as it turns out purely functional programming is really good at solving some real-world problems, like concurrency.

I'll talk about how shared mutable state, queues, and streams can be used in purely functional programs, and why such a solution might be preferred over over the classical ways of managing concurrent state.

Kamil Owczarek Machine learning on streaming data with Spark

In the "4V" definition of Big Data, the 3rd V, Velocity, often refers to streaming, where even small chunks of data, arriving at a torrential rate, grow to huge amounts to be processed. That combined with machine learning techniques, gives us vast possibilities, such as interactive traffic predictions for large metropolitan areas, near real time market advice for personal banking clients on their phones or low-latency risk assessment for financial institutions. The presentation explain the possibilities of combining streaming with machine learning in the Spark ecosystem and techniques for optimal implementation of such combinations, together with useful engineering and mathematical techniques that will boost the performance of Streaming ML in Spark.

Himanshu Arora and Nitya Nand Yadav 10 things I wish I'd known before using Spark in production

You have recently started working on Spark and your jobs are taking forever to finish ? This talk is for you! We have compiled many spark best practices, optimisation and tweaks that we have applied over the years in production to make our jobs faster and less resource consuming. In this talk we will learn about advanced spark tuning, data serialisation formats, storage formats, hardware tuning and GC tuning etc. We will also discover the appropriate usage of RDD, DataFrame and Dataset in order to take full advantage of spark internal optimisations.

Roman Janusz Building trait-based web services with Udash REST

Udash REST allows you to define REST endpoints with plain Scala traits, customized with annotations. On the surface this looks very similar to already well-established solutions from Java world, e.g. JAX-RS. However, we think that when redone in Scala most of its Java downsides can be avoided, primarily thanks to typeclasses and macro-based compile-time reflection instead of runtime reflection. The presentation will describe how Udash REST strives for type safety and seamless developer experience.

Jarek Ratajski Kotlin for Scala developers

Java ++ or rather Scala – … kotlin is a popular language that you might sooner or later encounter.

Sadly it is missing some important features. On the other hand it has its own strong points and with libraries such as arrow-kt it is possible to overcome some of the limitations and write `almost scala` code.