SCALAR Conference 2023 summary

Anna Zabłotna

22 May 2023.12 minutes read

SCALAR Conference 2023 summary webp image

Scalar is a highly regarded conference that focuses on Scala, a programming language that has gained popularity among developers in recent years. The conference, which takes place annually in Poland, in Central Europe, is widely recognized as the region's largest gathering of Scala language and functional programming enthusiasts.

Since its inception in 2014, Scalar has established itself as a premier forum for discussing the latest developments in Scala, as well as showcasing practical use cases of the functional programming languages and presenting the best programming patterns. The conference draws speakers and attendees from around the world, providing a valuable opportunity for knowledge sharing and networking among the Scala programming language community.

scala enthusiasts

2023 edition in numbers

  • 2 days of immersive functional programming experience
  • 8th edition, as always, powered by the SoftwareMill team
  • 22 established IT experts and Scala practitioners
  • over 300 Scala programming language enthusiasts ready to learn Scala features

Adam Warski

Oxes, Tapirs, and Sttps
Adam Warski is a Functional Programming enthusiast, Scala language expert, SoftwareMill CTO, and co-founder.

This presentation delves into the creation of Ox, a prototype concurrency library that harnesses the capabilities of Scala 3 and Project Loom. The discussion commences with an exploration of a basic fork-join scenario, progresses to racing scenarios, and culminates in the implementation of channel-like functionality inspired by Go. Throughout this journey, attendees will gain insight into Ox's design, which integrates both imperative and functional programming paradigms, resulting in a cohesive and versatile API.

Daniel Ciocîrlan

Full-Stack Scala 3 with the Typelevel Stack
Daniel Ciocîrlan is the founder of Rock the JVM, a Scala developer and teacher.

In this presentation, you will witness a live demonstration of a comprehensive strategy and methodology for constructing complete, all-inclusive applications in Scala 3. The talk will showcase the utilization of popular libraries such as Cats, Cats Effect, Doobie, FS2, Http4s, and other related tools, as we delve into the actual implementation process at Rock the JVM.

Jacek Kunicki

Have we found the Holy Enum?
Jacek Kunicki is a passionate software engineer living in the JVM land... and SoftwareMill.

Scala 2 has gained notoriety for its handling of enums, mainly due to the existence of multiple approaches to achieve enum-like behavior, which serves as a cautionary sign. Regardless of the method selected - be it the built-in Enumeration, ADTs, or an external library like Enumeratum - each of them has certain limitations. However, Scala 3 holds the promise of a significant transformation in the realm of enums. In this talk, we’re going to look at the issues that enums have in Scala 2 and whether we found the Holy Grail with the introduction of Scala 3.

Ayush Mittal

Implicits in Scala 3
Ayush Mittal practices and preaches functional programming languages.

Implicits have long been regarded as the most polarizing aspect of the Scala language. While they enjoy widespread popularity, they are also frequently subject to criticism for their excessive power and potential for misuse. This presentation aims to delve into Scala 3 approach to addressing these concerns and shed light on the inner workings of implicits in Scala 3. By exploring this topic, attendees will gain a deeper understanding of how Scala 3 handles implicits and the improvements it brings to the table.

Szymon Rodziewicz

Making Scala batteries-included with Scala Toolkit
Szymon Rodziewicz works at the Scala 3 Compiler Team.

In order to enhance the accessibility and productivity of Scala, the VirtusLab and Scala Center teams have dedicated the past few months to bringing the Scala Toolkit project to life. Once released, this toolkit will enable Scala developers to leverage a collection of community-built libraries seamlessly right after installing the Scala binary.

This presentation will provide insights into the journey that led to this solution, including its present state and future plans. Attendees will discover how cognitive science, including neurocognitive science, played a pivotal role in constructing a toolkit that offers a great user experience, thus making the Scala learning and development process more intuitive and efficient.

Daniel Beskin

Fixing-up Production with Property-based Testing
Daniel Beskin is a functional developer who's convinced that the best way to learn something is to teach it.

Property-based testing is frequently hailed as a miraculous testing approach, promising numerous tests with the creation of a single property. While this concept is undeniably appealing, it's impractical to rely solely on property-based testing for trivial functions like "reverse." However, can we leverage this methodology for more substantial real-world scenarios?

The speaker presents a concise case study where property-based testing was employed to diagnose, minimize, and resolve an actual production issue. Throughout this talk, attendees will witness firsthand the practicality of property-based testing, including its core elements of random data generation, shrinking, and the establishment of well-defined properties.

Łukasz Żuchowski

Smart data pipelines for AI
Łukasz Żuchowski is a software engineer and distributed systems expert.

In this session, you will discover how to leverage monads to construct data pipelines that are not only readable and efficient but also robust. The approach emphasizes the construction of pipelines based on business rules rather than being solely reliant on Spark data frames. By adopting this methodology, you will gain valuable insights into constructing data pipelines that align closely with the specific requirements of your business, resulting in enhanced clarity, performance, and reliability.

Wojciech Mazur

The future of WebAssembly for Scala
Wojciech Mazur is a member of VirtusLab's Scala Compiler team and a Scala Center alumni.

Mainstream programming languages such as Rust, Go, and C# are rapidly gaining prominence in the realm of WebAssembly. With the increasing maturity and adoption of this runtime, it prompts the question: can Scala also participate in this trend?

This presentation aims to explore the potential of Scala in the context of WebAssembly, shedding light on the advantages and opportunities it brings to both web and native runtimes.

Attendees will gain insights into the current level of WebAssembly support in Graal Native Image and Scala Native, along with the associated limitations and prospects. Moreover, the discussion will delve into the complex relationship between Scala and Java, highlighting how inheriting Java's language semantics and runtime proves to be both a blessing and a curse for Scala code.

Filip Michalski

Scala from B to F - Backend developer on Frontend
Filip Michalski is a full stack developer focused on Scala language and a functional approach to coding.

Every developer, at some point, finds themselves venturing out of the "basement" of [B]ackend development and entering the enticing and glamorous realm of [F]rontend development. But does such a transition necessitate abandoning our beloved functional Scala tools?

This talk aims to explore how we can harness the power of Scala and scala.js to build frontend applications in a manner that aligns with the principles of functional programming. By attending this session, you will discover how to leverage Scala's functional capabilities and apply them to frontend development, allowing you to continue using your favourite tools while delving into the world of frontend programming.

Jakub Kozłowski

Pain-free APIs with Smithy4s
Jakub Kozłowski is a lead software engineer on an API tooling team.

Avoid errors in API design, implementation, and evolution by utilizing Smithy. Explore the capabilities of Smithy and Smithy4s, which facilitate the definition of APIs in a unified location and simplify the creation of server, client, and CLI components, all in a Scala-friendly and tooling-compatible manner. Attend this session to discover how leveraging Smithy and Smithy4s can streamline the API development process and help ensure the consistency and compatibility of your API.

Nicolas Rinaudo

Things that are things, but not other things
Nicolas Rinaudo writes code for JPMorgan, where they use Scala programming language to make some very complicated things seem very simple.

The best way to describe this presentation is Nicolas' words:

Abstractions such as functor, monads... are often explained by example, which is only half of what's needed to build a solid intuition. The other half is counter-examples: things that aren't things. This talk intends to fill that void, by going through the list of common abstractions and showing types that are a functor, but not an applicative. While this may sound more like a toy than something useful, understanding the exact properties that disqualify a data type from being an instance of a given abstraction turns out to be surprisingly helpful, and have certainly allowed me to go further in my study of such things.

Martin Odersky

Direct Style Scala
Martin Odersky is a lead designer of the Scala programming language and the Academic Director of the Scala Center.

Envisioning the potential near future of Scala, this session explores various advancements. Beginning with the introduction of a boundary/break for error handling, we delve into strawman abstractions for suspensions and their practical implementations. Specifically, we outline a prospective direct style concurrency and IO library, highlighting direct-style futures and channels as the primary abstractions. These abstractions serve as instances of asynchronous sources, offering a flexible yet straightforward approach to composing computations. Join us in this discussion as we explore the exciting possibilities that lie ahead for Scala language.

Magda Stożek

Get more clarity with opaque types in Scala 3
Magda Stożek is a Senior Scala developer, a fan of strongly-typed languages who enjoys trying to find "the right way" of doing things.

Types serve as invaluable allies to programmers. As we strive for an ideal coding environment, we seek to model our domains in a manner that renders incorrect data impossible through the utilization of the type system. In Scala 2, we have access to useful tools such as type aliases, value classes, and Refined Types. However, Scala 3 introduces a fresh addition to this arsenal: opaque type aliases. What advantages do they offer? Will they simplify our lives? Are there any drawbacks to consider? Join this live demonstration session to discover the answers to these questions and gain a comprehensive understanding of the benefits and potential limitations of opaque type aliases in Scala 3.

Michał Pawlik

Typesafe techniques for better sleep at night
Michał Pawlik creates warehouse automation systems in Scala language.

Discover a range of techniques that empower you to circumvent runtime errors and effectively relocate them to the domain of compile time. In this session, you will delve deeper into the Scala code, refined types, and a declarative strategy for defining HTTP endpoints using tAPIr.

Aleksandar Skrbic

Functional programming and Kafka: do they mix?
Aleksandar Skrbic is a software engineer who loves working at the intersection of backend and data engineering.

Apache Kafka has emerged as a prominent tool in the realm of streaming, making it essential knowledge for contemporary backend developers. In this presentation, we will navigate through the essential patterns for integrating Scala applications with Kafka. We will delve into the available options within the Functional Scala Space, including configuration and interaction with Producers and Consumers. Additionally, we will examine the implementation of various streaming patterns using fs2 and Cats-Effects, providing practical insights into building robust and efficient Kafka-enabled Scala applications.

Kamil Kloch

Cats Effect - Dispatcher, Supervisor, IOLocal
Kamil Kloch left academia, discovered the Scala programming language, and never looked back.

In this talk, we will explore three lesser-known yet immensely valuable constructs introduced in Cats Effect 3: Dispatcher, Supervisor, and IOLocal. These constructs have seen updates as recent as the 3.4 release of Cats Effect 3. While users might initially struggle to discern their immediate significance by examining their interfaces in isolation, we will take a different approach.

Łukasz Michniewicz

Building multiplayer game backend with Akka on AWS Lambda
Łukasz Michniewicz is a senior fullstack software engineer with strong skills in Security Engineering and DevOps.

Multiplayer game backends find an ideal companion in actor systems, where Akka actors seamlessly transform into in-game entities. Additionally, AWS Lambda offers a hassle-free deployment option, reducing the DevOps overhead. In this presentation, Łukasz will guide attendees through the process of constructing a high-performance and cost-efficient backend for a multiplayer game using Scala, Akka, and GraalVM.

Valentin Kasas

Pretty little compilers
Valentin Kasas has been writing Scala code for a living for more than ten years.

We all have pretty little things laying around in our codebases. They’re not exactly The Big Thing™, but they’re nice and useful nonetheless. They’re bits of specifications, or schemas, or even documentation. Yet, we seldom give them the same love we give to our actual code, and our poor little things just stay there, unloved and half-forgotten. But we can do better and give these things the love they deserve by writing them “pretty little compilers”.

Kasper Kondzielski

Writing Scala outside of Intellij Idea
Kasper Kondzielski is a software engineer with a passion for writing clean and reliable code.

Discover the process of constructing a personalized IDE for Scala using Kasper's nvim setup as a foundation. The discussion will focus on the crucial components for Scala development and general software engineering. Topics of importance include metals, bloop, lsp, code navigation, enhancing interactivity within the editor, and the reasoning behind Kasper's choice to adopt this setup over Intellij Idea.

Tomas Mikula

Custom Stream Operators Made Safe And Simple with Libretto
Tomas Mikula is a functional Scala programmer with an urge to work on improving programming languages.

In this presentation, we will explore the capabilities of Libretto, a Scala DSL designed for concurrent programming. Tomas will showcase how Libretto can be utilized to develop custom stream operators. Furthermore, he will demonstrate the seamless integration of Libretto with ZIO Streams. By watching this session, you will witness how Libretto enables developers to concentrate on business logic rather than getting caught up in low-level implementation intricacies.

Paweł Marks

The future of Scala
Paweł Marks is taking part in shaping the future of Scala 3 as a member of the Scala Improvement Process Committee.

Scala is undergoing rapid improvement, and this presentation offers valuable insights from someone actively involved in these transformations. Attendees will gain a comprehensive understanding of the Scala Improvement Process, enabling them to grasp the inner workings of the language's evolution. Moreover, the session will introduce participants to various experimental features currently under exploration and shed light on planned but as yet unimplemented enhancements.

By attending this talk, you will gain an insider's perspective on Scala's ongoing development, familiarize yourself with experimental features, and get a glimpse into the future direction of the language.

Gabriel Volpe

Functional Event-Driven Architecture
Gabriel Volpe is an Author of a book: "Practical FP in Scala & Functional Event-Driven Architecture".

This session provides a sneak peek into the forthcoming book, "FEDA: Powered by Scala 3" offering a preview of the comprehensive knowledge and practical guidance it offers in this domain. Watch to uncover the mysteries of Event-Driven Architecture in the functional world and get a glimpse into the upcoming book.

Scalar team


Scalar is an essential event for developers interested in Scala language and functional programming, providing a unique platform for learning, sharing, and connecting with like-minded professionals from around the world.

Want to learn more about Scala and other programming languages? If you are a fan of functional languages, stay up to date with all about the next edition of Scalar 2024.


See you next year!

Reviewed by Bartosz Żyliński

Blog Comments powered by Disqus.