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

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

Agentic systems unlock capabilities that traditional “deterministic” applications simply can’t deliver. But there’s a catch: their probabilistic nature introduces real and often unexpected risks—hallucinations, context drift, prompt degradation, and multi-step workflows that evolve in surprising ways. And you definitely don’t want to discover those in production.

The good news: there is a remedy. We can borrow the most reliable practice from deterministic software—test-driven development—and adapt it to the agentic world. The result is Eval-Driven Development (EDD): a systematic, engineering-first approach to bringing reliability into inherently probabilistic systems.

Read more

Nobody will dispute that creativity is essential to being a successful programmer. With the rise of LLM systems, we lazy coders are even more allured to take the shortcut and by handing out the most mundane aspects of our everyday jobs. Yet what we do not know is that by doing so, we are also seriously hampering our happy, silly, and joyful side of programming, or in other words, the creative aspects of programming. In this talk, we’ll explore why AI-assisted tools are not beneficial but detrimental to our creative side—that very side that is sorely needed when facing complex issues that require coming up with a new and unique approach.

Read more