Registration & breakfast

---

Breakfast

---

Break

The best time to take coffee or juice

---

Coffee Break

The best time to talk with speakers and attendees

---

Lunch Break

---

Keynote

---

Opening ceremony

---

Closing ceremony

---

TBA

To Be Announced

---

Lightning talk

---

Topic tables

Join other attendees and share ideas, talk about the recent challenges, or find solution for a problem. During this session you can connect with other like-minded people in a space designated for certain languages, technologies, and interests.
1. Suggest a topic
Look for large white sheets of paper, and tell everyone what is on your mind! You can also tweet using #topicforgeecon hashtag. Vote for topics (mark it with line/x/heart) and like tweets to show others you’re interested.
2. Choose a room and have fun
We will group similar topics and assign a room. Topics will be pinned before room entrance (list of topics and rooms will be also posted using attendees slack channel - slack.geecon.cz), so you will be able to join others also interested in eg. Kotlin, JVM tuning, Machine learning or testability.

---

Open Spaces + Part @HEVRE, Beera Meiselsa 18 Street

---

Party!

MashRoom, Plac Wolnica 10

---

Lunch - room 7

L1_1

---

Lunch - room 5

L1_2

---

Lunch - room 3

L1_3

---

Lunch - room 7

L2_1

---

Lunch - room 5

L2_2

---

Lunch - room 3

L2_3

---

Lunch - room 7

L3_1

---

Lunch - room 5

L3_2

---

Lunch - room 3

L3_3

---

Debugging with IntelliJ IDEA

Historically, debuggers are used to help locate and fix bugs. Nowadays, the debugger in IntelliJ IDEA can help you do much more than that. Let's see how the debugger helps make the development process more productive. I demo various features for debugging Java applications, including not-so-standard ones, like: * Lambda breakpoints
* Stream chain tracing
* Dropping the frame
* Emulated method breakpoint
* Evaluate and log
* Non-suspending breakpoints
* Custom data renderers and more
100% live coding session

---

We hate code - The !joy of maintaining dead code

Do you love to maintain code that you didn’t wrote? Probably not… As systems grow and evolve, the codebase inevitably accumulates clutter, including unused or “dead” code. Often the developers who wrote that code are not even in the company anymore. So how do you know if the code is still used? Dead code can be confusing and it can be the source for vulnerabilities in your code base. So it is not only “legacy” code we have to deal with but also “dead” code and even so called “zombie” code. This session will give you an overview over the common struggle with this types of code and it will try to give you an idea about the differences between those types of code and about tools that will help you to get rid of it.

---

The DNA of highly effective teams

Session type: TEAMCULTURE

'Culture eats strategy for breakfast'. That widely quoted statement, attributed to Peter Drucker, never really spoke to me and I found it pretty bland - until the day I was asked how we were actually able to pull it off. Half a year earlier we cancelled the subscription to our 24/7 support team because they didn't have any work with our services. Now, as I was explaining to the former lead of that support team how we work, I realized that for the most part our smooth sailing could be attributed to our team culture - and it suddenly clicked. Now Drucker's sentence made sense. The last couple of years as a software engineer I spent building SaaS products for end customers. I want to share my observations from working in highly effective software teams with you. Spoiler: this is not a talk about Scrum. Target audience: all people who are interested in how to collaborate more effectively, particularly in software teams.

---

The guardrails of the AI galaxy

Session type: AI

The use of AI in critical, sophisticated scenarios is desirable, but we all know it’s essentially impossible. Why? The non-deterministic nature of LLMs makes them prone to hallucinations and unreliable outputs. So, what can we do when our LLM responds with nonsense? Let us introduce you to the LLM guardrails. In this talk, we’ll dive into the Quarkus LangChain4j integration that provides you with the ability to verify and/or modify both requests and responses that are being exchanged with your model. Through practical examples, we’ll explore the options available for validating user-provided inputs, rewriting or retrying outputs, and even reprompting the model if needed. The guardrails not only enhance the reliability of AI-driven applications but also allow us to build more trust in our AI systems, one response at a time. Come to learn how we can ensure our LLMs stay on track, even in the most challenging scenarios.

---

The Best of Java Shorts Show: 100 Snippets in 45 Minutes

How to: use globbing for pattern matching, run a Java app without compiling with libraries, print an emoji, run an HTTP dev server, easy date and time, perform SIMD operations, access LLMs, run cron-like jobs, access the system clipboard, print colorful logs, implement smarter enums, 'piping' Java applications. implement a file watch, main() in interfaces, easy file parsing (...) and ~100 other popular Java snippets from http://youtube.com/@bienadam/shorts. No builds, no Maven, no dependencies, just plain java, in rare cases javac and Visual Studio code.

---

What is Functional Programming?

Session type: FP

Functional programming is here to stay. While it hasn't taken over the world, many of today’s popular programming languages have at least borrowed some of its concepts. But if someone asks you, 'What is functional programming?'—would you be able to answer? Specifically, when can we call a language 'functional'? Or, what exactly is 'functional style'? In this talk, we’ll explore the features that may define a language as functional or enable functional programming style. On the other hand, we’ll examine whether certain features disqualify a language. Finally, we'll try to answer if Java might be considered a functional programming language. By the end, our goal will be to discuss functional programming more objectively and with greater confidence.

---

Java Streams: Evolution from JDK 8 to Today

Session type: ARCHITECTURE

Java Streams, introduced in JDK 8, have become a cornerstone of modern Java programming. This session explores the key enhancements and optimizations made to the Stream API in subsequent JDK releases. Join this session to learn about new APIs, performance improvements, or how Streams integrate with reactive programming through the Flow API. This talk is perfect for developers looking to deepen their understanding of Streams and apply the latest features to write more efficient, modern Java code.

---

The Hidden Art of Thread-Safe Programming: Exploring java.util.concurrent

Writing correct, thread-safe code is notoriously challenging. Unlike single-threaded code, concurrency bugs often remain hidden, waiting for the perfect storm of conditions to emerge. Even the standard Vector class, long trusted for its thread safety, harbored a race condition for 5 years, only to introduce a potential deadlock that persisted for the next 9 years. The classes in java.util.concurrent are used in all major Java projects, either directly or indirectly. In this session, we will take a close look at some of the techniques used to create them. We will explore topics like lock striping in LongAdder, lock splitting in LinkedBlockingQueue, weakly consistent iteration in ArrayBlockingQueue, and check-then-act in CopyOnWriteArrayList.

---

Reading Code

As developers, we spend a lot of time learning to write code, while spending little to no time learning to read code. Meanwhile, we often spend more time reading code than actually writing it. Shouldn’t we be spending at least the same amount of time and effort improving this skill? Deliberate practice can help us get better at reading code. Learning how to better read and understand code, can in turn teach us what makes code readable. This might even help us to write code that is easier to read. In this talk we will discuss the benefits of deliberately practicing reading code in a code reading club or session without an IDE, as well as common strategies to navigate a new codebase and familiarise ourselves with the code using the IDE.

---

Reinventing Microservices: Efficiency and Innovation with Single-Runtime

Session type: ARCHITECTURE

Scaling microservices presents significant challenges—increased costs, complex upgrades, and inter-service communication overhead. At Wix, we faced these issues as our microservices grew to thousands. Enter Single-Runtime: a solution blending the flexibility of serverless with the cost efficiency of monolithic deployments. By leveraging Kubernetes daemonsets for host deployment and lightweight pods for business logic, we transformed our infrastructure to support multi-tenancy for the first time. Join us to explore our journey in tackling resource usage and infrastructure complexity. Attendees will gain actionable insights on reducing production costs, streamlining infrastructure management, and fostering innovation in a polyglot environment. Discover how to build a robust, cost-effective development ecosystem from our practical experiences.

---

Simplify your architecture

Session type: ARCHITECTURE

We tend to overcomplicate things especially when we learn them. Your friend comes back from a conference with shiny new ideas and the next day you wake up with event driven architecture for communication, event sourcing for persistence, domain driven concepts scattered randomly on your sources and a distributed monolith in a monorepo. And none of this helps, quite the contrary. Since this is usually where I help companies, I’d like to show you a few recurring patterns of overcomplification and how to avoid them. I’m going to talk about:

• when NOT to use an event bus and when it pays off
• how to handle DDD archetypes to NOT make your life harder
• where 3 layered architecture is an antipattern, and how to use vertical slices
• how to optimize the shit out of your system
• how to split your system into modules/microservices so that development gets easier, not harder
• and a few more things

---

End-to-End Pull Request Testing on Kubernetes: A Walkthrough

Session type: DEVOPS

As applications increasingly rely on Kubernetes for deployment, ensuring seamless integration and end-to-end testing during pull requests is crucial. This talk dives into the practical steps of building a robust CI/CD pipeline that mirrors production environments, enabling reliable and efficient testing within your Kubernetes ecosystem. We’ll explore how to:

• Set up foundational unit and integration tests using modern tools like Testcontainers and GitHub Workflows.
• Integrate Google Kubernetes Engine (GKE) to emulate a production-grade cluster for testing.
• Leverage vCluster to isolate test environments, ensuring parallel runs and minimizing interference.
• Attendees will gain actionable insights to create scalable and maintainable testing pipelines via an existing working example.

Depending on the audience, I can focus more on a aspect or another.

---

Brief history of Virtual Threads in Java

Session type: ARCHITECTURE

Threading in Java has a long and exciting history. To start from the beginning, let's look into the green threads and the subsequent transition to native threads. What were the shortcomings of native threads that needed to be overcome in Java web server runtimes? What was the history of Project Loom's endeavour to introduce continuations to Java? To add some excitement, we will compare reactive approaches with modern Virtual Threads and assess the support for Virtual Threads in modern microservice runtimes with Virtual Thread based Helidon 4.

---

Coding Fast and Slow: Applying Kahneman's Insights to Improve Development Practices and Efficiency

Session type: TEAMCULTURE

How does behavioral psychology connect to coding? This talk explores how understanding and managing your mental energy can transform the way you work. Using accessible research, including Daniel Kahneman’s concepts of “fast” and “slow” thinking, we’ll dive into how different types of thinking impact decision-making and productivity. We’ll also discuss how to conserve mental fuel, so you have the focus and clarity needed for critical tasks—even at the end of a demanding day. In addition to understanding how our minds work, we’ll talk about practical techniques for managing time and allocating mental resources effectively. This includes strategies to reduce context switching, avoid wasting mental energy on low-priority tasks, and stay focused on what really matters. By using your mental energy wisely, you’ll be able to maintain productivity and avoid burnout. If you’re interested in learning how to apply behavioral psychology to your workflow, improve time management, and make smarter decisions with less effort, this talk is for you.

---

Functional Programming with JVM and Truffle

Session type: FP

I am programming (for) the JVM for a long time. I have seen a lot of conferences and tons of Java programmers and I can guess what they are interested in and what they need. However during the last few years I have started to meet different group of programmers. Functional ones. Functional programmers are different. They think differently. They do things differently. Most of them finds Java ridiculous. Are they right or do they just preach water and drink wine? I have had a lot of opportunities to watch them and think about such a question. I believe I do understand them now. At the end 'who wants to hang out with wolves, has to howl with them'... During my talk I am ready to shine a light on this functional world and reveal all the secrets it tries to hide in front of JVM developers!

---

Optimising Java for Cloud: The Enterprise, The Serverless, and The Native.

Session type: CLOUD

Do you want to know your options for running Java on Google Cloud? We will explore various options for running workloads written using the latest Java and Jakarta EE versions on serverless offerings like CloudRun and Knative. Furthermore, we will look at optimizing your runtime performance using various frameworks and Native Image compilation.

---

From JVM to Native: The Path to Efficient Java Containers

Session type: CLOUD

When billing costs in the cloud are based on resource usage, the general advice is simple: use less. In this session, we’ll explore how to build size-compact, cloud-native Java applications that are optimized for deployment in resource-constrained environments. We’ll focus on packaging a Spring Boot web server into slim, distroless, and scratch containers—each providing just enough operating system to run the application. Along the way, we’ll discuss the trade-offs of these approaches, and demonstrate how smaller containers not only reduce resource usage but also are faster to transfer and deploy, which is critical in autoscaling scenarios. The session will dive into GraalVM Native Image configuration options that enables static linking and stripping out unused code, and additionally experiment with Jlink to create a custom Java runtime. Additionally, we’ll explore the advantages of switching from standard JVM-based Paketo Buildpacks to those that support ahead-of-time compilation. Finally, we’ll demonstrate how to automate the entire process—building, optimizing, and containerizing—using CI/CD pipelines.

---

Faster or better designed? Choose any two!

Designing for low latency is hard. We need principles to help us navigate the performance landscape. I'll present here a ranked set of guidelines to lead you through the maze of trade-offs that you will meet in designing a low latency application: 1. No Garbage – none, really?
2. Natural Batching and why you need it.
3. Threads are evil.
4. No exceptions!
5. The Single Writer Principle.
6. Sharing isn’t caring.
7. Good programmers copy, great programmers … don't.
We'll look at the implementation of these principles in the Aeron messaging system and the measured benefit of using them. Applying these principles to the design of any application – low latency or otherwise – will result in a less complex, more efficient, more maintainable system.

---

Evolution of private banking product in 10 minutes.

Session type: LT

This is an AI free talk. I wanted to tell you a story (hope you will find it quite funny) of a banking project which I was developing for several years. From idea, early prototype through rise of the first implementation, pains of maintenance (spring and hibernate included!), general rewrite (no-code? almost no code?) ending with long and prosper life on a modern tech stack (any ideas of a modern tech stack for manager? :-D). This lightning talk contains several general conclusions about product/tech which everyone should keep in their hearts during everyday work.

---

What's the best number of threads?

Session type: ARCHITECTURE

Now you're presumably thinking, 'What a stupid question?'. Surely, there's no one answer to this. It depends on several factors; what you're doing, where the code is running, and how many you need. However, I had never really thought about it in-depth before until someone asked me: 'What is your favourite number of threads?'. In this short (and hopefully fun) talk, I will take you through nearly all possible answers to this question and why they are both right and wrong on a technical and human level. Finally, I will give what I believe is the ultimate and final answer to the question: 'What is the best number of threads?'. There is no barrier to entry here. If you know what a thread is, then you're qualified enough to come along and have fun.

---

JVM in the Age of AI: Babylon, Valhalla, TornadoVM and friends

Session type: ARCHITECTURE

Are you tired of all the hype around yet another LLM-as-a-Service? That's why I want to talk about something more interesting than just another tool for prompt engineers. While the entire industry is discussing it, my goal is to explain what needs to happen within the virtual machine for the JVM to become a good platform for Machine Learning and AI. We will discuss hardware and the challenges its evolution poses for the JVM, projects like Valhalla and Babylon, as well as standardization efforts like the JSR381 Visual Recognition API. We will also look at initiatives like TornadoVM. This will be an overall birds-eye view to understand how the JVM can meet the demands of contemporary artificial intelligence and machine learning.

---

Leading in the AI Era: New Rules for Engineering Management

Session type: AI

The rise of AI is transforming engineering management, demanding fresh approaches to leadership and collaboration. Many engineering leaders, however, are unprepared for the challenges and opportunities AI presents. This session will explore how to embrace AI-driven tools, foster collaboration between humans and AI, and redefine success metrics for the AI era. Learn what the future of engineering management will look like and how you can shape it to drive innovation and success.

---

Avoid common LLM pitfalls

Session type: AI

It’s easy to generate content with a Large Language Model (LLM), but the output often suffers from hallucinations (fake content), outdated information (not based on the latest data), and reliance on public data only (no private data). Additionally, the output format can be chaotic, often littered with harmful or personally identifiable information (PII), and using a large context window can become expensive—making LLMs less than ideal for real-world applications. In this talk, we’ll begin with a quick overview of the latest advancements in LLMs. We’ll then explore various techniques to overcome common LLM challenges: grounding and Retrieval-Augmented Generation (RAG) to enhance prompts with relevant data; function calling to provide LLMs with more recent information; batching and context caching to control costs; frameworks for evaluating and security testing your LLMs and more! By the end of this session, you’ll have a solid understanding of how LLMs can fail and what you can do to address these issues.

---

The Art of Trade-off

The system for marketing automation which we build in Allegro currently handles more than 25 000 incoming events. We had to make tough decisions in order to deliver new features and overcome performance bottlenecks. I will tell about our journey on real life cases which overwhelmed us at first. The presentation will cover multiple types of trade-offs from technical to business.

---

Building Efficient Dynamic Languages on the JVM

The JVM has evolved over the past 20 years to support an impressive array of features. At the same time, dynamic languages like Python, JavaScript, and Ruby has grown more popular. This talk will explore the array of JVM features that can be used to build and support dynamic languages on the JVM, from InvokeDynamic to Panama to Loom to Leyden. We will explore the trade-offs involved and talk about what the future holds.

---

From words to wisdom: How LLMs and vector databases revolutionize data understanding

Session type: AI

In this session, we will delve into the dynamic relationship between large language models (LLMs) and vector databases. LLMs, like ChatGPT, have the ability to generate human-like text and respond intelligently to questions. But how do these models understand and maintain context? The key lies in vectorization. Text is transformed into high-dimensional mathematical representations—vectors—that capture semantic meaning beyond individual words. These vectors allow LLMs to efficiently store, compare, and retrieve information. By utilizing vector databases, we can perform fast similarity searches, enabling AI systems to find the most relevant information, even when it isn’t an exact match to the input. This capability is crucial for tasks such as contextual search, recommendation systems, and natural language understanding. During the session using Kotlin and LangChain4j, I will demonstrate how to convert text into vectors, store them in a database, and retrieve relevant information in real-time.

---

AI Agents with Gemini 2.0: Beyond the Chatbot

Session type: AI

You will learn how to move beyond simple LLM calls to build intelligent agents with Gemini 2.0. Learn how function calling, structured outputs, and async operations enable complex agent behavior and interactions. Discover how to create purpose-driven AI systems capable of a series of actions. The demo covers how a chat message activates the agentic experience, then agents utilize tools to achieve complex goals, and unlock the potential of multi-agent systems, where they collaborate to solve problems. Join us to discover how Gemini 2.0 empowers you to create multi turn agentic workflows for everyday developers.

---

Organizing chaos - Structured Concurrency

Session type: ARCHITECTURE

When there’s order in our world, it’s much easier to navigate. As programmers, we rediscover this simple truth with great enthusiasm every few years. In Java 21, we’ve been given a new toy—virtual threads. One of their main selling points is the slogan: 'Create, start, forget'—an enticing promise that encourages us to create as many of these threads as possible. But we all know what happens in kids' rooms after a birthday party or a fresh delivery of toys—chaos. This time, however, the creators of Java have tried to anticipate the mess and provided us with a brand-new API: Structured Concurrency. It’s not a groundbreaking innovation or a reinvention of the wheel, but rather a proven way to 'organize' concurrency in our programs. During this presentation, I’ll introduce you to the concept of Structured Concurrency, explain why it works and why it was created. I’ll also demonstrate this code in action.

---

A way for multi-language refactoring with OpenRewrite

OpenRewrite is a well-known automated refactoring platform for Java, Groove, and Kotlin source code. It consists of an auto-refactoring engine, refactoring recipes for common framework migrations, security fixes, and other stylistic tasks. Using OpenRewrite allows you to reduce coding time from hours or days to minutes. But for now, we would like to extend the platform by adding support for non-JVM languages. TypeScript, Python, and C# are currently in our development pipeline. During the talk, we will discuss OpenRewrite's basic concepts of LST, TreeVisiting, Recipes, Type attribution, etc. Then, we will look at how other languages apply these concepts and reuse Java-based LST and the OpenRewrite platform.

---

Say `Hi!` to Spring AI and LangChain4j - Seamless Support for GenAI in Your System

Session type: AI

Generative AI is taking the world by storm. While some use cases may seem questionable, many systems can genuinely benefit from GenAI. While most attention still focuses on advancing GenAI capabilities, integration with new and existing enterprise-grade systems often gets overlooked. This talk presents a software architect's perspective on incorporating various GenAI models into your applications. We'll examine key quality attributes (such as portability, maintainability, security, and extensibility) while comparing two popular JVM solutions - Spring AI and LangChain4j. All of that will be illustrated with real-life stories and examples.

---

Faster Java Builds with the Mill Build Tool

Mill is an open-source JVM build tool 4-10x faster than Maven and and 2-4x faster than Gradle for common workflows. With automatic caching, extensive parallelism, and easy extensibility, Mill allows you to effectively build large Java projects even as they grow in size, complexity, and number of developers. This talk will explore some of the benefits of the Mill build tool, dive into the technical details of how a modern build tool works, and show how you can try out Mill today on your greenfield or brownfield Java codebases.

---

Java + LLMs: A hands-on guide to building LLM Apps in Java

Session type: AI

AI is revolutionizing the software landscape. However, for many Java developers, integrating these powerful AI tools into existing enterprise applications or a new one can feel daunting. In this hands-on session, we'll demystify the process and show you how to build LLM-powered features directly into your Java codebase. Using JakartaEE and the LangChain4j library, we'll dive deep into Retrieval Augmented Generation (RAG), a cutting-edge technique that combines the vast knowledge of LLMs with the precision of your own data. We'll explore how to create both few-shot and zero-shot RAG models, and then add practical features like summarization and similarity search, backed by an Embedding database. Through a live coding demo, we’ll walk you through constructing an AI-powered online store backend and provide practical insights into the architecture and code. Whether you're familiar with AI or just getting started, this session will give you the confidence and skills to harness the potential of LLMs in your Java projects.

---

Java 25: Unleashing the Power of Streams

Java 8 introduced Streams in 2014, revolutionizing data processing. While incremental improvements have followed, Java 24 marks a significant leap forward. This session will explore: Stream Gatherers: A powerful new feature enabling more sophisticated intermediate operations. Custom Intermediate Operations: A comprehensive API empowers developers to create their own unique stream transformations. Hands-on Coding: We'll delve into practical examples, including building custom gatherers and intermediate operations. Key Takeaways:

• Understand the core concepts of Java Streams.
• Master the use of Stream Gatherers.
• Gain the knowledge to create custom intermediate operations, unlocking limitless possibilities.

Why Now? The upcoming Java 25 will finalize this API. This is your chance to learn and experiment with these cutting-edge features before they become standard practice. This RFC highlights the key features and benefits of the Java 25 Stream enhancements, making it more concise and impactful for potential attendees.

---

The Future of Data is Words

The world is changing, it’s pretty clear by this point. With the advent of generative AI, we are witnessing the boundaries constantly being pushed on what is possible for a machine to understand and do, simply by using words. However, while this revolution is happening, our dear old friend SQL has officially celebrated its 50th birthday, proving itself once more as a survivor in the world of data. So what is it going to be? Who will control the future of data? Words or SQL? Let’s take a journey into the past, present and future of querying data. We will talk about how SQL became so popular and how it survived for so long . We will talk about the LLM revolution, the challenges of leveraging AI to transition from SQL to NLQ and the technologies that might get us closer there such as RAG, Semantic Layers and Knowledge Graphs. Lastly we will peek into the crystal ball and try to figure out what the future might bring and how it might change the way we see modern data platforms.

---

All the Things That I F**ed Up and What I Learned from Them

Failure is an inevitable part of innovation, but it’s also the most underappreciated teacher in the tech industry. In this candid and storytelling-driven session, I’ll walk you through 12 of my most memorable professional missteps as a solutions architect, Java community leader, and IT strategist. From underestimating legacy systems to mismanaging cloud migrations and from overengineering solutions to misaligning stakeholder expectations, I’ll unpack how each “failure” taught me critical lessons about resilience, adaptability, and the art of problem-solving. This session isn’t just about what went wrong but what we can learn. Expect to laugh, reflect, and leave with actionable insights into how you can navigate complexity, embrace imperfection, and grow from challenges in your career. Whether you’re an architect, developer, or leader, this talk will empower you to see failures as stepping stones to tremendous success. After all, the only true failure is the one we don’t learn from.

---

How 15 years in politics have made me a better programmer

I've spent countless hours the last 15 years on politics. My claim is that it has made me a better programmer. Let me tell you how. Some of the topics I'll go through:

• How a proof of concept sticks
• Prioritizing
• Balancing making the most suitable solutions and giving people what they want
• Every decision is a prioritization, every choice has its downsides
• The solutions are easy, getting peoples buy-in is the hard part
• Estimation vs polling
• Campaigns vs public procurement

---

From Clutter to Clusters: Vector Embeddings for Log File Analysis

Using vector embeddings for Retrieval-Augmented Generation (RAG) is frequently demonstrated these days. However, embeddings have a broader range of applications, including the ability to group similar items together. Log files, with their wealth of information, are an ideal candidate for this approach. By clustering log entries, we can uncover common issues as well as rare conditions within complex systems. This talk will begin with traditional techniques using term vectors and then delve into how modern vector embedding models can enhance log file analysis. We will explore how to build such a processing pipeline, which is often a fun way to start understanding the problems of the system you're dealing with.

---

Let’s use IntelliJ as a game engine, just because we can

Ever wondered what would happen if you used IntelliJ IDEA as a game engine? Probably not, but Alexander did, and it turns out, it’s absurd and a lot of fun! Join Alexander for a lighthearted yet insightful dive into the absurdness of using one of the most sophisticated IDEs to create games within your codebase because... well, why not? In this talk, Alexander will walk you through his adventure of using the IntelliJ plugin platform to implement game logic, render graphics, and more. He’ll share the head-scratching moments, the 'aha!' breakthroughs, and the plain stupidity of making this idea work. You'll see IntelliJ handling sprites, game physics, and maybe even a rogue mutable variable trying to destroy your cursor! This session is for anyone who believes that the best projects are born from a spark of curiosity and a sense of fun. Discover how pushing the boundaries of your tools can lead to unexpected innovations and a lot of laughs along the way. After all, the most important work we do is often the work we find the most fun. Come ready to chuckle, learn, and maybe even be inspired to try your own offbeat experiments!

---

Mobile-First Security: A Tale of a Greenhouse and a Bunker

TL;DR: A fresh look at IT security with smartphones, a 'reverse of control' approach, and P2P at center stage. With the number of active smartphones approaching the size of the world population, many companies advocate a 'mobile-first' approach—including in security-related use cases. However, due to factors such as developer inertia and incremental updates to legacy systems, server-centric architectures still dominate technology stack decisions. When it comes to security, mobile devices are often relegated to a mere 'second factor'. Despite significant progress in the field, including the shift towards 'passwordless' security, this domain remains brimming with outdated clichés — from identity providers and firewalls to freely flowing access 'tokens'. As a result, security incidents and their economic implications continue to rise. This talk offers a fresh perspective on security, placing the user and their smartphone at the center. We will explore how modern smartphones—equipped with a variety of sensors and advanced security technologies—can help us weave a security network far more resilient than existing solutions. We’ll start by dissecting current security and identity management technologies, identifying their weaknesses and breaking points. Then, we will distill best practices and highlight common pitfalls to avoid. The core of this talk will focus on how to leverage proven smartphone security techniques—such as asymmetric cryptography, secure enclaves, and biometrics—and combine them with less commonly used elements (e.g., environmental data from sensors and P2P interactions) to form stronger security chains than those typically available today. We will cover practical use cases, including authentication, identity verification, mitigating common attacks, and handling exceptional situations—such as losing your smartphone or another critical component of your security chain. This discussion will dive into technical details, providing practical tips and sample code. This talk does not cover or promote any existing product. The ideas presented can be implemented in any programming language relevant to mobile and server development, including good old Java.

---

Pipeline Perfection: Practical Tips to Optimise Your CI

Session type: DEVOPS

Your Continuous Integration pipeline is the bloodstream of your organization. In this talk, we’ll share hands-on tips and tricks to keep your pipeline fast, efficient, and reliable. From using the right CI strategies to parallel processing, running tests selectively, skipping unnecessary steps, and managing dependencies better, we’ll cover plenty of practical advice you can apply immediately. Uncover the secrets to a pipeline that never slows you down!

---

Why should we be careful with AI?

Session type: LT

AI will stay with us, whether we like it or not. The continuous growth of the possibilities of AI systems presents both opportunities and challenges, which requires from us to be more responsible for the world around us. The advent of AI can have a darker side, and it’s not necessary the development of rouge AI that will decide to wipe out humanity, like in the movies. During this talk I would like to give you some (possibly) less common perspectives on AI, and to leave you with some food for thought. This talk will be for everyone - feel free to join. And now ask yourself: can you tell if this abstract has been generated by AI, or not?

---

From Hero to Zero - Evolving Resilience From a Hero Culture to a Zero Error One

Session type: TEAMCULTURE

How do you move an organization from a culture of heroic production firefighting to one of consistent, proactive reliability? At Wix, we transformed our approach to resilience and error prevention & handling, shifting from relying on heroic interventions to fostering a 'Zero Error' mindset, where errors are prevented, caught and resolved as early as the development phase and achieved five nines production availability! In this talk, I’ll share how we:

• Evolved monitoring, alerting, and troubleshooting automations to provide proactive out-of-the-box solutions for developers.
• Automated resilience principles via our platform engineering framework to ease up testing, enforce limits, timeouts, and validations effortlessly.
• Created a zero-error policy, focusing on eliminating errors from the get-go, dramatically reducing daily production errors by 80% in 3 months!.
• Prioritized a mindset shift, fostering proactive quality improvement through visibility, collaboration, education, scoped and scalable processes.

I'll share practical steps we took & tools we built to reduce noise, prevent recurring issues, empower developers, and scale improvements across the organization. Whether you’re dealing with alert fatigue or looking to improve reliability, this story offers lessons that can help any team move toward a cleaner, more sustainable production environment. and free you up to build the next amazing (and reliable) thing.

---

DataFrame - a Swiss Army Knife of Java Data Processing

When implementing an ETL job, doing data analysis, or simply reading an Excel file, you will quickly discover that standard Java is missing some key components for data processing and visualization, which are present in more complex and heavy tools like Spark or Flink. So can we use big data techniques without the big data infrastructure? This talk will demonstrate how a lightweight DataFrame from the open-source DFLib library (https://dflib.org) solves this problem for any Java app and a large number of use cases. It will also highlight a couple of other techniques that may feel 'exotic' to Java developers, but nonetheless are very useful, namely Jupyter Notebook and Java charting based on Apache ECharts, essentially assembling a full data engineering toolkit for the 'normal' programmers.

---

Wrong and Useless Models built by using Domain-Driven Design

Are you satisfied with the domain model in your project? Do you find it sometimes overcomplicated? Is making changes to it a challenging task? Does a part of your business logic exist in REST controllers and large service classes? Moreover, are there any important business use cases lacking proper test coverage? If you want to understand how to implement domain models effectively, please attend my talk. I will share ideas from many years of personal experience specifically related to developing domain models and dealing with various business scenarios in real code. Many of the strategies I will demonstrate during the presentation were acquired through learning from painful mistakes. To bring these concepts to life, I'll walk you through code examples highlighting the common traps to avoid and the best practices to adopt. I look forward to seeing you at my talk!

---

Stream Processing As You’ve Never Seen Before (Seriously): Apache Flink for Java Developers

Session type: ARCHITECTURE

You were tasked with building a real-time platform, but traditional tools couldn’t handle the massive data streams, leading to lagging performance and frustrated users. Deadlines were looming, and the team needed a breakthrough. And when you learned about Apache Flink. We’ll explore how the DataStream API allowed efficient real-time data processing and how the Table API and SQL features simplified complex queries with familiar syntax. Testing became more straightforward, and managing the application state was no longer a headache. You’ll learn:

• Harnessing the DataStream API: Process unbounded data streams efficiently to make your applications more responsive.
• Unlocking Table API and SQL: Use SQL queries within Flink to simplify data processing tasks without learning new languages.
• Effective Testing Strategies: Implement best practices for testing Flink applications to ensure your code is robust and reliable.
• Stateful Stream Processing: Manage application state effectively for complex event processing and real-time analytics.

By the end of this talk, you’ll be equipped to tackle real-time data challenges. Whether you are building analytics dashboards, event-driven systems, or handling data streams, Apache Flink can be the game-changer you’ve been searching for.

---

Superhuman: How to Be a Manager (And Not Lose Your Mind)

Session type: TEAMCULTURE

Being an engineering manager is so much more than just leading teams. Navigating AI-driven transformations, shifting generational expectations, and increasing emotional labour in leadership are just a few of the challenges that managers face while trying to maintain the team's motivation, well-being, and performance, juggling business priorities, managing tech debt, application performance, scalability, and reliability, and taking care of a bunch of other things (ofter forgetting to take care of themselves!) In this talk, I'll discuss the challenges of modern engineering management, including the tension between technical expertise and strategic leadership, the risks of burnout and boredom, and the growing demand for empathy-driven leadership. I'll share my learnings and insights into managing 'the engineering leg,' including AI adoption and integration, fostering multi-generational team collaboration, and maintaining personal resilience. Whether stepping into management or refining your leadership style, this session aims to do a 'reality check' of the manager's role and to equip engineering leaders with the tools to adapt, inspire, and lead without losing themselves.

---

The powerful careers of quiet engineers

Session type: TEAMCULTURE

Stephen Hawking used to say that quiet people have the loudest minds. Do you agree? I do and I do think that your impact is immeasurable. Let's think through it together and reflect on the strategies how to make our introversion shine and boost your career! During this talk, you will learn about:

• 4 types of introverts, who is outgoing introvert and who is a shy extravert
• introversion benefits for the team and for CEO
• tools for introverts to enhance their careers and how to accept introversion within themselves.

---

Bridging the Gap: Full-Stack Development Without the Headaches

Working on web projects often means dealing with two separate environments —one for the backend and another for the frontend —each with its own ecosystem. Developers frequently encounter issues when dealing with their counterparts' ecosystems, creating a needless wall between front-end and back-end developers. You have to use unfamiliar tools, follow API changes, create mocks, and have a hard time creating e2e tests. Overall, this makes development unnecessarily frustrating and a time-consuming process. In this session, I'll discuss your approach to these typical problems and show you how Quarkus makes full-stack development easier. Without having to deal with typical npm or front-end setup issues, Quarkus allows you to develop applications with dependable Java back-end services and javascript front ends. You can concentrate on more important things, like building your app! Using a Java backend powered by Quarkus and a JavaScript front end, we will learn how to build a full-stack application.

---

How designing a board game could help you become a better software engineer

They do abstract thinking, systemic thinking, and modelling. Their work is their passion, so they often do it after hours too. And they drink coffee. A lot of coffee. Is this a board game designer or a software engineer? The similarities are not accidental. In many ways, making board games resembles making software. After all, board games can also have bugs, infinite loops, or hang-ups in the middle of a turn. But there are some differences that set them apart. Let’s compare these approaches and see what we could take from one process to the other. What would I like to share with you? My satisfying adventure of working on both. I had to become a board game designer to understand some concepts I only knew in theory, and to see them make a difference. I’ll talk about rapid prototyping, constant cooperation with users, ruthless simplification and feedback - because feedback is king. I invite you to a different world where we first take a look at “how they do it”, and then port the learnings back to the software world.

---

If Streams Are So Great, Let's Use Them Everywhere. Right?

Using streams everywhere: is that really a good idea? Certainly, stream code is often much clearer and more concise than iteration over a collection. But sometimes a stream solution requires a complex combination of collectors, reduction over a primitive stream, or nested FlatMap operations, and the verdict isn't so obvious. In this talk, we'll look at some sample use cases, evolve the best solutions we can, in both imperative and functional styles, and then argue over which is better. This session is for everyone who needs to write code in Java for bulk data processing - every Java developer, in fact. You'll leave hopefully entertained, and with a better idea of the use cases where streams excel, and where you're better staying with old-fashioned ways.

---

Arrow Flight SQL: The Database Transport Protocol

In this talk, we’ll explore Apache Arrow, an in-memory columnar format designed for OLAP query performance, and Arrow Flight and Flight SQL projects, the protocols that enable building database frontends that communicate using Arrow data. We'll compare it to JDBC, and show an example app that implements the Arrow Flight SQL protocol.

---

Gentle Introduction to Lock-Free Programming in Java

Are you curious about lock-free programming but only familiar with using locks in concurrent Java? This talk is for you! We'll make the concepts of lock-free programming approachable, starting with why it matters and the basics of progress guarantees. You’ll learn to differentiate between wait-freedom, lock-freedom, and obstruction-freedom, understanding why these guarantees are crucial. We’ll explore essential lock-free programming idioms, like Compare-And-Swap (CAS) for atomic updates, markable references for efficient state management, and the sentinel node technique for simplifying concurrent data structures. The infamous ABA problem will be demystified—what it is, why it’s problematic, and how to tackle it with techniques like versioning. To see these concepts in action, we’ll implement three lock-free data structures in Java: a stack, a queue, and a linked list. These examples will highlight the practical application of lock-free techniques and the challenges they address. Finally, we’ll discuss performance characteristics, comparing the benefits and limitations of lock-free programming versus traditional locking. You’ll learn when to use lock-free methods for better scalability and when sticking with locks might be more appropriate. Join us to elevate your concurrent programming skills and confidently start experimenting with lock-free programming in your Java projects!

---

To RAG or not to RAG

Session type: AI

Artificial intelligence is bombarding us from every direction in the news and on social media. One of the sensible immediate applications of AI is RAG, at least that's what they say—for instance, Thoughtworks discusses it in their Technology Radars. But what exactly is this RAG, how do you install or implement it, what are its requirements, is it always necessary, and is it generally worth it? Join my talk to find answers to these questions (and a few others), delivered through working code snippets!

---

History in the Making: On Computer Preservation

Our young little industry is, at 70 years and an estimated 27 million engineers, no longer young or little. The breakneck pace of hardware and software evolution is unprecedented in human history, and the impact of computing on humanity - transforming industries, communication and social structures, even nationalities - will only be fully understood by historians in the distant future. But what will these historians learn from, if the fruits of our collective labor are discarded and forgotten, old computers rusting in landfills, bits and bites gone to the ether? Thus was born the computer preservation movement. A loose collection of hobbyists, collectors, traders and - more recently - legitimate non-profits and foundations - has set out to preserve and categorize this rich and fascinating history. Being a hobbyist vintage computer collector, this has been a passion as well as mission of mine for some 30 years. Join me as we explore this wonderful mix of history, technical challenge and pure computer geekdom!

---

How To Be a Rockstar Developer

One evening in 2018, Dylan Beattie sat down in a bar, opened a laptop, and wrote a joke: a parody specification for Rockstar, a programming language based on the lyrics to 1980s power ballads. The joke was supposed to end there: a single Markdown file that folks would read, maybe laugh a bit, and then get on with their lives… well, that’s not quite how it worked out. The internet’s a big place, and a little corner of it took Rockstar to their hearts: they found it, they loved it - and then they implemented it. Six years on, Rockstar has shown up in the most unlikely places, from Classic Rock magazine, to Advent of Code, to Carnegie Mellon University and MIT - and each time, it attracts a new wave of aspiring Rockstar developers, with questions about how it works, and suggestions about how to make it better. And so, one evening in 2024, Dylan sat down in another bar, opened another laptop, and wrote another joke: “Rockstar 2.0: The Difficult Second Album”. On one level, Rockstar in 2024 is a stupid joke language based on Bon Jovi songs. On another level, it’s packed with things that would have been impossible even just a few years ago: a project that combines .NET, C#, JavaScript, browser APIs, and web assembly, building on decades of research in parser engineering and asynchronous application development. And yes, it’s still based on Bon Jovi songs. This is the story of Rockstar 2.0. You’ll learn about the history of esoteric programming languages, from INTERCAL, to Piet, to the researcher who taught Perl to speak Latin. You’ll learn what’s involved in creating an entirely new programming language. You’ll see a lot of cool tech, you’ll marvel at just how much engineering can go into one joke, and who knows - you might even qualify as a Certified Rockstar 2.0 Developer.

---

From candidate to architect mindset - how to pass system design interview

In today's fast-paced tech landscape, a top-tier software engineer isn't just about coding prowess. It's about being a strategic problem solver who can navigate complex business challenges with innovative solutions. As a software engineer, he should be able to facilitate technical discussions, choose the correct option, and have the necessary skill set to implement the selected option. This presentation is your roadmap to approaching System Design interviews, blending empirical research with practical insights to make the process intuitive and engaging. It provides several exact examples from real interviews and will equip you with the necessary tools to excel in standard System Design interviews.

---

500TB of audit logs for 500$/mo and still searchable in real time

Session type: DEVOPS

Audit logs, payments, or transaction logs, … in the modern world, we are forced to store vast amounts of data for auditing and compliance purposes. When data volume grows, a question arises - should we store it on-premise with some “cheap disk arrays” or pay extra for cloud storage? The answer should be - let’s store it cheaply in the cloud! Let me show you how we managed to store over 500TB of audit data, with a cost under 500$/mo and a fast response time no matter how big the query time range is. This is the story of locating, classifying, and effectively storing 0.5PB of customer data. We’ve managed to utilize Google BigQuery technology in a rather unique setup that allowed us to store the entire dataset for less than 500USD/month and allows the support & compliance team to execute complex queries against the entire dataset with a response time of 11s.

---

Scaling Agile Teams: The Matrix Model for Scalable Autonomy

Session type: TEAMCULTURE

As organizations grow, managing multiple agile teams becomes increasingly complex. A well-structured matrix model ensures scalability while maintaining autonomy and cross-team collaboration. This talk will explore:

• How to structure squads, chapters, and platform teams to support agility at scale
• Optimizing team formation for faster decision-making and reduced time-to-market
• Managing dependencies and knowledge sharing to prevent bottlenecks
• Balancing autonomy and alignment through leadership frameworks and best practices

We’ll present real-life experiences and practical takeaways on effectively scaling agile teams while maintaining efficiency and innovation. Target audience: Agile practitioners, engineering managers, software architects. Supporting materials, including case studies and slides, will be provided.

---

Jakarta Data: Simplifying Database Operations for Modern Enterprise Architectures

Session type: ARCHITECTURE

In enterprise software development, productivity is critical to delivering value faster while maintaining high-quality standards. This presentation will show how Jakarta Data empowers developers to achieve more with less code, making everyday database operations—like repository creation, dynamic queries, and multiple pagination—effortless. With Jakarta Data, you can handle these tasks in just a few lines of code, letting you focus on solving business problems rather than writing a boilerplate. Through practical examples and actionable insights, you’ll see how Jakarta Data streamlines development, reduces technical complexity, and ensures your applications are scalable and maintainable. Whether modernizing a legacy system or building new applications, Jakarta Data offers seamless integration into modern Java frameworks, helping you deliver enterprise-ready applications faster and more efficiently. If you’re ready to simplify your workflow and maximize productivity, this session is your next step forward!

---

Beyond data classes: Kotlin-powered domain modeling

Domain modeling is a key part of building robust software that meets the needs of complex businesses. Kotlin is an excellent choice, providing powerful tools to support effective domain modeling. In this talk, we will explore how Kotlin's features make it ideal for domain modeling, enabling you to craft expressive, resilient, and clean domain code. We will dive into features like sealed classes, inline classes, extension functions, and more to show how they can enrich your models, making them more expressive and less error-prone. During the talk, we will refactor real-life code, transforming typical anemic domain structures into something much more idiomatic and effective. Whether you are new to domain modeling or looking to sharpen your Kotlin skills, join me to see how you can boost your domain design with Kotlin.

---

Data-oriented programming with Java

Java has long been associated with object-oriented programming (OOP), but in case of a lot of modern data-intensive applications (like web services), data-oriented paradigm can be a better fit. This talk explores the shift from traditional OOP to data-oriented programming (DOP) in Java, focusing on how recent and upcoming features make working with data more expressive, efficient, and declarative. We will discuss records, pattern matching, and other language features supporting this approach. Additionally, we will explore how data-centric persistence libraries like jOOQ enable working with data structures in a way that moves away from traditional ORM/JPA-based approach. By the end of this talk, you will gain practical insights into application of DOP principles to write cleaner, efficient, and more maintainable Java applications.

---

Spotting Pure Functions in I/O Driven Code

Session type: LT

After a long time with imperative and mainly I/O driven systems the functional programming (FP) style becomes more and more present in my code. I finally realised that even without knowing FP I always searched for simple pure functions. I'd like to share my experiences with you in a tiny sample application. Before diving in I'll define what pure functions are and why we like them so much. We'll refactor the sample application to extract pure functions. During this journey I'll highlight some aspects of what to take special care of in the world of pure functions. I'll show you where you generally find them and increase your awareness of their existence. I hope that you'll look differently at your code after this presentation!

---

5 reasons why you should invest in automatic dependency upgrades

Nobody enjoys dependency upgrades - tedious, risky, and often dismissed as unnecessary. But what if automating them could turn a dreaded task into a strategic advantage? In this short presentation, I’ll reveal why regular and automated dependency upgrades are essential for Developers, DevOps engineers, and Security teams alike. We’ll explore five compelling reasons, grounded in real-world benefits from an (interesting) case study, that demonstrate how automation can improve security, productivity, and system reliability.

---

Back to the Future of Software: How to Survive the AI Apocalypse with Tests, Prompts, and Specs

Great Scott! The robots are coming for your job—and this time, they brought unit tests. Join Doc and Marty from the Software Future (Baruch and Leonid) as they race back in time to help you fight the machines using only your domain expertise, a well-structured prompt, and a pinch of Gherkin. This keynote is your survival guide for the AI age: how to close the intent-to-prompt chasm before it swallows your roadmap, how to weaponize the Intent Integrity Chain to steer AI output safely, and why the Art of the Possible is your most powerful resistance tool. Expect:

Bad puns

Good tests

Wild demos And a new way to look at AI—not as your overlord, but your intern (on a short leash) The machines may be fast. But with structure, constraint, and a little time travel, you’ll still be the one writing the future.

---

Reasoning Models over Agents: Lessons from O3 & O4-mini

Agent frameworks like LangGraph promise autonomy, but they too often collapse under real-world complexity: brittle flows, opaque debugging, limited generalization. In this session I’ll show why reasoning-centric LLMs—specifically OpenAI’s O3 and the lightweight O4-mini—deliver cleaner code and more reliable outcomes by deciding when and how to invoke tools on the fly. Expect practical patterns you can drop into production today—no convoluted agent graph required.

---

Collaborate with Agents: Build Your First Multi-Agent System

---

Stream Gatherers - let's get to know each other better!

The concept of Stream Gatherers introduced as a permanent feature in JDK 24 naturally complements what was missing in the Java Stream API and is the biggest revolution in this area since JDK 8. It is therefore worth familiarizing yourself with the possibilities offered by this solution (and there are quite a few of them!) to be able to increase the flexibility and readability of the code related to stream processing of data structures. During the session, we will try to solve several business problems, both using already built-in gatherers, as well as creating our own.

---

The Art of Benchmarking: Separating Fact from Fiction

In a world driven by data, benchmarks are the key to making decisions - choosing the fastest language, the most efficient framework, or the best-performing library. But can we always trust the numbers? In this talk, we’ll learn what benchmarking means, how it can be done effectively, and the subtle ways results can mislead even the savviest developers. Along the way, I’ll share practical tips to help you dig deeper than the blog posts and tweets. Inspiring you to create your own, hopefully reliable, benchmarks and separate fact from fiction in the benchmarks you see. Whether you're a performance enthusiast or just tired of the benchmark wars, this talk will give you the tools to navigate the truth behind the numbers.

---

Breaking Java Stereotypes: It’s Not Your Dad’s Language Anymore

TBD

---