Sessions

Direct Style programming is an exciting development for the future of Scala, but something that can seem a little abstract and remote.

The purpose of this talk is to introduce the problem Direct Style is trying to solve and then, step by step, build up to the solution that the Scala compiler team is building to. We’ll see what’s already implemented and ready for use right now, but also the things that are still needed in order for the entire vision to be realised.

By the end of the talk, we’ll have created a respectable set of effects and their handlers, and written an entire program using them to demonstrate how natural that style of programming can be.

Just as Scala has transformed the way we build applications with functional programming, effect systems are changing how we build strong, testable, composable and provably correct code.

In this talk, we will explore the benefits of effect systems in Scala, the different approaches to effects, how effects make our code more modular and powerful, and the tradeoffs we need to make in the code – all with realistic examples and tradeoffs from personal experience and the experience of companies using them.

By the end of this talk, you’ll know what effects are, how they work, and whether you can (or should) use them in your own code, with the excitement (and care) that may come with it.

In the last few years, one of the leading new areas of development in JetBrains has been AI assistance. It started with simple access to an external large language model within IntelliJ IDEA—but we didn’t stop there.

Today, JetBrains offers a wide range of new features and extensions that can make software developers work more quickly and productively. During this talk, we will go through the most important of them - AI Assistant, Junie, local and cloud completion, connecting to local LLMs, the integration of Model Context Protocol, and more. We will discuss how these tools can boost your productivity and improve your coding experience. We will also talk about AI agents in general, and the future of AI assistance.

The talk will consist of animated infographics and live coding examples.

ZIO has a reputation for being powerful — but intimidating, especially if you’re not fluent in functional programming. In this talk, I explore ZIO through the lens of a machine learning practitioner who doesn’t speak in morphisms or monads — and doesn’t need to.

Why not just stick with Python? Because deploying Python ML models is notoriously painful. Scala was built for robust systems, and ZIO leverages that power to offer a practical, testable, and type-safe approach to production ML.

We’ll walk through real-world ML workflows using ZIO:

- Expressing failure and requirements with types.

- Assembling components with `ZLayer` dependency injection.

- Parallelizing training using ZIO’s concurrency model.

- Streaming large or real-time data via `ZIO Streams`.

- Serving models efficiently with `ZIO HTTP`.

If you’ve ever struggled to scale notebooks, wrangle side effects, or make your models production-ready, ZIO might be the missing piece — and you won’t need to know what a morphism is to use it.