Abstract

Java bytecodes and class files deliver on the original vision of “write once, run anywhere”. Using a Just-in-Time (JIT) compiler allows JVM-based applications to compile only the code that’s being used frequently and optimise it precisely for how it is being used. Using techniques like speculative optimisation can often deliver better performance than static, Ahead-of-Time (AOT) compiled code.
However, this flexibility and performance comes at a cost. Each time the JVM starts an application, it must perform the same analysis to find hot spots of code and compile them. This is referred to as the application warmup time.
In this session, we’ll look at several approaches to how this problem can be alleviated or even eliminated. Specifically:

• Generating a JIT compiler profile of a running, warmed-up application that can be reused when the same application is restarted, eliminating the need for much of the JIT compilation.
• Decoupling the JIT compiler from the JVM for a Cloud environment. Providing a centralised JIT-as-a-Service allows caching of compiled code and offloading the compilation work when new code must be compiled.
• Creating a checkpoint of a running application. This includes all application state (heap, stack, etc.) in addition to the JIT-compiled code. Project CRaC will be used as an example.

Abstract

The classes of the Java Collections Framework are arguably the most heavily used data structures on the planet. In their 25-year lifetime, they’ve become part of the everyday vocabulary of millions of programmers. But, actually, how good are they? And how have they changed, to fit with the changing direction of the language towards a more functional style?

To answer these questions, this session will preview some of the material in the upcoming second edition of Java Generics and Collections: the sequenced collections introduced in Java 21, use cases for the unmodifiable collections of Java 9, best practices for using the framework, and a design retrospective distilling the experience of a quarter-century’s use of the Framework. This session should give you a better understanding of the design forces that shaped the Framework, and an improved ability to get the very best out of it.

Abstract

Here we are, creating a whole new project from scratch and no legacy hindering us. But wait, should I use Spring Boot, Quarkus, Micronaut,... What is happening in the Java ecosystem? What do I do?

On this talk we are going to create a (simple) app on those frameworks and compare pros and cons. We will build the native version, compare the source code and dependencies, and, probably, find out that the real treasure is the code we made along the way.

Abstract

Pattern matching in Java makes use of the instanceof and switch syntax, so that programmers can leverage their existing knowledge to easily master the new features. At least that's the theory. In this session, you will see, through a series of increasingly challenging puzzlers, how the pattern matching process works under the hood and just how complex the interactions between classic and modern features are. You will come away with a thorough understanding of the mechanisms and limitations of the pattern matching features that have been gradually added between Java 14 and 21, as well as those that are still contemplated for future versions. You will also learn best practices and style recommendations so that your code is not a puzzler for your peers.

Abstract

Enterprise applications are complex. A transaction starting in the browser will go through proxies, api gateways, security appliances, application performance monitoring tools, logs, microservices and more microservices. Historically there has been no standard way to get observability and traceability between all the enterprise components. Each product and framework has it's own proprietary way of identifying a transaction making it difficult if not impossible to stitch together a complete picture of a transaction. This is changing with the introduction of the W3C Trace Context standard and the open source initiative of OpenTelemetry.

In this session, you will learn how using Trace Context, OpenTelemetry and other open source and commercial products can improve your observability to help you better triage production issues, improve performance, be proactive and make your users happier.

Abstract

Use Spring Boot! No, use Micronaut!! Nooooo, Quarkus is the best!!! What about Helidon?

Many developers praise the hottest and fastest Java REST frameworks: Micronaut, Quarkus, Spring Boot, and Helidon. In this session, you'll learn how to do the following with each framework:

• Build a REST API
• Secure your API with OAuth 2.0
• Optimize for production with Docker and GraalVM


I'll also share some performance numbers and pretty graphs to compare community metrics.

Abstract

Our cloud-native environments are more complex than ever before! So how can we ensure that the applications we’re deploying to them are behaving as we intended them to? This is where effective observability is crucial. It enables us to monitor our applications in real-time and analyse and diagnose their behaviour in the cloud. However, until recently, we were lacking the standardization to ensure our observability solutions were applicable across different platforms and technologies. In this session, we’ll delve into what effective observability really means, exploring open source technologies and specifications, like OpenTelemetry, that can help us to achieve this while ensuring our applications remain flexible and portable.

Abstract

We don’t have to exert much mental effort when writing blocking code, but this has drawbacks. Non-blocking code, on the other hand, could be used to increase application throughput. This is why non-blocking code is recommended in many scenarios. Over the last two decades, many approaches have been introduced to writing code that does not block.

In this session, we will look into those options that are available to us. To begin, I’ll go over the evolution of the Java concurrency model since its inception with the vanilla thread. Then I'll talk about Future/Callable and CompletableFuture, talk briefly about reactive programming, and end with Project Loom, which was added to Java 19 this year.

Abstract

Flow state, cognitive load, and speed of feedback loops are three core dimensions of developer experience. Taken together, they encapsulate almost all friction encountered in the development process.

However, these can be hard to measure and sometimes straightforward to improve.

In this session, we show how tests, the test suites' quality, and running test experience cover all three core dimensions and enable high-performing teams.

We look at anti-patterns for tests and how they drastically increase the cognitive load required even for the most straightforward changes and slow down feedback loops. Then we show how modern high-quality test setups ensure developer productivity and happiness and drive team velocity up and to the right.

Abstract

This session details the practical approach used to analyze the performance of web applications. This session explains the general principles of performance analysis, such as how to set up a load benchmark, what tools should be used, the USE method, flamegraph generation and their analysis, with examples drawn from the work done in Jetty 12.

Abstract

Learn important new features of Jakarta EE 10, along with strategies for migrating from older versions of Java EE and Jakarta EE. Jakarta EE 10 includes a number of new features, and this presentation will dive into some of the most important ones, providing examples through demos. After going through some of the new features, some strategies will be shared for upgrading older applications to Jakarta EE 10. This session will also demonstrate how to upgrade an application from Jakarta EE 8 to Jakarta EE 10.

Attendees will walk away with a solid understanding of some of the most important features of Jakarta EE 10 and better understand how to migrate to the latest Jakarta EE release.

Abstract

Virtual threads will be very likely the next big game changer in the Java ecosystem, allowing to have the scalability of asynchronous programming models with the simplicity of synchronous code. Their main claim is that, differently from native threads that are a costly and then scarce resource, you can create as many virtual threads as you want with known and much cheaper memory and performance impact than the native ones. But is this always true? What are the costs of scheduling thousands or even millions of virtual threads? Does the more frequent context switch have some performance implications? What about the cache misses that these context switches could potentially imply? During this talk we will try to answer these questions in a funny way, by analyzing an implementation of the traditional Conway's Game of Life based on the communicating sequential processes (CSP) model and using both virtual and native threads with different algorithms in order to compare their performances. Based on this analysis we will also try to derive some rules of thumb on when and how using virtual threads.

Abstract

Java is innovative with each release, and to become a creative engineer for your company, you should know what is new in your language. This session will sweep the dust off Java SE's 19 hidden gems, including new cool language features, compiler changes, library additions, and critical bug fixes, and they're handy in your day-to-day work.

Abstract

Jakarta Contexts and Dependency Injection is probably the most underrated specification around. It is the Jakarta EE and MicroProfile corner stone since it provides a standard programming model and a powerful to integrate third party technology in a seamless way.

Now that major work on CDI 4.0 is nearly over (waiting for Jakarta EE 10 release), it’s interesting to list the evolution of the spec in the last year.

In this talk we’ll go thru all new and corrected features in the specification and will make a big focus on CDI lite that will enhance CDI spec to better support build time framework like Quarkus.

We’ll go thru the new portable extension API with a concrete example, and we’ll see how it differs from legacy runtime portable extension.

You’ll leave the talk being able to develop CDI Lite extension for your favorite framework integrating it to the CDI programming model.

Abstract

One of the most common reasons for software defects is poor exception handling. The more complex the application, the more difficult it can be to track down the root cause of a bug. An exception at the service or database layer may manifest itself as unpredictable behavior at the user interface level. Simple coding errors or unexpected inputs may result in unnecessary and confusing error messages. The net result is an application that doesn't meet the user's expectations. These types of issues can be avoided by handling exceptions properly. In this session, we'll look at examples of what happens when exceptions aren't handled, and how you can avoid unexpected defects by following a few key principles and using some discipline. We'll also examine the importance of establishing logging standards, and look at how to properly configure error pages and use the error handling facilities in back-end Java services and web apps.

Abstract

Graph Theory, Operating Systems, Data Structures, State Machines are usually boring subjects and useless topics for a developer, right? Wrong! Let's find out how those concepts are implemented inside most popular Java frameworks, such as Spring. Let's explore how those concepts can be key concepts to your career and as much as you become a senior developer, you must study and domain all these fundamentals. In this session Professor Isidro will show Isi-Spring (a cacophony for "easy", the main reason to explain complex features on a simple way).

Abstract

Spring Framework 6 and Spring Boot 3 are almost here and you know what that means? New .jars! And also new baselines and new possibilities! Spring Framework implies a Java 17 and Jakarta EE baseline, and offers new support for building GraalVM-native images. It also offers a new observability layer, an amalgamation of some of the work in the Micrometer project and Spring Cloud Sleuth. Spring Boot 3 builds upon all of this, and integrates all of this into our application. Join me, Spring Developer Advocate Josh Long (@starbuxman), and we'll look at next-gen Spring.

Abstract

In the early days of computing, software developers had to encode their programs on punch cards, and carry the bits around by hand. By the 1970s they had the joy of keyboards and displays. Sadly, those oppressed developers had to wear flare trousers, work in C, and manage their own memory. By 2000 the memory thing was sorted out, but the trousers were arguably worse, and developers had to maintain their own hardware. Now, our hardware is someone else’s problem, everything is open source, AI can write our code, and we have a choice whether to work in Java, Kotlin, Javascript, Ruby, Go, Python, Rust, or Typescript. On the other hand, now we have yaml. And many of us find we have to work in ALL of Java, Kotlin, Javascript, Ruby, Go, Python, Rust, or Typescript, all while managing a cloud, becoming security experts, learning CSS, and debugging the code our AI “helper” wrote. And we’re supposed to be full-stack, and shifting left, and building up open source in our free time. Are we living the dream or sinking under cognitive overload? And is open source helping or hurting?