ScalaUA-2019 Abstracts

Justin Kaeser – Integrating Developer Experiences – Build Server Protocol and beyond (45 minutes)
IDEs - Integrated Development Environments - traditionally provide out of the box support for many of the tasks that go into making working software out of source code. But increasingly, developers expect to be able to use any one of a variety of special-purpose tools for each task. This shifts the focus of the IDE from ""Integrated"" to ""Integrating"" external tools into a coherent experience. Especially in the Scala ecosystem, we have an increasing number of build tools to choose from. I have been focusing on integrating sbt and other new tools with the IntelliJ Scala plugin and will talk about challenges involved and how the Build Server Protocol makes it possible for IntelliJ to interface with any build tool.  
Karl Brodowsky – Know your Data (20 minutes, Lightning Talk)
When working with big data efficiently gains can be achieved by putting in knowledge about the nature of the data. Most of our data processing does things like sorting, searching and compression without any assumptions about the data and this works well for relatively small amounts of data that do not create really heavy load or costs. It is relatively little known that it is actually possible to speed up these things when we stop ignoring the knowledge that we actually have or can acquire.  
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
 
Łukasz Filut – Large love simplicity – how build metrics on few example incidents (45 minutes)
The talk is about four cases of different availability and performance incidents. Problems has been detected and resolved in large scale systems (two on large payment provider, one large bank and one in large high school portal). All cases will be occasion to introduce GQM methodology in terms of defining proper and understable metrics. During talk I would like to convince audience (especially developers and devops) to take responsibility for this is very crucial element of any monitoring ecosystem. Each case will be described and followed by methods that helped me during incident. On close up I will present two things. I will introduce GQM as method itself and show how this method could help build better, more readable and reliable, monitoring dashboards with GQM.  
Maciej Gorywoda – Cellular Automata: How to become an artist with a few lines of code (20 minutes, Lightning Talk)
Let's face it: most of the time our work is boring. We just glue stuff together and test if it doesn't blow up. Where’s our promised fun in programming? Right, it’s in fun-ctional. Haha. No. Fun is when great things arise from humble beginnings. You write a small piece of code, run it, and see a complex pattern unfolding. That’s intriguing. That’s what get your interest. Cellular Automata are a very universal model of computations, letting us predict weather, model animal behavior, or city traffic, as well as generate mathematical art. In fact, it’s even possible to simulate automata with other automata, and that’s a thing that always makes computer scientists super-excited. What’s also fun is that a cellular automaton (singular) is a little cute piece of immutable data to which we can apply a range of FP techniques in order to run complex simulations with very little of actual code writing. During this talk we’re going to do just that. We’ll start with some theory, then move to some short code examples, and finish with discussing how can it all help us solving real problems. I promise that you won’t learn anything that is immediately useful, but - I hope - it will inspire you.