«Advanced Patterns in Asynchronous Programming», Michael Arenzon
In this talk we'll cover some advanced compositional patterns with Scala Futures, in order to build and use higher level abstractions when dealing with async code. Using Futures as a basic building block for concurrent, async code has become pervasive in the past few years and for a good reason. However, when moving from the traditional synchronous code to the async one, a set of patterns that were obvious to implement before now seem to be more challenging. The aim of this talk is to show few examples of these patterns implemented with Scala futures in an async and non blocking manner. We will present the usage pattern and the implementation in order to show the principles of properly handling async code.
«Akka: Actors Design And Communication Techniques», Alexey Zvolinskiy
Akka is a powerful toolkit with numerous modules. However everything in Akka starts from understanding of Actors model. In this talk I want to discuss some practical techniques for Actors design, messaging patterns and organization of Actors hierarchy. This topic should be interesting for beginners and more or less experienced Akka fans 🙂
«Bring Functional Programming to production (Lightning Talk)», Yaroslav Hryniuk
Writing purely functional applications is hard. There are a lot of parts of the puzzle like typelevel/cats, typelevel/cats-effect, category theory, etc, but, unfortunately, there is no defined complete approach to do that. I am going to put all together and provide a set of rules for writing such kind of applications. Firstly, we are going to abstract over a container, and define code capabilities using typeclasses from cats and cats-effect. Then, I will show some practical problems we can easily solve using given approach. Currently, this approach is being adopted and used in WIX for production.
«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.
«Capitalizing on a great IDEA — Becoming a super user with IntelliJ (Lightning Talk)», Maxim Novak
IntelliJ IDEA is the best IDE I’ve ever worked with, it has so many features that allow me to boost my productivity in my every-day job; features, that many developers just don’t use. In this talk I will give you the tools to become a super-user, do the same things only faster and easier. I’ll showcase live-coding use-cases to cover, among other tips, useful shortcuts, easier editing, navigation, and refactoring.