«Build Server Protocol and fresh IDEAs», Justin Kaeser
LSP has gained significant traction with implementation for over 25 languages and most major editors. However, LSP does not specify how language servers communicate with build tools. Currently, every IDE and language server must implement custom integrations for multiple build tools in order to extract compilation information such as classpaths and source directories. The Build Server Protocol is an attempt to formalize the communication between language servers and build tools in order to provide a seamless workflow when importing a project in your IDE or editor. In this talk, I'll explain the motivation behind BSP and its current implementations in both clients (IDEs) and servers (build tools). I'll zoom on in how BSP is being implemented in IntelliJ IDEA, what's its state of the art and how it can simplify its integrations with JVM-based build tools like sbt, bloop, CBT, Maven or Gradle.
«Purely functional microservices with http4s and doobie», TJasper van Zandbeek
As functional programmers we want to compose pure functions, allowing us to reason easier without needing to worry about side effects. But how to compose pure functions into microservices, which are frequently created using Scala futures and are therefore impure in nature? Using http4s and doobie it is possible to create a pure functional microservice in which side effects are pushed to the border of the application. This talk shows how to do this.
«Tame Your Data with Reactive Streams and Monix», Jacek Kunicki
Stream processing is a hot topic today and it’s easy to get lost among all the possibilities. In this live coding session we will explore the Reactive Streams approach used by the Monix project - one of the Scala implementations of the Reactive Streams concepts. On an almost real-life example we’re going to walk through both the basics and some more advanced usages of the library. The code to be presented is available at https://github.com/rucek/reactive-streams-with-monix
«Reactive streams in pure functional way (FS2)», Iurii Susuk
In this talk, I will show how elegantly you can build data processing pipes using functional algebra. We will discuss core concepts like Stream, Pipe, Signal, Chunk and Handle. We will quickly look into how is stack safety achieved (with pull mechanism), how to interact with outer world (with IO monad) and how to build concurrent streams.
«Monad Stacks or: How I Learned to Stop Worrying and Love the Free Monad, and other stories», Harry Laoulakos
In this talk, I will demonstrate various techniques, such as: Monad Transformers, Effects libraries, and Free monads. These techniques can be used to transform scala “spaghetti” code (that is embedded maps, flatmaps and pattern matching) to cleaner code that almost looks like imperative code.