Last week I attended the Functional Scala London 2019, a conference with an incredible lineup of prominent figures of the Scala world. Organized by John De Goes and Aleksandra A Holubitska, this conference is a proper contribution to the community: 2 days of knowledge sharing at no cost for the attendees. This is my summary of every talk presented at day 1.
Keynote: Against noise by Paul Phillips
Paul couldn’t be present, so we watched a video he recorded for the conference. He cracked some funny jokes (being invisible) before starting his point, using
df as example: it has a crappy output. In order to extract useful information using
df, some options are necessary, whereas the default case should be the one providing an output that’s easy to understand.
df is noisy, and visual noise is worse than audio noise. That was his motivation to start his new project:
Paul is a great presenter. Having him was a nice start to the conference!
Introduction to Interruption by Jakub Kozlowski
A talk about functional effects and how they don’t break referential transparency, being purely functional. Jakub showed us an “Interruption story” example, and discussed what are the options to code it, mentioning Futures (no go), Fibers (easy to mess up) and finally Effects.
Some takeaways from his talk:
- Avoid concurrency
- If you are using it, avoid start/fork
- Use built-in parallel operators
- Use Deferred
- Small, high level, compositional abstractions
- Keep the concurrency details away from domain
- Trust the laws, nothing else
Making Algorthms work with Functional Scala by Karl Brodowsky
Karl’s talk was heavily focused on algorithms and how we should be aware that, sometimes, when being purely focused on one aspect, we can forget about other important aspects of our software, like performance. Using sorting algorithms as examples, he measured and presented how immutability can be expensive.
He finished talking about more performatic sorting algorithms, like Flash Sort.
Solving the Scala Notebook Experience by Jeremy Smith & Jonathan Indig
This talk introduced Polynote, a polyglot notebook environment. They started discussing the pain points of working with Scala + Spark in a notebook, what was the motivation to build Polynote.
In summary, they walked-through the process used to built the tool… by one developer!
You don’t need to be an expert on category theory to be productive with FP.
I don’t work with this sort of software, but I had some brief contact with Jupyter in the past. Polynote looks like a modern and superior tool for me, with an interesting set of features.
Mixing Scala & Kotlin by Alexey Soshin
Alexey talked about Scala adoption, how one can educate developers, fire them or provide an environment with polyglot microservices.
Some of the highlights about Scala and Kotlin interop were the differences between Companion Objects and Functions. Sometimes, it’s necessary to use the common ground between them: Java. His example was about Futures, from Kotlin to Java
CompletableFutures and them to Scala.
Prototyping the Future with Functional Scala, by Mike Kotsur
Mike talked about how good the Scala ecosystem is for prototyping. He told us about a project that speeds up Docker containers, initially prototyped in Python and Django.
I would say his presentation was an use case of architectural change, mostly adopting cats effect.
Unveiling ZIO Test, by Adam Fraser
This was one of my favourite talks. Adam introduced ZIO Test, and honestly, it seems awesome, I will give it a try as soon as I can. It implements Tests as values, provides an easy syntax, generators and property based tests out of the box.
Let’s Gossip! by Dejan Mijic and Przemyslaw Wierzbicki
In summary, a talk about ZIO Keeper, a purely-functional, type-safe library for building distributed systems.
Distributed systems are everywhere
The main characteristics are:
- Composable and easily replacable building blocks
- Resilient (failure friendly)
- Strong typed and resource-safe
- Security as an opt-in feature
Ray Tracing with ZIO, by Pierangelo Cecchetto
Pierangelo presented a pure functional, modular ray tracer library he built on top of ZIO. I understand it as an abstraction behind the behaviour of rays, reflection and visual effects.
Invertible Programs, by Sergei Shabanau
In this talk, Sergei discussed invertible programs. Think about inversions between strings and ints, or bytes and a http request. Defining a type-safe specification of a grammar using parser combinators, Sergei found an interesting solution in Parserz.
Complex problems do not necessarily require complex solutions
The killer feature of Parserz when compared to other libs is simple: it is easy to go both sides.
Hyper-pragmatic Pure FP Testing with DIStage-Testkit, by Pavel Shirshov and Kai
The talk started with a discussion: which tests are good and which are bad? Bad tests are slow, unstable, don’t survive refactoring, hard to maintain. In summary, bad tests are expensive.
Pavel and Kai suggested a different terminology, instead of unit/functional/integration, two categories for encapsulation Blackbox and Whitebox tests. Then, three levels of isolation: Atomic, Group or Communication tests.
Based on these initial premises, they presented a testcase they build with
distage-testkit which simplifies the test environment setup, provinding tests dependencies in a smart and non-invasive approach. The way it provides Docker containers I found particularly interesting.
Keynote: Unleash the Fury, by Jon Pretty
The Keynote closing the first day was delivered by Jon Pretty, a discussion about the top 10 problems with Scala and what we, as a community, can do to solve them. He talked about the news for 2020, and the expected impact. He talked about his current project, Fury, a dependency manager and build tool for Scala and (potentially) other JVM languages. The tool has a friendly user interface and tries to solve serious problems like publishing libs.
Great message to close the first day :)
And this was the first day of the conference in a nutshell. A considerably amount of knowledge for one day, but was totally worth it. I am very thankful for this conference, from the community to the community! A Big #ScalaThankYou to everyone that made Functional Scala 2019 happen!