Schedule

Let's analyze and compare the current garbage collection algorithms in Java and Go.

Let's see how to replace ENVs with more secure mechanisms for obtaining secrets.

A talk on the evolution of the S3-compatible storage metastore for billions of objects, architectural patterns and errors along the way. How background operations and statistics collection are performed efficiently.

I'll show you Nullaway, an extremely smart static nullability analyzer.

A Spring Boot starter is more than just @AutoConfiguration. We’ll explore how to build one without causing chaos in your ecosystem.

Let’s talk about how we built a reliable and predictable request/reply mechanism on top of Kafka, using only the client and broker’s standard functionality.

How to implement a native Rust engine in a Java application via Project Panama (FFI). Practice and pitfalls.

We will look at all the latest features: from AOT repositories and composite keys to Single Query Loading, and will talk about dreams related to the Scrolling API, and about the problems in implementing all these features.

Let's discuss what coroutines are in pure Kotlin (without additional libraries!), and as the most illustrative example, we'll use them to build our own iterator { ... } function from the Kotlin standard library.

A talk on AI copilots and IntelliJ IDEA: let's look under the hood of popular agents and see how the classic IDEA mechanisms (AST, PSI, indexes) enhance LLM. At the intersection of proven IDE APIs and AI, benefits are born—listeners will learn how to connect this in practice.

When intuition fails and the logs are silent, Spring Boot developers are left to guess. The days of guessing are over. Meet Axelix—an open-source "scout" within the ecosystem. It monitors your Spring Boot instances and builds an interactive map of your applications in real time.

During the workshop, we will analyze a real task from fintech.

We want to talk about each stage of increasing the load and bring the service to a situation in which there are no standard solutions anymore.

What could be more unpleasant than failures and failures of your Java service in production? Basic monitoring and the ability to develop metrics for Spring Boot microservices will be your faithful assistants in the difficult investigation of incidents. But do you know how to develop your own metrics and design dashboards for them in Grafana?

Let's look at why the Spring MVC service can freeze when the CPU is low: the queue accumulates not in the processor, but in Tomcat/Hikari/HTTP pools and waits for external dependencies. You'll get a minimal set of metrics (RED+USE), a short diagnostic playlist, and practical fixes: timeouts, bulkhead/limits, pool matching, and saturation alerts.

I'll show you different Outbox implementations.

Tired of reviewing the code? Connect the AI! But don't be surprised if he starts spamming. 

From a failed pilot to a production agent: how we created an automatic code review system for Spring AI. I'll show you why the most sophisticated prompt engineering is not an option, how architecture and limitations make AI "smarter" and how we taught the bot to leave only really useful comments.

About the one-nio serialization/deserialization framework and its architecture. From its origins to JDK 25 support: Unsafe, MagicAccessorImpl, Var/MethodHandles.

Don’t wait for a 3 AM production alert to find your race conditions. Master JCStress, Lincheck, and Fray before the users do.

The talk will cover the practical challenge of scaling up code agents—from individual local deployments to large-scale experiments, reproducible quality assessment, and the generation of synthetic data for training.

A talk on optimizing write performance in Apache Cassandra.

The report is a top-level overview of optimization approaches that modern Java frameworks use to speed up work on the JVM.

Advice that various AI assistants give on improving the code.

A talk about a custom language for a data processing platform and its Java-based engine. How to create such a language using JetBrains MPS and use it as a development environment. The talk will include practical examples of creating the language and implementing its elements in Java.

With the help of Claude Code, we will write a personal database that will not be inferior in performance to leading solutions.

Why does a single missing bracket sometimes cause the entire IDE to crash, while at other times it makes almost no difference? Let’s explore how Java parsers recover from errors, how to measure the quality of this recovery using real-world data, and why metrics that seem obvious at first glance can lead to incorrect conclusions.

We will show you how to build an application to automate writing tests on the Kotlin Multiplatform stack, Compose, and the Koog agent framework.

We will tell you how we provided the agent with the execution time data and what came of it.

The G1 garbage collector was introduced in Java 6 in 2009. Since then, it has been rewritten several times. We will trace the history of its implementation to understand how it works and its limitations.

I'll tell you how we eliminated a serious drawback of serialization with the One Nio library: ignoring custom methods designed for standard Java serialization.

I will also tell you about the elimination of one of the limitations of the One Nio serialization algorithm, which made it possible to do this even faster.

Summing up the results of the conference, remembering the highlights and talking about plans. Come to the conference hall or join the broadcast so you don't miss anything!