Full stack Kotlin with Ktor

Kotlin developers have a lot of potential at their fingertips. The right language and tools to build not only beautiful cross platform applications using KMP, and Compose but also a powerful server side ecosystem thanks to Ktor and the JVM.

This session will give a practical tour to building a Ktor application using Dependency Injection using familiar tools like Dagger 2, implementing routes, how to share code, and writing tests against a real database using TestContainers.

Coroutines and Structured Concurrency in Ktor

Ktor is built from the ground up using Kotlin and Coroutines. It allows us to leverage Structured Concurrency, and easily build elegant and robust applications.

Discover how Coroutines and CoroutineScopes work in Ktor from the ground up, and what patterns and best practices allow building safe -and maintainable applications with Ktor in Kotlin.

Unlocking the Power of Arrow 2.0: A Comprehensive Guide

We’ll dive into Arrow 2.0, a transformative update to Kotlin's functional programming landscape. Join the maintainer for an enlightening tour of Arrow 2.0's advancements, including typed error handling for safer code, seamless integration with Kotlin Coroutines for concurrent programming, resilient programming techniques, and elegant approaches to working with immutable data structures. Arrow 2.0 represents a significant milestone in our journey to make Functional Programming in Kotlin truly idiomatic, simple, and elegant to empower developers to write expressive, efficient, and reliable code. Whether you're a seasoned functional programmer or a Kotlin enthusiast, this session promises practical insights into mastering Arrow 2.0 and navigating the functional frontier in Kotlin.

Functional Programming in Kotlin

Graceful shutdown with Structured Concurrency

This session will discuss some of the challenges when working in distributed systems with Kubernetes, or RedHat OpenShift, more specifically graceful shutdowns to properly support continuous deployment with staged rollouts and efficient up-and-down scaling.

Functional microservices with Ktor

Compare architectural patterns between SOLID (OOP/DDD) & FP.
Showcasing that functional patterns are in line with what we're already familiar with from OOP and best practices there.

This talk aims to demystify some functional patterns by explaining them through patterns we know from OOP. Such as interface segregation, composition over inheritance, etc.

This talk will avoid all "names" as much as possible, and will drill down into the patterns to see what properties we care about and how they're implemented in both paradigms.

This talk will be a "live" session. Hopefully, it includes a lot of live coding, but this depends on preparation as well.

The idea is to discuss quite some code in IDEA, similar to the webinars (https://www.youtube.com/watch?v=IDMmmrRhUvQ).

Arrow 2.0's Trajectory

Since the first commit 10 years ago Arrow has travelled a long path to reach 2.0, this talk will take us through the journey, decisions, and challenges that shaped Arrow.

Arrow aims to bring functional programming patterns to Kotlin in an idiomatic way, by leveraging Kotlin's DSL features to represent complex programs in elegant ways.

Advanced DSLs in Kotlin

Kotlin has powerful support for building DSLs, and in this talk we’ll explore all the existing techniques used to build powerful DSLs for your applications. We’ll dig into the building blocks Kotlin has and see how you can leverage them into your current applications in order to simplify your code, thus promoting more elegant Kotlin usage for your domain specific needs.