Java 25 is the next version with LTS support, and with it comes many exciting changes. In this presentation we will do a rapid review of some of the key changes to the JDK from 11-21 and how they have improved developer experience, performance, and supporting Java applications in production. We will then transition to what Java looks like in a post JDK 21 environment, and where Java will be heading to in JDK 25 and beyond!

If you want to learn about the current state of Java and were its heading, this is the presentation for you.

This presentation covers five strategies to help speed up Maven builds, focusing on practical steps like parallelizing builds, optimizing Maven profiles, and leveraging caching. We'll explore how tweaking your configuration can significantly reduce build times. The aim is to provide actionable techniques that developers can immediately apply to make their Maven builds faster—directly impacting productivity by shortening the feedback loop for code compilation and testing wait times.

There are several key techniques to understand while using Kubernetes with Java/Jakarta EE and MicroProfile applications. Examples include:

* How Kubernetes primitives (such as deployments and services) align with application server administration, clustering, and load-balancing.
* How to add self-healing capabilities using Kubernetes probes and monitoring with open standards like OpenTelemetry for logging/metrics/tracing.
* How Kubernetes can be extended using Operators to effectively manage clusters.
* How the CI/CD pipeline of your application can be adapted to Kubernetes.

This entirely slide-free, demo-driven session walks through each of these considerations in turn. At the end of the session, you will have all the demos on GitHub so you can explore them on your own.

Over the last 30 years, Java has been the preferred technology for developing enterprise applications. Frameworks and approaches such as J2EE, Spring Framework, Java EE, Spring Boot, and Jakarta EE all contribute to this success story. 

The Jakarta EE 11, with features for increasing performance and developer productivity, such as support for virtual threads and the new Jakarta Data specification.

This session will give you a history lesson of Enterprise Java as well as an overview of everything brought to you by Jakarta EE 11 with lots of code demos. We will also look forward and check out what's in the pipeline for Jakarta EE 12.

Maintaining a consistent and adaptable technology stack is more challenging than ever. How do you ensure your architecture evolves with business needs, security requirements, and emerging best practices?

This session explores how OpenRewrite, an open-source auto-refactoring tool, powers large-scale software migrations in fintech and beyond. We’ll demonstrate how OpenRewrite recipes are designed to analyze entire codebases, address security vulnerabilities, enforce architectural standards, and seamlessly migrate frameworks and libraries. We’ll also show how these deterministic recipes can be used ‘tools’ in an agentic AI implementation.

Join us to learn how OpenRewrite enables dynamic architecture governance, empowering teams to secure, modernize, and streamline their codebases at scale.

Full-stack development can be intimidating. You need to know several technologies, and you need to know them well. But what if you could build a full-stack web app using only Java? No JavaScript, no HTML, no CSS. Just Java.

Join this live coding session to discover how to develop a full-stack web app using Spring Boot and the open-source Vaadin Flow framework. Starting from scratch, we'll cover everything: persistence, external services, and a good-looking UI. All in Java.

🤖 AI code assistants are everywhere in Java development! They promise speed, but be honest, blindly accepting suggestions or falling into "vibe coding" often leads to confusing code and technical debt. 🤔 

✨ This talk reveals the 7 key habits and critical mindset shifts that separate frustrating AI interactions from game-changing results.

The Golden Rule? Simple: whether you wrote the line or the AI did, you own the code. (git blame doesn't point to 'code assistant'❗) That's habit #1 – come to the talk to discover the other 6!

Knowing these habits with solid checks and a clear view of code quality are non-negotiable.

Join this session to learn the habits that will transform how you build Java code with AI. Walk away ready to make these tools work for you, faster and safer! ✅🚀

Struggling with sluggish databases and Hibernate bottlenecks in your Java applications? Frustrated by complex database designs that force your app into rigid molds? With Java, you can turn performance woes into real-time wins.

We’ll tackle the limitations of databases, latency, scalability, and complexity, and explore a Java-native in-memory data processing approach powered by the JVM. Optimized for fast, memory-efficient processing, this high-speed Java-native data layer runs between your app and database, slashing ORM delays, boosting response times, and effortlessly handling gigantic workloads. 

Learn to simplify development, cut cloud storage costs, and unlock peak performance with this innovative approach, leveraging the JVM’s efficiency to drive next-level Java app performance.

Traditional server databases create monolithic bottlenecks in microservice architectures, leading to high complexity, increased effort, and increased development and maintenance costs.

However, there is an alternative in Java. Imagine lightweight, Java-native persistence perfectly aligned with domain-driven design and microservice principles. Each service gains its own, independent data store, eliminating the "database black hole" and enabling rapid, isolated recovery. 

This approach simplifies microservice development, eliminates database bottlenecks, ORM complexity, and latencies, reduces infrastructure overhead, and fosters genuine microservice autonomy, driving agility and cost-efficiency.

The promise of Reactive programming models is that you can free yourself from the constraints of handling one request for each thread and realize increased throughput as a result. The only problem is that it requires a completely different set of APIs that many developers find counter-intuitive. What if you can achieve the same performance using thread-per-request APIs, and let the Java virtual machine handle the hard work of blocking when appropriate, and executing platform threads when the time is right? Enter virtual threads, a key feature of Project Loom, currently available in JDK 19. In this session, we'll look at how different frameworks, such as Helidon and Quarkus, are using this powerful new feature to increase throughput without requiring reactive programming models.

Microservices are a popular approach to building modern software, offering scalability and flexibility. But for many teams, they come with challenges like increased complexity, difficult debugging, and managing too many small services.

In this talk, we'll introduce an alternative: Self-Contained Systems (SCS). Unlike microservices, SCS allows each part of your application to operate independently with its UI, logic, and database, simplifying both development and deployment.

You'll learn why SCS can be a better fit for many projects, how it reduces the complexity of distributed systems, and when it makes sense to use this approach over microservices. We'll also dive into my current customer project which shows you how to build self-contained systems using Java and Vaadin.

In the realm of Java programming, understanding memory management and garbage collection mechanisms cannot only be helpful for optimizing performance and resource utilization but also in general will help you to use the right garbage collector for your application. This session will be about memory allocation, object lifecycle, and garbage collection strategies within the Java Virtual Machine (JVM). Attendees will gain insights into memory allocation strategies, object retention policies, and various garbage collection algorithms like generational and concurrent collection. So when you are interested in getting more knowledge about which garbage collector to use best for your application or about memory management in the JVM, this session is for you.