ScalaUA-2019 Abstracts

George Yarish — Building recommender system with matrix factorization (45 minutes)
Online retailers are always fighting to bring more traffic to their websites, so they have begun to provide more services to make as many sales as possible. With recommendation systems and Big Data techniques, companies will be able to apply users information and behavior so they can provide more efficient targeted services. This talk presents a solution that we in Grid Dynamics were able to deliver to one of our customers. The Scala and Spark application incorporates a collaborative filtering approach and Alternating Least Squares algorithm, a very well-known and widely-used algorithm among many world marketing internet leaders.  
Jon Pretty — How I rebuilt the Typelevel Ecosystem with Fury (45 minutes)
Fury is a new build tool and dependency manager for Scala, based on a radical model of source dependencies and distributed builds. The Typelevel ecosystem offers a platform of useful Scala projects which have been converted to use Fury. I will talk about the experience of building them with Fury. This talk will catalog the steps involved with writing Fury builds for a widely-used and coherent subset of the Scala ecosystem, covering the common cases, the biggest challenges, and any compromises that had to be made to support everything.  
Marcin Rzeźnicki — Using monads to enforce programming style your Boss likes (45 minutes)
It all started with my boss coming to me - "I don't like EitherT", he said. "All right, you should be using MonadError anyway" - I replied. "Oh, I don't like that even more". So I decided to help him out and everything went south. I ended up wrestling `Free` and `Cofree`, fighting stack overflows, benchmarking trampolines with flame graphs and, finally, rolled up my own monad which I call `Sealed`. I promise I'll put a GitHub link, but for now I am not really proud of it. My boss and my company love it, though. So I thought I could share with you how to use monads to make your boss happy. Topics I'll cover:
- monadic error handling and flow control
- explore design and implementation of various existing monads in Scala,
- learn how to design a lawful monad from scratch and test it,
- how to deal with various issues that arise in the process: stack safety, performance implications,
- benchmarking with JMH and flame graphs
 
Kévin Rauscher — Scala Schemas with Shapeless (45 minutes)
Why write code the compiler can generate for us ? Following this motto, we, as scala developers, tend to derive a lot of things from our model definition. But what happen when we have to keep our API backward compatible while upgrading our domain model. While coupling models is inconvenient, decoupling them leads to a lot of boilerplate. In this talk, we'll see that, by using the same techniques which allow us to automatically generate our typeclasses, we can also scrap the boilerplate when going from one model to another.
In this session, expect to hear about:
- Recursion and pattern matching
- HList and LabelledGenerics
- Automatic Derivation of typeclasses
- Automatic Derivation of case class transformers
 
Jakub Kozłowski — Conquering Concurrency with Functional Programming (45 minutes)
Some people claim functional programming is useless because in the end there will be side effects - or else your program won't do anything useful. That's not true (at least not in user code), and as it turns out purely functional programming is really good at solving some real-world problems, like concurrency. I'll talk about how shared mutable state, queues, and streams can be used in purely functional programs, and why such a solution might be preferred over over the classical ways of managing concurrent state.