Talks

Using Spring Boot applications support in AOT-centric JVM Excelsior JET as an example, Nikita will show how Java dynamic properties being used in Spring Framework can work together with AOT-generated machine code.

Writing and maintaining tools on bytecode level should always be guided by comprehensive tests. We will learn how bytecode manipulation can be implemented in a test-driven approach and with many code examples see practical techniques for real projects.

We'll tell how Kafka's designed and how we've been learning to use it properly.

We'll discuss several capabilities of IntelliJ IDEA: analyzing code, debugging apps, and structural search (and replace).

A thorough analysis of Vaadin Flow internals and the search for pitfalls.

Come and learn from a hands-on practitioner real-world best practices of using Aspects, design hints, under-the-hood implementation details, debugging tips, performance impact of aspects, all in an interactive, entertaining and extremely dynamic session.

You will learn why RSocket is an innovative solution for cross-server communication, how we can improve gRPC using RSocket, and why you should start using RSocket today.

The Axon platform offers an unique, scalable way to build microservices. We'll talk about the main concepts behind Axon, focusing on how it addresses performance-related aspects of CQRS and event sourcing.

Dmitriy will share with you his personal experience of developing disk intensive applications and the peculiarities noticed during the development of Apache Ignite Native Persistence Store. This talk is aimed at experienced developers who need maximum performance when working with the disk.

We'll discuss in which cases JVM TI can help developers, including common Java applications. We'll learn about the capabilities of the interface, including new features from Java 9 and 11, and create our own tool. Using the real-life cases as an example, we'll see what JVM TI issues developers encounter and how to solve these issues.

Andrzej will talk about agent based modelling, from the point of view of a developer building the framework, focusing on some interesting, non-trivial or plain old surprising experiences he's getting building a JVM-based agent-based modelling SDK at Simudyne.

The talk will walk the audience through the basics of creating a new collection, adding new collection-specific API, the salient aspects of the new collection, lastly, the various knobs and controls which are required to make it safe and usable.

We will consider the practical application of Java 11 functionality in a container environment typical for popular frameworks.

We'll look at all the areas of JDK 9, 10, 11 and 12 that may impact application migration and also how the new JDK release cadence will impact Java support and the choices of which Java versions to use in production.

This session will first provide the background to the new HTTP Client API, its history and evolution through JDK 9 and JDK 10, then moving on to the specifics of what has been standardized in Java SE 11. The audience will learn how to use the API to perform common tasks.

We'll share our experience of using Netflix OSS stack and switching to Kubernetes.

True software сraftsmen can be an order of magnitude more efficient than narrowly skilled developers. They not only write code, but solve problems. Surely you want to be one. Let's break it down and see why it works.

We don't have ACID transactions in distributed systems which affects every developer's daily life. In this talk, Bernd tells about how to cope with consistency challenges in modern architectures.

We can often divide the refactoring process into atomic steps, or transactions; after each step the semantics is saved. The smaller these steps, the shorter the "broken" condition of the program, the lesser is the possibility of an error. We'll see via examples how to achieve this during the Java code refactoring in IntelliJ IDEA and how to make your environment do atomic refactoring if it resists.

Kohsuke, the creator of Jenkins and CTO of CloudBees, will walk you through what exciting new Jenkins projects are aiming for, how they work together to make you even more productive.

Programming in a reactive style can turn your code into an unmaintainable abstract mess, obscuring business domain.

We will discuss best practices for Java code shapes and compiler configurations to maximize performance with GraalVM and how to measure performance in a reliable manner.

The goal of this presentation will be to understand when, how, and why to adopt serverless technologies.

Oli introduces Mu, a new FP library for building web services aiming to make it painless.

We'll look at the process of decomposing a Java application into reusable components, ending up with application design that has good chance to evolve over the years without introducing additional accidental complexity.

A concise set of practical suggestions on how to move Spring Boot microservices from Java 8 to 11.

Charlie will describe how you can use Eclipse OMR technologies to easily create an interpreter for a new or existing runtime and get a JIT for free!

We'll discuss which channel algorithms other programming languages and libraries use, how we in Kotlin develop our own solution, which challenges and subtle aspects we encounter in the process and what we managed to achieve.

Since it's impossible to entirely remove all bugs from any software package, how do we know when it's time to stop testing and release the product to its end-users?

This sessions shows how to implement service-meshed applications using Java EE 8 and MicroProfile. It also includes how to integrate the required cross-cutting concerns, such as monitoring, tracing, or resiliency into our applications, where developers have to actively integrate technology themselves and where the platform support us.

Recent Gradle releases give you new capabilities to greatly improve the speed of your Java project build. We will discuss and use real builds to demo how you can identify performance bottlenecks, reduce build configuration time dramatically, take advantage of advanced features, and track build performance over time for your whole team.

A complete overview of Java agent development.

If you are going to create a working application using Kafka Streams, you'll need to learn quite a few things. We'll try to answer the emerging questions, examining along the way several demo examples using Spring framework.

We'll explain the fundamentals of local variable type inference and then take a series of examples of the use of var and discuss the technical merits of each case.

We'll talk about Truffle — framework for creating programming languages on the basis of GraalVM. Details of its work can help you better understand how languages supported by GraalVM — JavaScript, Ruby, R, Python — work and how they should be used.

That's a talk about Pavel's exploration of Kotlin's entrails, and about result of compilation of our code. What is a cost of constructions we're used to use? What dangers do they hide? You can find some answers in this talk.

You've never heard of BlockHound? Or you've heard about backpressure, but aren't sure it works in your code? Maybe you want to prepare your code in advance, in case something goes wrong in production? Or you just want to watch Reactor developers working with their product and learn a couple of cool tricks? Then this talk is for you!

With all the latest genetic engineering achievements, are we going to play God like this or is it time to outplay him?

It has never been like this and now it is exactly the same again: production crashes! Or just runs slow. It may be JIT compiler did something unexpected. We'll discuss how to manage its actions and how to analyse cases when something goes wrong.

As an example we'll discuss a system with problems and, naturally, try to refactor it in reactive manner. We'll cover benefits and drawbacks of not only the approach, but also API of specific implementations. We'll evaluate the level of complexity before and after refactoring. We'll try to learn what is joke and what isn't.

Nikolay will tell why they believe development of Kotlin/Native makes sense despite the wide variety of existing compiled languages.

We are going to create a functional and blazingly fast microservice, using functional programming abstractions to quickly mix & match different HTTP libraries, state implementations and concurrency configurations.

This session shows which non-functional requirements we enterprise developers need to be aware of to build stable and resilient applications.