John A. De Goes

Topic: Scala: End Game

Scala 3 is the largest revision of the programming language in recent history, and is rapidly nearing release. With Kotlin on the rise and the containerized world drifting away from the JVM, developers everywhere are wondering what the future holds for Scala. In this sequel and conclusion to Scala’s Last Infinity War (Scalapeno 2018), John A. De Goes and Wiem Zine Elabidine take to the stage to present a compelling and inspiring vision for the Scala programming language, ecosystem, and community. Attendees will learn about powerful new simplifications coming to Scala 3; new libraries pushing Scala to the forefront of async, concurrent, and distributed programming; and new hope that the Scala community will move beyond past civil wars, and assemble together, diverse but united by a common passion for using a powerful language to take on the hard problems of modern application development.

Wiem Zine Elabidine

Topic: Scala: End Game

Scala 3 is the largest revision of the programming language in recent history, and is rapidly nearing release. With Kotlin on the rise and the containerized world drifting away from the JVM, developers everywhere are wondering what the future holds for Scala. In this sequel and conclusion to Scala’s Last Infinity War (Scalapeno 2018), John A. De Goes and Wiem Zine Elabidine take to the stage to present a compelling and inspiring vision for the Scala programming language, ecosystem, and community. Attendees will learn about powerful new simplifications coming to Scala 3; new libraries pushing Scala to the forefront of async, concurrent, and distributed programming; and new hope that the Scala community will move beyond past civil wars, and assemble together, diverse but united by a common passion for using a powerful language to take on the hard problems of modern application development.

Paul Phillips

Topic: xs: a collections cli

The pastiche of command line tools we utilize to process text can be reimagined more coherently as collections operations, where the collection is a sequence of strings, or a view imposed on a sequence of strings. The tool I present here has simplified my life in this regard. It offers a highly concise way to perform chains of collections operations (e.g. take/takeRight, drop/dropRight, slice, map, filter) with all of them designed to flourish as much as anything can amongst the grim ad hoc reality of unix pipelines. I call it xs.

Eric Torreborre

Topic: The many faces of modularity

Functional Programming is on the rise and many programmers fall in love with the idea that they can build well-behaved programs from small, well-understood, functions. However our community is still wondering how to best build large applications and services. Many techniques co-exist nowadays: functions-only, MTL, effects, Tagless-final, ReaderT pattern, dependency injection... This can be so confusing for newcomers. This talk will take a 'zoom out' approach and come back to what we are really after: modularity. We will embark on a 'modularity tour':

* Why is it so important to have modular programs?

* Why is it so hard to achieve modularity?

* What can we expect from today's techniques?

* What can we hope from the ongoing research?

Jon Pretty

Topic: Unleash Your Fury

Coming soon

Itamar Ravid

Topic: Modern Data-Driven Applications with ZIO Streams

Most applications these days have to deal with some form of data processing. Whether it's data ingestion, aggregation or persistence - it's hard to avoid! Dealing with these tasks can be a nightmare without a fitting abstraction. In this talk, we will see why ZIO Streams can be the perfect basis on which to build your application. Throughout the talk, and with numerous examples, we will see how ZIO Streams enables developers to quickly and succinctly construct concurrent and resource-safe applications. We will also look at the internal representation of ZStream to gain a deeper understanding of how it works under the hood. No prior experience with the library is required!

Kai

Topic: Hyperpragmatic pure FP testing with distage-testkit

Having a proper test suite can turn ongoing application maintenance and development into pure joy – the best tests check meaningful properties, not the implementation details, and hold no impliict assumptions about their test environment - every test case must be self-contained and portable. To ensure that tests are free of implementation details and environment dependency, we may simply run them in a different test environment, with different implementations of components. But the boileplate and manual work involved in rewiring components, writing hardcoded fixtures and setting up different test environments make this very hard to do at scale. To tackle this problem we've created distage & distage-testkit, distage-testkit gives you the following superpowers:

* ability to easily swap out individual components or entire test environments

* principled & leak-free control of global resources for integration testing – docker containers, DBs, DDLs

* execute effects or allocate resources per-test, e.g. generate random fixtures per-test

* first-class testing of functional effects

* write tests as lambdas – access test fixtures via parameters or ZIO Environment

...and more! We'll also discuss general testing practices and what really distinguishes good tests from great tests.

Pavel Shirshov

Topic: Hyperpragmatic pure FP testing with distage-testkit

Having a proper test suite can turn ongoing application maintenance and development into pure joy – the best tests check meaningful properties, not the implementation details, and hold no impliict assumptions about their test environment - every test case must be self-contained and portable. To ensure that tests are free of implementation details and environment dependency, we may simply run them in a different test environment, with different implementations of components. But the boileplate and manual work involved in rewiring components, writing hardcoded fixtures and setting up different test environments make this very hard to do at scale. To tackle this problem we've created distage & distage-testkit, distage-testkit gives you the following superpowers:

* ability to easily swap out individual components or entire test environments

* principled & leak-free control of global resources for integration testing – docker containers, DBs, DDLs

* execute effects or allocate resources per-test, e.g. generate random fixtures per-test

* first-class testing of functional effects

* write tests as lambdas – access test fixtures via parameters or ZIO Environment

...and more! We'll also discuss general testing practices and what really distinguishes good tests from great tests.

Pierre Ricadat

Topic: Designing a Functional GraphQL Library

GraphQL is becoming a strong alternative to REST for exposing APIs. In this talk, I will introduce Caliban, a new functional library for writing GraphQL backends in Scala. I will go through the process of creating the library from scratch and explain my design choices: how to minimize boilerplate, how to expose a pure API with explicit errors, how to handle subscriptions, etc.

Adam Fraser

Topic: Unveiling ZIO Test: A New Testing Library for Functional Scala

As we gain more and more expressive ways of writing software using functional effects, we also need tools to test that software. Unfortunately, existing testing frameworks have not kept up with the evolution of modern functional effect systems. In this talk, Adam Fraser will first show how existing testing frameworks force developers to treat effects as 'second class citizens', and then demonstrate the power of treating effects as first class values. Then Adam will introduce ZIO Test, a next generation testing library co-developed by Adam that takes this idea to its logical conclusion by making every test an effect. Finally, Adam will demonstrate how this functional approach makes many “hard” problems in testing easy, and completely unifies features like property-based testing that used to require separate libraries. Whether you use Future, Monix, Cats IO, or ZIO, come discover the power of purely functional testing with ZIO Test!

Dejan Mijic

Topic: Let's Gossip!

Over the past couple of years, we have witnessed the emergence of functional effect libraries. While most of them successfully conquered single node computation, providing better solutions for concurrency than actors, distributed computation is still untamed. In this talk, Dejan and Przemyslaw will introduce their work on ZIO Keeper, a principled functional library for building distributed systems. They will present the building blocks of this library, explain the design choices behind them, and demonstrate their capabilities. Finally, they will wrap up the talk with a glimpse to the future, sketching the roadmap to a functional solution to the problem of distributed computation.

Przemyslaw Wierzbicki

Topic: Let's Gossip!

Over the past couple of years, we have witnessed the emergence of functional effect libraries. While most of them successfully conquered single node computation, providing better solutions for concurrency than actors, distributed computation is still untamed. In this talk, Dejan and Przemyslaw will introduce their work on ZIO Keeper, a principled functional library for building distributed systems. They will present the building blocks of this library, explain the design choices behind them, and demonstrate their capabilities. Finally, they will wrap up the talk with a glimpse to the future, sketching the roadmap to a functional solution to the problem of distributed computation.

Pierangelo Cecchetto

Topic: Ray Tracing with ZIO

In the FP realm in Scala, tagless-final is a popular technique to have injectable, testable, extensible components. An alternative technique is the usage of environmental effects, which provides similar benefits, with a lower entry barrier and improved type-inference. During this talk, we will build a fully testable ray tracer in Scala with ZIO using environmental effects. We will also explore some useful combinators available in ZIO to build concurrent, resource-safe applications.

Jakub Kozlowski

Topic: Introduction to Interruption

Modern functional effect systems give us great power, but with that power comes interruptibility. It's important to know if and when your effects can be interrupted, and how to handle that interruption well. In this talk, I'll provide a concise introduction to the way interruption works in functional IO, as well as some best practices for making our code interruption-safe.

Oleg Nizhnik

Topic: Composition using Arrows and Monoidal Categories

Monads and monad-like types are the perfect fit for many eDSLs in functional programming. However, sometimes we need to enforce stricter language requirements, such as static process analysis, minimizing allocations, purity, totality and linear-like semantics (exactly-one use). In such cases, Arrows and Symmetric Monoidal Categories (SMC) may be a fine choice, still they are generally avoided because manual composition is difficult. We present a WIP macro library volga that is for arrows and SMC what is for-comprehension is for monads. We will discuss use cases applicability of Arrows and SMC, as well as syntax and semantics of volga.

Alexey Soshin

Topic: Scala & Kotlin, Working Together

Scala is a language that many companies use nowadays. But it’s also considered to be very complex and hard to master. So, some of those companies are looking to migrate to Kotlin. Do they need to write everything from scratch, though? In this talk, we’ll see how we can build Kotlin services on top of Scala infrastructure, so you can have best of both.

Aleksandra A Holubitska

Topic: ZIO Chunk: A Fast, Pure Alternative to Arrays

Arrays are fast and don’t box primitive values, but due to class tag requirements and mutability, they are painful to use and don’t integrate well into functional code. In this presentation, Aleksandra A Holubitska introduces the audience to Chunk, a data type in ZIO that’s designed to be friendly to use, immutable, and high-performance. Learn more about how you can replace usage of arrays in your application with this new high-performance data type that powers ZIO Streams and other libraries in the ZIO ecosystem.

Mike Kotsur

Topic: Prototyping the Future with Functional Scala

A few months ago I quit my job and became an independent contractor so that I could help companies build great applications using Scala. My first client, a medium sized company, which develops SAAS products for universities and research organizations, asked me to help the team to develop a kick-ass prototype within a very limited period of time. In this talk I will explain how the team came to the conclusion that Scala is a good solution for the job of building a worker for preparing, executing and retiring Docker containers and how FP and the combo of Cats Effect, FS2 and RabbitMQ helped me, who didn’t use those libs in production before, to go in a fast-forward mode without compromising quality. And finally, we will try to conclude if functional Scala is a good choice for prototyping the future.

Lander Lopez

Topic: Practical logic(al) programming with Dotty

The upcoming Dotty/Scala 3.0 will enable a new level or logic and algebraric programming at the type level. We will be able to use products and coproducts at the type level. These are the equivalent of tuple and Eithers at the value level. After a primer on these new capabilities, we will explore how the FP machinery behind ZIO and other pure FP libraries can be simplified. The new encodings make complex topics like MonadTransformers approachable for FP beginners. Some of these techniques push the limits of dotty's type system, so we will be extending the typechecker through dotty's extension mechanisms.

Matthias Berndt

Topic: Next level type safety: An Intro to Generalized Algebraic Data Types

Generalized Algebraic Data Types, or GADTs for short, are a powerful but little-known feature of the Scala type system. They enable a much wider set of invariants to be expressed and enforced through the type system than is possible without. In this talk, I will present a simple expression DSL and how to leverage GADTs to achieve a robust and performant implementation.

Sergei Shabanau

Topic: Title: Invertible programs

Parsing functionality is commonly available for many languages. Taking text and converting it to the desired structure is a long solved problem. Invertible parsing is (almost) unavailable. Taking text and converting it to structured data or taking structure and presenting it as text in coherent manner using the same program is solved only in theory. Until recently. __Invertible__ simply means __can run in both ways__. With 'parserz' parser combinators library in Scala one can do just that: go from program text to abstract syntax tree and print programs back after optimization done on a tree; or express a web server and get a web client for free by simply running the parser logic backwards; or even print the description of the parsing program itself to serve as documentation. Welcome version 0.2 of the library with simpler API, new features and, as usual, made with love.

Piotr Golebiewski

Topic: Taming complexity: modular design with ZIO

Modern applications often form complex systems with wide range of responsibilities. As business requirements evolve often what was once a simple process grows to cover many scenarios and corner cases. Given enough time, are we doomed to end up with unmaintainable codebase? Not necessarily. Meet ZIO, a modern functional programming toolbox specificly designed around the idea of composability.

Jacob Wang

Topic: Adventures in type-safe error handling

Error handling is hard - It's a constant struggle between type-safety, ergonomics and performance. Can we have all three? In this talk, we will look at various approaches (including a new library) to handling errors in Scala with their advantages and drawbacks.

Karl Brodowsky

Topic: Making Algorthms work with Functional Scala

In this talk we will use sorting algorithms as an example for making algorithms work faster. First we will explore how to ensure that the functional nature of scala does not stop us from writing efficient algorithms, that tend to mutate data a lot. Then we will address some ideas for making algorithms faster than what we usually have

Maxim Schuwalow

Topic: Macros and environmental effects

ZIO's environment type provides a powerful way to pass dependencies deep down into your program and structure applications. Using it in practice though, it turns out that there are a few usability issues left to solve. As usual, one way to solve these is to turn to metaprogramming. In this talk, we will explore zio-macros and take a look at the patterns that become possible if you enrich your functional effect system with a tiny bit of magic.

Jeremy Smith

Topic: Solving the Scala Notebook Experience

Notebooks have become an essential tool for data science and machine learning research. We felt the existing tools weren't satisfactory for Scala, and lacked the features that developers need in order to productively create reproducible notebooks. So we set out to create a new notebook tool from scratch, which provides essential code editing features that other tools lack, as well as seamless interoperability between multiple languages – including Scala, Python, and SQL – and a host of other improvements that evolve the notebook experience. We'll demonstrate our open-source notebook solution – and talk about why we built it, how some great functional Scala libraries allowed us to go from zero to MVP in an unbelievably short time, and what we learned from migrating to ZIO

Jonathan Indig

Topic: Solving the Scala Notebook Experience

Notebooks have become an essential tool for data science and machine learning research. We felt the existing tools weren't satisfactory for Scala, and lacked the features that developers need in order to productively create reproducible notebooks. So we set out to create a new notebook tool from scratch, which provides essential code editing features that other tools lack, as well as seamless interoperability between multiple languages – including Scala, Python, and SQL – and a host of other improvements that evolve the notebook experience. We'll demonstrate our open-source notebook solution – and talk about why we built it, how some great functional Scala libraries allowed us to go from zero to MVP in an unbelievably short time, and what we learned from migrating to ZIO

Mateusz Sokol

Topic: ZIO Actors

Actors are one of the most popular concurrency models in nowadays software systems. In this talk, Mateusz will present zio-actors - a small, strongly typed actor library backed by ZIO. He will explain library design, demonstrate its usage and point out the differences and similarities with Akka.

Bas Geerdink

Topic: Streaming Analytics with Scala and Spark Structured Streaming

Streaming Analytics (or Fast Data processing) is becoming an increasingly popular subject in enterprise organizations. The reason for this is that customers want to have real-time experiences, such as notifications and advise based on their online behaviour and other users’ actions. At the core of a streaming 'pipes and filters' architecture is the execution of predictive models that operate on enormous amounts of never-ending data streams. In this talk, Bas will go through a few challenges that will arise when dealing with streaming data, such as latency issues, event time vs server time, and exactly-once processing. All code examples are written in Scala. The solution is built on the KISSS stack: Kafka, Ignite, and Spark Structured Streaming. The solution is open source and available on GitHub.