Functional Scala London 2019: Day 2
My summary of the second day attending the awesome Functional Scala London 2019. If you didn’t read the first part, just do it!
Keynote: Modern Data-Driven Applications with ZIO Streams, by Itamar Ravid
Opening the second day, Itamar amazed us with the super powers provided by ZIO Streams.
Modern data-driven applications have multi dimensional datasets and the flow of incoming data is non stop. Building an ETL from S3 objects in about 10 minutes, Itamar successfully demonstraded the power of ZStreams, tackling the problem with a solution that is resource safe, interruptible and efficient with maybe 80 lines of (very simple) Scala code.
This one is easily between my top 3 of this conference. Besides, Itamar’s talk inspired me to build something that I hope, will be sharing here soon :)
Functional Architecture, by Piotr Golebiewski
Piotr presented a modular architectural design on top of ZIO to deal with complexity, building small programs and composing them into larger ones.
I would call his demo a “real world usecase” (UserService, UserStorage, so on and so far), the sort of example I consider very important; that’s exactly what helps selling Scala and its ecossystem.
He showed then how to test the modularized application, organise dependencies, the good and the bad. It was Piotr first presentation, and it was a great one. Well done Pietr!
Caliban: Designing a Functional GraphQL Library, by Pierre Ricadat
Pierre is the creator of Caliban, a purely functional library for creating GraphQL backends in Scala. He told us about GraphQL in a nutshell followed by the reasons why the lib was created.
The talk was a general overview of Caliban’s capabilities, and plans for the future. It’s the sort of lib important to prove the maturity level of Scala ecosystem.
Macros and Environmental Effects, by Maxim Schuwalow
A talk about how to eliminate boilerplate code in the ZIO environment, using ZIO Macros.
Maxim had some examples with boilerplate using Doobie and even ZIO, and the differences after performing some local elimination after adopting the macros.
Honestly, I don’t have many notes about this talk, which I loved - I was just too busy paying attention!
Streaming Analytics with Scala and Spark, by Bas Geerdink
A presentation about fast data use cases, in different sectors (Finance, Healthcare) and patterns (fraud detection, trend analysis) for instance. Think Big Data, critical domains and real time.
Bas showed us how to work this data with Spark + Kafka. How to prepare the data, process the streams, look at time windows and how to bound them by watermarks (timestamps).
ZIO Actors, by Mateusz Sokol
Mateusz started his talk going back to actors basics: what they are and what they should do. He made a quick demo using Akka actors and then introduced ZIO Actors.
Even though ZIO Actors are stateful, they are wrapped in pure effects. Using a State Machine example, Mateusz demoed supervision, location transparency and more. At the very end, he shared the challenges of building the lib.
Adventures in Type-safe Error Handling, by Jacob Wang
Jacob went all the way through every abstraction to handle errors, including:
Either
IO[A] //cats
IO[Either[E, A]]
EitherT[IO, E, A]
Bifunctor IO[+E, +A] //zio
What took him to build Hotpotato (best name ever), a type-safe error handling library, based on Shapeless Coproducts, an interesting alternative.
Composition using Arrows and Monoidal Categories, by Oleg Nizhnik
Oleg delivered a proper class about Monoidal Categories Theory. This one took my whole attention, I would suggest you to wait for the video, it was legendary.
Practical Logic(al) Programming with Dotty, by Lander Lopez
This presentation was Dotty in a nutshell. I would highlight Union Types. Unfortunately at this point I had to take a break, so missed most of the talk.
Next-Level Type Safety: An Intro to Generalized Algebraic Data Types, by Matthias Berndt
Matthias started describing ADTs, using Either as example and talking about how we can reify type information into values. He discussed the limitations regarding some combinators, and introduced Generic ADTs.
We watched a case study of designing an expression DSL, first implemented just with regular ADTs and discussing the limitations of this solution. Afterwards, an implementation using GADTs, provinding proper type reification and type check, having a much nicer result.
Keynote: The Many Faces of Modularity, by Eric Torreborre
Spoiler: Eric’s talk about modularity was awesome. Starting with a comparison between software and Lego, Eric trashed everything that’s not modular, and I love this sort of provocation.
Eric backed his afirmations about modularity with studies, listed the many problems of working with software: critized popular solutions (including ZIO!) in a very respectful way, highlighted that there are topics were modularity is not being properly considered yet (data, for instance), we have weird solutions to problems, we reimplement the same solutions reiventing the ecossytem. It was a long rant! (alert of internal joke)
At the end, he talked about what really matters and how to achieve the best results. Looking back to solutions that were already there, functional programming, encapsulation, types, effects, streams, always seeking for modularity. I am definitely rewatching his talk when available, I have pages and pages full of notes from it!
That was the final day of the conference. Lots of knowledge, wonderful speakers, community growing. I can’t wait for Functional Scala 2020!
#ScalaThankYou to Functional Scala 2019 for this conference! The Scala community is lucky to have you!
Comments