Mastering Java fundamentals is necessary to create maintainable, bug-proof, high-quality code and advance your Java career.

I've seen many experienced developers write meaningless Java code because they lack knowledge of the Java core features. They reinvent the wheel and write more complicated, confusing, and difficult-to-maintain code.

Join me in this talk so you can prepare for Java interviews and Java certification using the latest Java features in your applications. You will also be well-equipped to create flexible and maintainable code, making you a reference for code quality from your co-workers.

Let's solve the Java code challenges together so you can best use the latest Java features to create high-quality software.

Follow Rafael —

According to Russell Ackoff “A system is not the sum of the behaviors of its parts, but the product of their interactions”. That’s why the design of those interactions is of the uttermost importance. In a Spring application, the primary means to establish relationships between application components is dependency injection (DI). With higher-level structuring approaches like Spring Modulith’s application modules in place, should the interaction of those be implemented by DI as well?

The talk presents different approaches to designing application module interactions and compares them regarding their applicability, effect on testability, consistency, error scenarios and how they affect the modularity of the system overall.

Follow Oliver —

Java's concurrency journey has been a long and winding one. We departed from the 'classic threads' station and traveled through Runnables, ExecutorServices, CompletableFutures and ForkJoinPools, before finally arriving at 'virtual threads'. But does 'finally' mean that we've arrived at our final destination, or is it a transfer at best?

Now that virtual threads are available, our Java programs will likely use an abundance of threads. This increase in thread count will immediately make thread coordination, observability and isolation more difficult. Two new Java features are currently in development that might make things a bit easier: Structured Concurrency and Scoped Values.

In this talk, we'll introduce and demonstrate these new features, and how they can help address the challenges that have emerged since the introduction of virtual threads. We'll also discuss how the availability of these features will impact your day-to-day programming life and whether Java's concurrency journey is actually over now that these features have become available or if there are still more stops to come.

Follow Hanno —

While strong authentication and authorization lay the foundation, achieving robust web application security demands a multi-layered approach. At first glance, the field of web application security can seem daunting, but by understanding and implementing core principles, you can dramatically strengthen your defenses against cyber threats.

In this presentation, we'll delve into the essential, yet often neglected, aspects of securing your applications. We'll cover best practices for secure coding, meticulous input validation techniques, the importance of strategic error handling and logging, how to manage file uploads safely, and much more.

Follow Loiane —

"My Village Chorafakia Akrotiri - a book by Emmanouil Koutrakis son of Giorgos (www.chorafakia.com). Heinz held the book in his hand. It was written in flowery Greek. But not just any Greek. The local village dialect of Cretan spoken in the village of Chorafakia. The book was hundreds of pages long, with almost 500 photographs. Unfortunately, even though Heinz has lived on Crete for 18 years, Greek, and especially Cretan, was still opaque to him. "Would you mind if I translate this book into English?" Heinz asked Mr Manolis confidently. Shouldn't be too hard. Send a copy to Google Translate, and we're done. "With the greatest of pleasure, as long as it doesn't cost me anything extra." And with that, the journey began to try and translate a book about the history of our village Chorafakia into something that Heinz could understand. After several years of wrong starts, we finally managed to convert the entire book to AsciiDoc. We also wrote some Java code that would send each portion to the ChatGPT 4.0 API for translation.

During the talk, we will attempt to translate the entire book of over 500 pages into a new language, as well as show the code that drives everything. The logic for working with the files and for interacting with the ChatGPT API was mostly generated by the ChatGPT AI. We will also look at virtual threads and structured concurrency and show how that was used to accelerate the translation process. We will also demonstrate how the ChatGPT AI built in to IntelliJ can be used to simplify our coding tasks.

Follow Heinz —

Spring Boot 3.x and Java 21 have arrived, making it an exciting time to be a Java developer! Join me, Josh Long (@starbuxman), as we dive into the future of Spring Boot with Java 21. Discover how to scale your applications and codebases effortlessly. We'll explore the robust Spring Boot ecosystem, featuring AI, modularity, seamless data access, and cutting-edge production optimizations like Project Loom's virtual threads, GraalVM, AppCDS, and more. Let's explore the latest-and-greatest in Spring Boot to build faster, more scalable, more efficient, more modular, more secure, and more intelligent systems and services.

Follow Josh —

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 real-world examples that show you how to build self-contained systems using Java and Vaadin.

If you're ready to rethink your architecture and say goodbye to microservice headaches, this talk will show you the way!
He owns Martinelli LLC and has worked as a software architect, developer, consultant, and trainer for three decades, especially in the Java Enterprise environment. In addition to his work, he is a lecturer at the Bern University of Applied Sciences BFH and the University of Applied Science Northwestern Switzerland FHNW on modern architecture and integrating distributed systems, persistence technologies, and DevOps.

Follow Simon —

Have you ever tried to troubleshoot an issue taking a looking at the log files? I bet you did! And it turns out the issue is related to data usage because, you know, users will use real data! Developers won't! A good thing about your recent troubleshooting is that you can understand the data. It's not a bunch of numbers or UUIDs in the name field. How about your development environment? Probably you use either hard-coded data or random strings. We must fix that!

This presentation will show you how to manage testing data in two different ways.

The first way is the creation of a Test Data Factory approach, where we will use the Factory Pattern to easily create any objects we want with understandable and reliable data. This approach will make you in control of your own data, so you can find any bug in the early stages of the SDLC and the DataFaker library will help us to generate good random data in every execution.

In a second way, we will learn and apply the Data-Driven Testing approach, where the same requirement can be applied to different sets of data, generating different results. This approach can reduce the amount of code and the execution time. With the support of JUnit 5 you will learn how to do it in 5 different ways: value source, internal method source, external method source, argument provider, and CVS source.

Follow Elias —

AI is revolutionizing the software landscape. However, for many Java developers, integrating these powerful AI tools into existing enterprise applications or a new one can feel daunting. In this hands-on session, we'll demystify the process and show you how to build LLM-powered features directly into your Java codebase.

Using JakartaEE and the LangChain4j library, we'll dive deep into Retrieval Augmented Generation (RAG), a cutting-edge technique that combines the vast knowledge of LLMs with the precision of your own data. We'll explore how to create both few-shot and zero-shot RAG models, and then add practical features like summarization and similarity search, backed by an Embedding database.

Through a live coding demo, we’ll walk you through constructing an AI-powered online store backend and provide practical insights into the architecture and code.

Whether you're familiar with AI or just getting started, this session will give you the confidence and skills to harness the potential of LLMs in your Java projects.

Follow Bazlur —

This session shows a new tool for interactive computing for Java developers. Up to now a couple of tools already exist for interactive computing or doing interactive experiments with Java:

JShell - terminal
Jupyter with Java Kernel - Web based
JDoodle - web based


The main idea for creating a new tool was to provide a seamless interactive experience to write Java code, interact with the results using a full graphical interface and all this without the tedious process of compiling and running every time you make a small change achieving a lightweight rapid development cycle. JTaccuino is based on running embedded JShell tooling for executing the Java code and provides a library and some packaged default tooling (JTaccuino Pad, JTaccuino Studio) to allow for maximum flexibility and for direct use or integration in existing environments. For the graphical frontend JTaccuino uses JavaFX.

JTaccuino uses the the Jupyter notebook format (ipynb) for persistence to leverage the source code rendering support e.g. on GitHub.

The session will demo the use of JTaccuino and shows different examples of Jupyter like notebooks in Java.

During the demo a special interest will be to show how a tight integration of a library, e.g. JavaFX charting solutions, can be achieved. This will enhance the overall user experience by adding magic things to the running JShell environment like the automatic display of special variable content.