Ruslan Shevchenko dotty-cps-async: can we free concurrent programming from the monadic style

Eliminating of explicit monadic wrapping of each async operation with help of continuations and tasty reflection in dotty. Now its possible to write an ideal async/await which works with any monad.

Nicolas Rinaudo Type classes from the ground up

Type classes are a powerful alternative to subtyping and can help to drastically reduce the amount of boilerplate in a project. Their encoding in Scala is fairly straightforward, but suffers from a notion that they are an advanced feature that only experienced developers should use.

The purpose of this talk is to demystify Scala type classes and show how functional code naturally evolves towards them, and how they compose implicitly to buy developers a lot of "free" functionalities.

Natan Silnitsky 10 lessons learned from using Kafka in 1000 Scala microservices

Kafka is the bedrock of Wix's distributed microservices system. For the last 5 years we have learned a lot about how to successfully scale our event-driven architecture to roughly 1400 microservices, mostly written in Scala.

We've managed to achieve higher decoupling and independence for our various services and dev teams that have very different use-cases while maintaining a single uniform infrastructure in place.

Our Kafka infrastructure is called Greyhound and was recently completely re-written using ZIO.

In this talk you will learn about 10 key decisions and steps you can take in order to safely scale-up your Kafka-based system. These include:

• How to increase dev velocity of event driven style code.
• How to optimize working with Kafka in polyglot setting
• How to support growing amount of traffic and developers.
• How to tackle multiple DCs environment.

Fabio Tiriticco From Zero To Deep Learning With Scala

Deep learning is awesome, trendy and… mysterious for many. This talk introduces AI / deep learning from scratch to an audience familiar with Scala and provides a unique case (dataset + code) for attendees to start experimenting!

Christophe Calvès 10 tips to write fast stack-safe functional code in Scala: the automatic-batching library experience report

Have you ever heard the belief of functional programming being slow? Have you ever been caught by a StackOverflowError in your recursive functions? Have you ever rewritten your functional code into imperative style to make it fast and stack-safe? What if i told you how to write fast and stack-safe functional code? Even for non tail-recursive functions! ;)

In this talk i’ll present you 10 tips to write fast and stack-safe functional code. They comes form our production experience implementing automatically batching of API calls. This experience led to the development of Auto-Batch, a pure functional-programming Scala library for automatic batching.

These 10 tips will cover the whole story of how we solve this use case, from designing the user API to ensuring the performance and safety of the execution engine. They will be presented in context: what was the business needs?, what were the technical requirements? With a strong emphasis on the problems we faced and how we managed to solve them.

Among the subjects discussed are : what `@tailrec` really means and how to bypass it, how to make most functions tail-recursive, how to be sure your code is really stack-safe, how to design your own data-structure that fits your needs, how to use smart constructors to speed things up, why parametricity is your friend, are Generalized Algebraic Data Types (GADT) really useful? (spoiler alert, they are!), is there a concrete use-case of continuation-passing style?, …

Dennis van der Bij Lithium: an OSS split-brain resolver for Akka-Cluster

When some nodes become unreachable in your Akka-Cluster no nodes can take over their work or even leave the cluster anymore. To bring it back to a fully working state the unreachable nodes must be downed. However, if done incorrectly it could lead to data corruption, a split-brain, and a headache fixing it. In this talk, the open-source split-brain resolver called Lithium will be introduced. I will explain why unreachable nodes affect the cluster, the risks of downing nodes, and how Lithium recovers the cluster so it can proceed with all its duties.

Jacek Kunicki How I Understood Monad Transformers

Do you know that feeling when you hear about a new tool and you get excited because you seem to see how it is going to solve your problems? Yet, if you were to explain it to someone shortly thereafter, you would realize that you have almost no idea how it worked? This was my story with many concepts of functional programming, including monad transformers.

A moment of enlightenment came only when I needed to solve a seemingly unrelated problem: mixing Options and Futures in a for-comprehension. I had a feeling that the task was pretty generic and that for sure someone had already solved it.

In this live coding session I'd like to show you the path that I followed - from a common problem, through some more and more universal solutions that have naturally evolved into something we know as a monad transformer.

Kamil Owczarek Spark-Cypher: How we will be doing graph analytics from 2020 onwards

Spark-Cypher is the descendant of Project Morpheus, which marks the new era of graph processing for Spark, vastly expanding on the possibilities of the existing GraphX API. In the talk, I will go through those new capabilities on examples, to showcase how you can benefit from Spark-Cypher once it officially comes out.

Ayush Mittal A trace to remember: Compositional Tracing

Distributed systems are awesome and have a lot to offer. However for programmers they present a challenge to monitor and debug. Frameworks such as OpenTracing offer a solution. We look at how to use tracing while keeping our functional programming code base "pure" and "composable".

Kim Covaci, Jordan Coll Type-Safe Error Handling in the Age of Dotty

Java’s checked exceptions provide a form of type-safety when handling errors, but sacrifice composability and referential transparency. These have been largely replaced by Either-like return types. Using Dotty Union Types, we demonstrate an approach that aims to combine the best of both worlds.

Adam Warski A functional Scala stack for 2020

How to write a basic backend application in Scala? Which libraries to pick? There's a couple of possibilities, and choosing can be overwhelming!

In the talk I'd like to present one approach and one set of libraries, which are used in the Bootzooka template project. During the live-coding session, we'll add a complete feature to the application, taking advantage of:

• trait-as-modules for code organisation
• constructors for "dependency injection"
• tapir with http4s for exposing http endpoints
• doobie for database access
• monix with cats-effect for managing side-effects

Along the way, we'll see both practical benefits of functional programming, and features of the libraries used. Come and see how to do functional Scala in 2020 (and beyond)!

Jarek Ratajski From Scala to assembly the cost of abstaction revisited

When it comes to performance a lot of developers take as granted statements (myths) that are not always valid, not anymore valid or were never valid.

Performance and benchmarking were always tough topics and in languages such as scala there so many layers between code and machine that any analysis seems futile.

We will however try to this and check few interesting examples scala code snippets down to the "bare metal". We will use recent JVM versions including graal and some useful tools such as jitwatch, javap, gc logs, jmh, performance counters.

The next time someone claims something about performance you can measure and check it yourself.

Jon Pretty Probing the Unprovable and Proving the Improbable

Writing robust, reliable software is the goal of most developers. Scala's type system provides a framework in which many desirable invariants can be proven at compile-time, while the JVM offers the means to probe the runtime to check that all inputs produce the expected results.

This talk will reveal and compare two new libraries, Quarantine and Probably, which approach this broad goal from these two orthogonal directions, each introducing a novel idea with the potential to change the way you write tests and handle exceptions.

Wiem Zine El Abidine, Adam Fraser Fiber Supervision in ZIO: Bringing Structured Concurrency to Scala

What are fibers? What is fiber supervision? And how do they make it easier for us to write safe concurrent code? Learn the answers to these questions and more from ZIO contributors Wiem and Adam!

Devon Miller Integrating scala.js into an existing full stack app

While a greenfield project may allow you to choose technologies you want to use, it may be more common that you must fit into an existing project. Even with a full-stack application, scala.js fits quite easily to an existing project. We will use an example based on nodejs, express, apollo graphql running with typescript and add in scala.js client and server components. We may also touch on the use of graaljs (graal VM) as part of the story for enhancing an existing full-stack application with dotty showing how all parts of scala can be used to scale-out a web application incrementally in an economic fashion without resorting to splitting up a server based solely on technology choices. We'll start with management justification speaking points that could help you justify a mixed language approach.