Speakers

Kotlin gives developers a lot of freedom in creating different overloads and working with several scopes. However, this is also a source of complexity. This talk gives a birds-eye overview of how the process of resolution (figuring out which overloads of many to call) and typing (understanding that all the types in a program align) work.

Among others, this talk discusses:

• The general process of resolution in Kotlin
• How scoping affects resolution
• Rules to choose overloads when several apply
• The special case for lambdas, including PCLA (the “new” builder inference)
• Support for context-sensitive resolution

Alejandro Serrano Mena is a passionate advocate of programming language design, formal methods and functional programming in software development. He works as a researcher in the Kotlin Language Evolution team at JetBrains and helps co-maintain the Arrow library. He enjoys not only using and improving those tools, but also spreading the word: he’s written four books targeting different levels, and regularly gives talks at conferences and meetups.

Read more

Modern LLMs like Ollama are technically ground-breaking but suffer from significant thermal and energy inefficiencies on resource-constrained hardware. This is often an overlooked cost of LLM’s deterministic nature of token generation along with the heavy, unoptimized CPU operations within the underlying math engines.

High energy demand translates to high water usage and thermal dissipation needs. For many communities, this environmental footprint makes local AI inaccessible or unsustainable. To solve this, we must adopt a more “frugal” philosophy, the way Android development does.

Read more

Hesitating to dive into a personal project? Come smile (and learn) with my 100% authentic experience: from hexagonal architecture to deployment, product design, and testing, I’ll show you how I built a product from A to Z without mastering everything — and why that’s exactly what makes it exciting!

I will talk Kotlin (of course), Vue.js, GitLab CI, databases, reverse proxy, CORS, Scaleway Cloud, product “doughnut,” and a dash of AI — all sprinkled with mistakes, doubts, and imperfections. Spoiler: Production is still standing (well, for now).

Read more

A darkness has awoken in Center-earth: an ancient imperative evil is reaching out from every corrupt codebase, intent on algorithmic oppression. Everything cherished will be lost if the growing scourge is not defeated.

Join the Kotlin fellowship!

We embark on an exciting journey to save Center-earth from the evil Dark Lord For-ron.

Our mission: restore pure functional programming and ensure immutability in this peaceful realm. Together, we will master the Kotlin Collection Functions (Set, Map, List) to transform, analyze, and aggregate data. We will unlock the power of:

Read more

Over the last year, I experimented heavily with AI integrations in backend systems.

At first, everything felt magical: prompt chains, agents, autonomous workflows, dynamic orchestration.

But the deeper the integrations became, the more uncomfortable the architecture started feeling.

• Prompts scattered across the codebase
• Provider-specific behavior leaking into business logic
• Hidden retries and orchestration loops
• Runtime parsing failures buried inside abstraction layers
• Observability becoming increasingly opaque

At some point I realized: the application was no longer using AI — the application itself was slowly becoming an AI framework.

Read more

When the output of your application is a print-ready PDF, the usual testing strategies fall apart. You can’t snapshot a DOM, you can’t assert on JSON, and “does this look right?” is a question only a human eye can answer. At persolog, every personality profile we ship is a multi-page PDF rendered through an InDesign-server pipeline — and as the solo developer with full product ownership, I needed a way for non-technical product owners to verify their template changes without me sitting next to them.

Read more

Code assistants now write competent Kotlin, Java, Rust, Go, or TypeScript on demand, often in languages we’ve barely touched ourselves. So what’s left for us to learn? If the assistant handles the syntax, the idioms, and increasingly the patterns, does it still matter whether we know a language inside out?

I think it does, but not in the way we used to assume. In this talk, I’ll argue that language fluency and language depth are decoupling. Fluency is the muscle memory of writing idiomatic code, and it’s becoming something we can borrow from an assistant. Depth is something else: understanding type systems, concurrency models, memory semantics, effect handling, the trade-offs a language’s designers made and didn’t make. Depth is becoming more valuable, not less, because it’s what lets us evaluate, steer, and trust what the assistant produces.

Read more