Schedule
Your success is ours! This is our business model!
Small Sessions
Our conference includes small sessions of 30min each (Talk + Q&A), delivered by speakers from all over the world, two panels, and various competitions. The following timetable is based on GMT.
Hour
Speaker
Talk
07:00 GMT
Welcome Talk
Welcome Talk
The conference will start with a short welcome talk. During this talk we will go over the schedule and provide more information about the various activities.
07:05 GMT
Sergio del Amo Caballero
Getting Started with the Micronaut Framework
This session introduces the Micronaut framework and demonstrates how the Framework’s unique compile-time approach enables the development of ultra-lightweight Java applications. Compelling aspects of the Micronaut framework include: + Develop applications with Java, Kotlin, or Apache Groovy + Sub-second startup time + Small processes that can run in as little as 10 MB of JVM heap + No runtime reflection + Dependency injection and AOP + Reflection-free serialization + A database access toolkit that uses ahead-of-time (AoT) compilation to pre-compute queries for repository interfaces. + Cloud-native features. Sergio will also demonstrate how you can generate GraalVM native images of your Micronaut applications to achieve instant startup and ultra-low memory footprint.
07:35 GMT
Ivan Yonkov
Reflection is Dead, Long Live Annotation Processing!
Have you ever encountered a piece of code that is difficult to debug because it obscures what is actually happening, such as “method.invoke(obj, args)”, surrounded by other mysterious operations? You are not alone; thousands of developers face this same challenge. The Java Community Process proposed a specification (JSR-269) almost two decades ago for a pluggable annotation processing API integrated into the Java Compiler. This API moves dynamically generated functionality to actual, physically generated code, making it visible and debuggable as-is. Not only is this approach more readable, but it is also significantly faster. Despite being available for so long, this feature is not widely used in projects that require metaprogramming, particularly for generating functionality based on information from annotations. Many popular frameworks still rely heavily on runtime dynamism, such as Reflection. In this session, we will aim to shift the mindset towards compile-time processing of annotations and explore the challenges one may face when leveraging the compiler in modern versions of Java.
08:05 GMT
Steve Poole
Hidden Security Features of the JVM – Everything You Didn’t Know and More
Java 17 announced the depreciation of the Security Manager (which is okay since hardly anyone used it), but that doesn’t mean the JVM leaves you vulnerable. There are many design features in the JVM and the JDK that help keep your application safe from harm. In this session, we’ll walk through these points – from compiler to bytecode to runtime and give you a refresher on how to get the best from these features. We’ll also look at new things in the works, compile-to-native consequences and even some off-the-wall “it’s just an idea” thoughts about how to make the JVM an even more secure environment.
08:35 GMT
Kahoot Quiz
XtremeJ Kahoot Quiz Competition
We are going to have a small Kahoot-based quiz competition. The competition will take place online and it will include quiz questions. The points are given in each quiz question in accordance with the correctness and the speed of answer.
08:55 GMT
Hackaton
XtremeJ Hackaton
Our small hackaton includes a question in which you need to write a small program that answers the question we created. The winner is the first that answers correctly this question. The winner will be announced at the end of the conference.
09:00 GMT
First Break
First Break
09:30 GMT
Marián Varga
12 Overlooked API Details that Can Get You in Trouble
API design and implementation are skills that are usually treated as just parts of mastering an implementation language like Java. Poorly thought-out API decisions or APIs driven by implementation framework defaults can lead to maintainability, security, or performance problems that are hard to fix once the APIs are already in use. In my talk, I will show real-world examples of APIs that work well at the beginning, but can be the source of unexpected problems later.
10:00 GMT
Haim Michael
Beyond Java: Evolving to Scala and Kotlin for Modern Development
This talk will focus on key considerations for developers deciding whether to transition from Java to Scala or Kotlin. We’ll discuss the strengths and trade-offs of each language, highlighting what developers should understand about syntax, learning curves, ecosystem support, and use cases before making the choice. Whether you’re aiming for functional programming with Scala or Kotlin’s modern, pragmatic approach, this session will equip you with the insights needed to make an informed decision.
10:30 GMT
Birgit Kratz
.
By the Bye: JNI
Many years ago I was working for a project in which we had to integrate a program written in C into a web application written in Java. The C program was doing complex financial calculations, developed over many many years. No chance to rewrite it in Java. The solution was to integrate it via JNI (Java Native Interface). Painful memories to this day. Reading and writing programs with JNI is very “rough” (to say the least) and has many traps and pitfalls. With project “Panama” and the new “Foreign Function & Memories API” (FFM) Java is aiming to address exactly these pain-points when working with code and data outside of the JVM-runtime. This new API has made me curious. In this talk I want to compare the native calls using JNI and the new Foreign Function & Memories API. How does it feel and does FFM keep its promises? I hope (and believe) that at the end of this comparison there will be a definite “Goodbye to JNI”.
11:00 GMT
Kahoot True False
XtremeJ Kahoot True Flase
We are going to have a small Kahoot-based True False competition. The competition will take place online and it will include True False questions. The points given in each question is in accordance with the correctness and the speed of answer.
11:25 GMT
Breakout Room
XtremeJ Breakout Room
The Breakout Room game takes place online. The participants in this game will need to find their way out by overcoming a digital lock. The first that succeeds to overcome the digital lock wins the game. In order to overcome the digital lock the participants will need to code various small programs in Java.
11:30 GMT
Second Break
Second Break
12:00 GMT
Simon Martinelli
CQRS Meets Modern Java
The Command Query Responsibility Segregation (CQRS) is a proven design pattern that enables the clear separation of data changes (commands) and data queries (queries). This separation allows these responsibilities to be scaled and optimized independently. The application code is also structured more understandably, which improves maintainability. This talk will deepen our understanding of the practical implementation of the CQRS principles using modern Java language features such as records, sealed classes, switch expressions, and pattern matching. An example application will demonstrate how the theoretical foundations of CQRS can be applied in practice and how this affects application design while increasing data access efficiency.
12:30 GMT
Andres Sacco
Using a Martial Art to do Tests
During this talk, you will see the relevance of creating integration/end-to-end tests so that the developers can change the application’s behavior and detect possible problems. Most developers use different alternatives connected with some particular framework or library, so they must write all the tests again when they decide to move to another one. You will see a short scene where you have an application where you will define the test using Karate in a way that is agnostic to the framework with the possibility to reuse the scenarios of the difficulty to create some performance tests and detect possible problems related to the use of resources or the latency.
13:00 GMT
Jennifer Reif
Pouring Coffee into the Matrix – Building Java Applications on Neo4j
Many of us have built applications for traditional data structures (like relational database tables), but is it different for graph data stores? Do developers need to retool and relearn? In this session, we will cover a brief intro to graphs, walk through writing a typical Java application with Spring, and then connect it to a graph database. From interacting with the graph data from the application to deploying to the cloud, we will see the process from start to finish. We will learn how to tackle pitfalls and pick up tips along the way, as well as explore the ways we can build, deploy, and connect applications to the database. This will come alive through a live demo, as we see the results of our efforts. Come to this session to build your business applications for graph data!
13:30 GMT
Kahoot Simple Answer
XtremeJ Kahoot Simple Answer
We are going to have a small Kahoot-based Simple Answers competition. The competition will take place online and it will include questions with simple short answers. The points given in each question is in accordance with the correctness and the speed of answer.
13:55 GMT
XtremeJ Championship
XtremeJ Championship
We will introduce the XtremeJ championship, which includes a questionnaire with various programming questions about Java. The winner is the first participant to answer all questions correctly.
14:00 GMT
Third Break
Third Break
14:30 GMT
Geetha Anne
Exploring Durable Execution in Software Systems with Temporal.io and Java
Distributed systems, which involve multiple components running on different servers or even different data centers, are notoriously challenging to manage due to issues like network latency, failure handling, data consistency, and more. Temporal.io provides a framework that abstracts away many of these complexities, allowing developers to focus more on business logic rather than the intricacies of distributed system coordination and state management. Temporal.io’s Java SDK offers developers the tools to build applications using the Temporal platform with Java. The Java SDK lets developers define activities and manage their execution, including retries and error handling. In this session we will show you how the temporal.io Java SDK is a powerful tool for developers looking to build distributed applications and systems, offering a combination of reliability, scalability, and fault tolerance that is hard to achieve with traditional approaches.
15:00 GMT
Hugh McKee
Are Your Microservices Small Balls of Mud?
Microservices continue to gain tremendous popularity given their potential benefits, such as independent deployability, polyglot implementations, and alignment with team organization. However, more organizations are finding that microservices introduce significant complexities, especially at scale. It’s easy for microservices to become an entangled mess of poor abstractions, failed transactions, unreliable communication, and technical debt accrued across versions. In this talk, I will make the case that many microservice implementations suffer from being small balls of mud. You will learn the telltale signs of systems exhibiting this anti-pattern, like services knowing too much about each other, brittle synchronous messaging architectures, failed deploys, blocking teams, and more. I propose event-driven architecture as an alternative model that solves many microservice woes. We will compare synchronous and asynchronous messaging approaches. I will use nontrivial example design and code reviews to demonstrate how event-driven services remain decoupled using publish/subscribe messaging. I will also showcase transactional consistency benefits using event sourcing/CQRS patterns. And more. You will leave recognizing mud in your systems and equipped with practical architectural guidance to incrementally evolve towards event-driven services. By swapping microservice mud for event-driven clarity, teams can scale complexity without getting stuck. Join me as we explore whether events offer the missing pillar for reliable, sustainable microservice architectures.
15:30 GMT
Fabio Turizo
Securing Microservices under 40 minutes with MicroProfile & Keycloak
Implementing the correct security patterns is a common challenge that most application developers and consultants can get wrong in even the most common of scenarios. Reinventing the wheel is a common pattern that DevOps engineers do when integrating security solutions inside their applications (authentication, password validation, identity management, correct storage of user data, etc.). Keycloak is an open-source identity management solution that focuses on offloading this burden from DevOps engineers, allowing them to focus on the business aspects of their applications and simplifying their solutions in the long run. This talk will focus on the benefits of using such a service with an enterprise application, with a live demonstration of a small application that uses the Eclipse MicroProfile APIs to correctly integrate it with Keycloak by way of the OpenIDConnect standards.
16:00 GMT
Xperts Panel
The AI Revolution in Coding: Tools, Trends, and Tomorrow
In this engaging panel, a team of industry experts will explore how AI is reshaping the coding landscape. From enhancing developer productivity to transforming software development practices, this discussion will dive into AI-powered tools, automation, and the future of programming. Join us for insights on how AI is influencing the way we code and how developers can leverage these advancements to stay ahead in the evolving tech ecosystem.
The panel participants are:
Victor Rentea. Andres Sacco Mary Grygleski Tomasz Manugiewicz
16:25 GMT
Closure Talk
Closure Talk
This talk concludes the conference. During this 10 minutes talk we will also announce the winners in the various competitions XtremeJ included.
Your Success is Ours!
We will do our best to serve your needs! This is our business model!
