• Watch recording
    Talk

    The Proxy fairy and the magic of Spring

    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.

  • Watch recording
    Talk

    Performance aspects of Axon-based CQRS/ES systems

    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.

  • Watch recording
    Talk

    Efficient file-based IO for Java developers

    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.

  • Watch recording
    Talk

    JVM TI: how to create a "plugin" for a virtual machine

    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.

  • Watch recording
    Talk

    Do it yourself: Collections

    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.

  • Watch recording
    Talk

    JDK 12: Pitfalls for the unwary

    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.

  • Watch recording
    Talk

    Java 11 reactive HTTP Client

    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.

  • Watch recording
    Talk

    The world needs full-stack craftsmen

    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.

  • Watch recording
    Talk

    Atomic refactoring in IntelliJ IDEA: Bending IDE to our will

    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.

  • Watch recording
    Talk

    Decomposing Java applications

    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.

  • Watch recording
    Talk

    A tale of how we did channel algorithm in Kotlin Coroutines

    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.

  • Watch recording
    Talk

    Software testing pitfalls

    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?

  • Watch recording
    Talk

    Cloud native, service-meshed Java Enterprise with Istio

    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.

  • Watch recording
    Talk

    Improve Java build performance with Gradle 5

    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.

  • Watch recording
    Talk

    Kafka Streams API: Moving beyond Hello World

    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.

  • Watch recording
    Talk

    Local variable type inference: Friend or foe?

    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.

  • Watch recording
    Talk

    Kotlin: how do usual constructions work

    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.

  • Watch recording
    Talk

    Don't be Homer Simpson to your Reactor!

    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!

  • Watch recording
    Talk

    Java is slow: CodeCache edition

    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.

  • Watch recording
    Talk

    Reactive, or not reactive: that is the question

    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.

  • Watch recording
    Talk

    Fast & functional

    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.