ScalaUA-2019 Abstracts

Michał Kowalczykiewicz — Love Affair Between Functional & Declarative Programming (45 minutes)
In this presentation I will show how we combine declarative and functional programming. Many of our retail-apps run on LogicBlox (application framework) and are written in the pure-declarative language LogiQL (implementation of first-order logic, superset of Prolog/Datalog). Both of these technologies are developed at Infor/Predictix. What is interesting is that some time ago we started to... generate the declarative code. The next part of the speech will be about the structure of code generators written in Scala (language, grammar, AST, parsers, etc...)    
Paweł Szulc — Formal specification applied (with TLA+) (45 minutes)
1.1 Elevator Pitch
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+.
1.2 Description
Formal methods (and formal verification) promise something that every programmer dreams about - an ability to deliver software that is proven not to fail. Despite them being heavily researched for the past few decades, they seem not to get enough traction. It might be that people are just simply scared of a little bit of math or it could be that even good techniques take time to surface to the mainstream. This talk is here to change that. 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.
Pawel will introduce Leslie Lamport's TLA+ - a formal specification tool with a model checker and proof system. The main objective is to see how formal specification can quickly discover issues deeply hidden in the corner cases of your design. You will gain a powerful tool that you will use on your daily routines. 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.
 
Himanshu Arora & Nityanand Yadav — 10 things I wish I’d known before using Spark in production (45 minutes)
You have recently started working on Spark and your jobs are taking forever to finish ? This talk is for you! We have compiled many spark best practices, optimisation and tweaks that we have applied over the years in production to make our jobs faster and less resource consuming. In this talk we will learn about advanced spark tuning, data serialisation formats, storage formats, hardware tuning, better data locality, control over parallelism and GC tuning etc. We will also discover the appropriate usage of RDD, DataFrame and Dataset in order to take full advantage of spark internal optimisations.  
Pavel Shirshov & Michael Feldman — distage: Modern Dependency Injection for Scala (45 minutes)
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.    
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.