Schedule

What a programmer's job consists of, where the inefficiencies and optimization possibilities are in it, what cognitive load is and how we deal with it.

Java 25 was released on September 16, and according to the tradition of JPoint and Joker, we will analyze all the key changes in detail.

I will trace the path of retries from repeated attempts in real life to their implementation in microservice architectures. I'll tell you how retries have evolved in life, programming, and the Java ecosystem. Which strategies and tools help to achieve reliability, and which ones break everything.

Building your own cloud solution is often considered a rocket science. I'll show you that it's not as scary as it seems.

With the appearance of virtual threads, ThreadLocal is no longer the only solution for context transfer — Java 21 introduced ScopedValue. But when to use what? Which is faster and uses less memory?

If your “hello world” Spring app needs 512 MB RAM and launches in 10 seconds, you’re not building an app — you’re running a memory leak with REST endpoints.

Rich Errors: reinvention of Checked Exceptions. I will tell you the background of the appearance of Rich Errors, what alternatives there are in other ecosystems and why we will never have real Union types.

Let's look at different approaches to loading objects from PostgreSQL.

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

Using examples, I'll show you which metrics I recommend collecting for an abstract web application (for each component, including APIs, databases, and queues) to make it easier and faster to investigate incidents and various performance issues.

We will discuss the issue of the development with Spring in conjunction with JPA, the related performance problem, and also suggest a solution.

JDK Flight Recorder is not a new technology that has undergone several rebirths in its history. The next release of JDK 25 has also not bypassed JDK Flight Recorder and brought with it new features.

Increasing the efficiency of writing code in IntelliJ IDEA using Vim.

Why the service layer should return an Entity, not a DTO. Why fetching small collections can lead to million-dollar datasets. Is it worth fetching deep-nested entities. How turning off autocommit can dramatically increase application throughput.

I will analyze the pitfalls when interacting with Cassandra and show the implementation of an effective consumer for a variety of Kafka topics in one stream.

A modern senior developer working with Spring is simply obliged to understand Kubernetes. In the talk, you will find out what you need to know, what the pitfalls are, what to look for, and how to use deployment tools in Kubernetes.

How we managed to reduce CPU consumption by almost three times, and at the same time reduce the response time to user requests and the actual intensity of allocations.

A practical overview of reactive programming in Kotlin using Flow.

When it comes to OAuth 2 and working with JWT, a lot of questions arise while writing code and you have to remember a lot of nuances. The talk contains everything that Google is most often asked about. For security lovers and understanders, in one narrative using the example of Spring.

Using the example of a classic multithreading task, I will consider some misconceptions related to virtual threads. For this, I will use an engineering approach based on measurements.

I will tell you about the structure and operation of the main debugging tools in JVM. I will give examples of debugging distributed applications, and also tell you about other non-trivial methods of debugging in JVM.

API often has to be checked manually — Postman, curl, Insomnia, HTTP clients in the IDE, each with their own limitations. Connekt combines these scenarios and turns manual checks into live code that is reusable. The talk provides a comparison of approaches and a look "under the hood" of the tool.

How to survive the spontaneous influx of users with new usage scenarios, how to quickly diagnose performance issues inside the JVM, what you may probably encounter in general, and how to avoid issues.

I'll tell you and show you with real-world code examples how we use coroutines and flow at SberDevices to solve non-standard tasks. We'll consider the problem of the transition between the world of callbacks and the world of coroutines. I'll show you how we implemented lazy subscriptions to our backend messages and used them to solve the backpressure problem for a shared queue for messaging with the backend.

I present a library that is developed by me and allows arbitrary control of system time in the JVM. It helps to test the behavior of Java components at different times.

We'll look at Quarkus, Panache, gRPC and other "non-obvious" things. We will discuss where they can be useful, what kind of pitfalls are there and how to expand professional horizons.

I'll tell you how some of the old (compressed oops and compressed class pointers) and new (compact object headers) settings affect actual memory usage, and what to do if your application is approaching the 32 GB limit.

How does source code turn into graphs, how do compilers work with these structures, and how can developers put them to use? We’ll explore the compiler frontend’s internal representations through a practical example of taint analysis.