Quarkus at Devoxx UK 2025

[insectengine]

Event Description: Come to Devoxx UK to meet with expert practitioners from around the world and delve into the most vital programming topics together. Expect to discuss groundbreaking developments in Java, Cloud, AI, Data, Security, Architecture, Programming Languages, Methodologies and Developer Culture.

Date: May 7-9, 2025
Location: London, England
Event Type: In Person

https://www.devoxx.co.uk/

Wednesday Quarkus Sessions

Session: Evolution of Java Code Execution
Speaker(s): Ben Evans
Date/Time: Wednesday from 11:00-11:50 in the Auditorium
Track/Level: Conference (INTERMEDIATE level)
Abstract: The two main services that any JVM provides are (mostly) hands-free memory management and an easy-to-use container for managed execution of application code. In this talk, Ben Evans will explain what the term "managed execution" really means, how that concept has evolved in the 30 years since Java was first released, and where it is going.

We currently live in exciting times, as the transition to Cloud-first invalidates quite a few of the assumptions that were baked into Java's initial design. The classical picture of interpreted bytecode -> JIT compilation (& warmup -> steady state) no longer satisfies.

There are a number of efforts to respond to this, and we will try to address as many of them as we can during the talk. Of particular interest is build-time shifting - as seen in technologies like Quarkus, as well as the concept of constraining dynamism as is being developed in Project Leyden.

• A brief history of Java program execution
• Dynamism and the Open World
• What changes the Cloud has brought
• Immutable images
• Livestock not pets
• Responses
• AOT (& Mechanism vs Outcomes)
• Quarkus
• Project Leyden
• A wildcard - iOS?
• The situation in 2025
• The Future - standardisation?
• Conclusions

Session: Create AI-Infused Apps with LangChain4j (and Quarkus)
Speaker(s): Daniel Oh, Kevin Dubios, & Holly Cummins
Date/Time: Wednesday from 13:50-15:20 in the Coding Cafe
Track/Level: Mini Lab (INTERMEDIATE level)
Abstract: Generative AI has taken the world by storm, and it seems like every executive leader out there is telling us “regular” Java devs to “add AI” to our apps. Does that mean we need to drop everything we’ve built and become data scientists instead now?

Fortunately, we can infuse AI models built by actual AI experts into our applications in a fairly straightforward way. We promise it’s not as complicated as you might think! Thanks to the ease of use and superb developer experience of Quarkus and the nice AI integration capabilities that the LangChain4j libraries offer, it becomes trivial to start working with AI and make your stakeholders happy.

In this session, you’ll explore a variety of AI capabilities. We’ll start from the Quarkus DevUI where you can try out AI models before writing any code. Then we’ll get get into the code and explore LangChain4j features such as prompting, chaining, and preserving state; agents and function-calling; enriching your AI model’s knowledge with your own documents using retrieval augmented generation (RAG); and discovering ways to run (and train) models locally using tools like Ollama and/or Podman AI Lab. In addition, we’ll take a look at observability and fault tolerance of the AI integration. We might even try some new features, such as MCP.

Come to this session to learn how to build AI-infused applications in Java. This is also an opportunity to provide feedback to the maintainers of these projects and contribute back to the community.

Session: Picocli: put some Java in your terminal 💻!
Speaker(s): Stéphane Philippart
Date/Time: Wednesday from 14:40-15:10 in Room A
Track/Level: Tools-in-Action (BEGINNER level)
Abstract: Everyone uses CLIs (Command Line Interfaces), and they've been around since the dawn of time.
Often synonymous with productivity gains, their creation is sometimes obscure and can seem complex.

This was the case a few decades ago, but in recent years, languages and frameworks have made it possible to write them simply in your favorite language.
I propose to use a language which, at first glance, may not seem the most intuitive for creating a CLI: Java!

Thanks to Picocli and Quarkus, your CLI will have all the bells and whistles of a great CLI, yet be simple to develop!
And the icing on the cake: we'll create a "real" executable thanks to Graal VM.

Come and join me for a live coding session that will show you how to create a Java CLI with Picocli and Quarkus from scratch!

Thursday Quarkus Sessions

Session: Java meets AI: Build LLM-Powered Apps with LangChain4j
Speaker(s): Kevin Dubois & Holly Cummins
Date/Time: Thursday from 09:00-09:50 in Room B
Track/Level: Conference (INTERMEDIATE level)
Abstract: Join us for a guided tour through the possibilities of the LangChain4j framework! Chat with virtually any LLM provider (OpenAI, Gemini, HuggingFace, Azure, AWS, ...)? Generate AI images straight from your Java application with Dall-E and Gemini? Have LLMs return POJOs? Interact with local models on your machine? LangChain4j makes it a piece of cake! We will explain the fundamental building blocks of LLM-powered applications, show you how to chain them together into AI Services, and how to interact with your knowledge base using advanced RAG.

Then, we take a deeper dive into the Quarkus LangChain4j integration. We'll show how little code is needed when using Quarkus, how live reload makes experimenting with prompts a breeze and finally we'll look at its native image generation capabilities, aiming to get your AI-powered app deployment-ready in no time. By the end of this session, you will have all the technical knowledge to get your hands dirty, along with plenty of inspiration for designing the apps of the future.

Session: Serverless Java in Action: Cloud Agnostic Design Patterns and Tips
Speaker(s): Daniel Oh & Kevin Dubious
Date/Time: Thursday from 11:20-12:10 in Room B
Track/Level: Conference (BEGINNER level)
Abstract: Tired of the same old serverless story? You've probably seen the basics of Function-as-a-Service with the big cloud providers. But there's a whole new world of serverless possibilities waiting to be explored. Join us as we dive deep into the future of serverless Java development with cloud-agnostic platforms on Kubernetes. We'll show you how to build cloud-native, event-driven applications that are fast, scalable, and resilient.

Key takeaways:

• Lightning-fast startup times: Learn how Quarkus optimizes your Java code for serverless environments.
• Kubernetes-native serverless: Discover the power of Knative for deploying and managing your serverless functions.
• Vendor-agnostic serverless: Break free from cloud vendor lock-in and deploy your applications anywhere.
• Real-world use cases: See how leading organizations are leveraging serverless to solve complex problems.

By incorporating these patterns and tips, you can create a captivating and informative session that leaves your audience eager to explore the world of serverless Java.

Session: Boost Developer Productivity and Speed Up Your Inner Loop with Quarkus
Speaker(s): Daniel Oh
Date/Time: Thursday from 14:10-14:25 in Room B
Track/Level: Byte Size Session (BEGINNER level)
Abstract: In today’s fast-paced development world, slow builds and sluggish feedback loops can cripple productivity—but Quarkus flips the script. Designed for Kubernetes-native Java, it turbocharges the inner loop with live coding, near-instant startup times, and memory efficiency, letting developers iterate faster than ever. Imagine tweaking code and seeing changes immediately without manual redeploys, or testing cloud-native apps locally without resource bloat. This talk includes a live demo showcasing Quarkus’ live coding in action: watch as code edits reflect in real time, feedback loops shrink to seconds, and cloud integrations streamline workflows—proving how Quarkus turns waiting time into productive coding time.

Session: 30 minutes to understand MCP (Model Context Protocol)
Speaker(s): Sébastien Blanc
Date/Time: Thursday from 17:20-17:50 in the Auditorium
Track/Level: Tools-in-Action (BEGINNER level)
Abstract: 2023 was the year of LLMs, 2024 was the year of RAG, 2025 will be the year of MCP ! From the official documentation you can read : “The Model Context Protocol (MCP) is an open protocol that enables seamless integration between LLM applications and external data sources and tools.” But does that really help you to understand what this means ?
Join me in this Tools-in-action to understand concretely what MCP is and you will see that the concepts behind it are not really new things but more a normalization of existing ones. You will learn how to consume from a MCP server but also how to write one, using the Quarkus implementation and its wonderful developer experience.

Expect a few slides and a lot of live coding ! By the end of the session you will have a complete understanding of this new buzzword of 2025 !