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: Coming soon

Coming soon

Valentin Kasas

Topic: Coming soon

Coming soon

Itamar Ravid

Topic: Fancy (Z)Streams for Fancy Programs

Streams are a declarative, high-level abstraction for representing many types of programs. In particular, purely functional streams built on top of effect monads are a joy to use for constructing performant, resource safe and concurrent applications. Many patterns written using manual concurrency management can be elegantly represented using streams, resulting in concise and correct programs. ZIO's streams library was introduced at the end of 2018. Since then, it has gone through several iterations, improving compositionality, resource saftey and support for concurrency. In this talk, we will show how, by using the ZStream and ZSink data types, we can quickly 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: Coming soon

Coming soon

Matt Searle

Topic: Coming soon

Coming soon

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.

Chetan Khatri

Topic: Demystify Functional effects with Apache Spark and Scala

This talk will give a pragmatic approach to understanding the side effects of the very popular Data engineering framework 'Apache Spark' and related transformations. Apache Spark operations are side-effect driven. It is very important to have control over those side-effects. In the end, the talk will demonstrate production-ready implementation and design with ZIO.

Tom Sydney Kerckhove

Topic: Validity-Based Testing

Writing correct software is difficult. Property testing has the potential to make safe software easier and cheaper. However, current methods still involve the costly requirement for programmers to write generators, shrinking functions and properties. Validity-based testing promises free generators, free shrinking and cheap properties, to allow property-based testing to fulfill its true potential.

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: coming soon

coming soon

Afsal Thaj

Topic: ZIO-Config; Re-inventing configuration management in Functional Scala

With this talk, we are unvieling ZIO Config, the library that aims to have a powerful & purely functional, yet a thin interface to access configuration information inside an application. It is built on sound foundations, leveraging the well-known, lawful abstractions of functional programming. Everything library does inside, is by making use of program introspection - a feature that goes well with a Free Applicative style encoding. However, it stays as minimalistic as possible, with zero dependencies, zero implicits and zero macros, and insanely simple to use. The purpose of the talk is not only to demonstrate what zio-config is, but to demonstrate the fact that sticking on to fundamentals of FP, and finding the right structure enables writing purely functional libraries with almost zero complexity.

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