Miklós Martin – Scheduling and retrying effects with cats (45 minutes)
Scheduling code to run inside the JVM is a common task in my experience. The number of different implementations we had for this problem was on par with the number of services we had. Also, they were all built on top of Akka's Scheduler which means they would not fit well in a pure program, require an actor system, are hard to test and the tests are painfully slow. Eliminating these problems was the main motivator for our new open source library. After the first ideas had been implemented and used in production, we have come across ZIO Schedule, which inspired a major rework. It also made us realize that this can not only be used for scheduling jobs, but also to schedule retries. This talk presents how the ideas of ZIO Schedule were implemented using the type classes from cats-effect, and how this library can be used.
Natan Silnitsky – Building Scala with Bazel (45 minutes)
We all know that compilation of large Scala codebases can be painfully slow, Enter Bazel - an open source build tool from Google that allows for very fast build times while maintaining correctness and reproducibility. In this talk I will share with you the story of how at Wix we have embraced Bazel and managed to dramatically improve our build times. I will also talk about "Rules Scala" - the Scala plugin for Bazel that has cool features such as "unused deps" and "persistent workers" that help keep your build configurations correct and your Scala builds fast.
Noam Almog – Adding Cross Multilingual Support to Wix microservices (45 minutes)
The last year Wix has added multilingual support to its microservices. In order to do that we needed to build a new infrastructure to allow our users to translate their sites and content to different languages. In this talk, we will review the architecture we chose to implement this and how we leveraged Scala's macros to allow easier integrations.
Pavel Shirshov & Michael Feldman – distage: Modern Dependency Injection for Scala
Many Scala developers nowadays consider using Dependency Injection frameworks an anti-pattern incompatible with modern FP settings. We argue that it's just a consequence of a bad experience with legacy Java runtime reflection-based implementations that lack features important for modern functional programming, such as a first-class support for higher-kinded types. We argue that as a paradigm for structuring purely functional programs, DI with automatic wiring compares favorably against implicits, monad transformers, free monads, algebraic effects, cake pattern et al, enabling scaling and a degree of modularity unachievable by any manual wiring approach. This talk covers DIStage – a transparent, flexible and efficient DI framework for Scala that enables late binding, testability, effect separation and modular resource management at scale, working with, instead of compromising the Scala type system.
Paweł Szulc – Formal specification applied (with TLA+)
Formal verification promises software without bugs. At the same time even its name scares programmers away ("It's math! run for your lives!"). This talk will familiarize you with one form of formal verification: a model checker - one that is available in a formal specification tool called TLA+. To convince and encourage you that (at least) some techniques are easy to use and can potentially save you days or even weeks of later debugging. Working with TLA+ will also allow you to think more abstractly about your system. This is not a theoretical talk, this lecture begs you to "please try it at home" - you won't be disappointed.