«Clean Tests — how to apply clean code principles on your tests», Noam Almog
Isn’t a news, and most everyone agrees that writing tests (before, during or after implementation) is valuable. Hardly anyone agrees on what good, clean tests look like, though; if your tests are a live specification of your codebase, don’t they deserve the same care and attention as your production code? This talk focuses on how to keep your tests readable, simple and maintainable. Specifically we’ll discuss how the “given-when-then” pattern affects the way you factor your code, and showcase the remarkable differences between a sloppy specification and a well-factored one.
«Implementing CQRS with Akka», Michał Tomański
Command Query Responsibility Segregation is an innovative pattern focusing on the way we interact with our data. The core idea is that we split our data model into two: write model and read model. It's getting more interesting when we mix CQRS with Event Sourcing. This approach might leave us with two separate databases, namely a storage for events and a storage for views. We're going to see in practice the problems that we can solve with CQRS and the problems that it introduces. In this talk, CQRS and ES will be implemented with a great help of Akka toolkit.
«Scala Refactoring: The Good the Bad and the Ugly», Matthias Langer
Did you ever wonder why Scala Tooling has such a hard time catching up with Java? If so, this talk will give you some answers, using the Scala Refactoring Library as a case study. You will hear about the advantages and disadvantages of the Scala Presentation Compiler, learn what Abstract Syntax Trees are, and how the the new scala.meta framework and scalafix fit into this picture.
«Saving the stack for fun and profit», Marco Borst
In a life coding session, Marco, saves the stack from overflowing. From a blank screen to a working library, we'll encode a 30 line algebraic data type that factors recursion out of recursive algorithms and moves the algorithm from the stack to the heap, a functional programming technique called trampolining. This session is of interest for every beginning Scala programmer that wants to understand what's happening inside utility libraries. Moving beyond merely using them, and being able to code them yourself when the need arrives.
«Reactive Programming in the Browser with Scala.js and Rx», Luka Jacobowitz
Creating User Interfaces has traditionally been a mostly imperative matter and building UIs in a functional way has never really been easy. In this talk we’ll learn how to build UIs using only pure functions with the help of Reactive Programming and Scala.js. We will take a look at OutWatch, a new UI Library based on Rx, look at what works well, identify more challenging tasks and unlock the full potential of functional design and type safety with functional programming in the browser.