Quarkus at Riviera Dev 2026

[insectengine]

Event Description: Riviera DEV is a conference by developers, for developers. It is a fun and relaxed event offered at an affordable price so that every developer can enjoy the experience.

Provide a first class tech conference where developers can learn, hack and network.

Date: July 6-8, 2026
Location: Valbonne, France
Event Type: In-Person

https://rivieradev.fr/

Monday Sessions

Session: From 0 to Agentic AI expert(ish)
Speaker(s): Kevin Dubois
Date/Time: Monday 6 July 09:00 - 12:00
Room: Amphi 139 (160 places)
Language: English
Abstract: Curious about building agentic AI systems, but you're not sure where to begin? In this deep dive session we'll start with the basics of a single AI service, including how to add RAG, guardrails, memory persistence, tools, MCP and observability. Once we've go that down, we'll go beyond a single AI service and see how implementing multiple AI services into agents opens a whole new world of possibilities. We'll cover a variety of agentic AI patterns such as agentic workflows, the supervisor pattern, and goal-based autonomy, human-in-the-loop, etc. And we'll wrap it up by combining these patterns into an advanced agentic AI system that we'll be able to deploy to Kubernetes.

This session will focus on Java and Quarkus LangChain4j, but the concepts are universal for anyone to follow.

Session: Crée un site statique avec Roq pour laisser tes histoires, idées et concepts circuler naturellement
Speaker(s): Andy Damevin
Date/Time: Monday 6 July 14:00 - 17:00
Room: Amphi 139 (160 places)
Language: French
Abstract: Dans ce Lab, nous allons apprendre à :

• Démarrer ton prochain blog ou site avec Roq (ou préparer le terrain pour en migrer un existant)
• Automatiser ta publication avec GitHub et l’héberger gratuitement
• Utiliser Tailwind CSS pour donner à ton site un look propre sans compétence en design
• Écrire ton premier article et tes pages avec l’éditeur Roq (CMS)
• Activer les commentaires sur tes articles
• Explorer les concepts avancés de Roq pour en faire une arme redoutable au service de toutes tes idées

Les seuls trucs à installer avant c'est la JDK 21+ et un IDE.

Session: Building with Open Source AI: A Crash Course
Speaker(s): Cedric Clyburn & Legare Kerrison
Date/Time: Monday 6 July 09:00 - 12:00
Room: Room 111 (40 places)
Language: English
Abstract: Thanks to open source, in the past year, we’ve seen a fundamental change: developers and enterprises are moving away from proprietary, closed-source models. To save costs, prioritize privacy, and allow for customization, they are building, testing, and deploying their own open models. However, this journey can feel overwhelming. Which foundation model should I use? How do I connect my model to existing data sources or build agentic capabilities to start seeing real value with AI, especially in an already existing Java application?

The key to navigating this emerging path is adopting the flexibility, transparency, and collaboration of open source that many of us are familiar with. We'll live demo the critical aspects of AI feature implementation using LangChain4J, also showing observability (OpenTelemetry), testing (Promptfoo), CI/CD (Tekton), and more. Join us as we get hands-on with language models and use open technologies to control our own AI journey.

Tuesday Sessions

Session: Meme les developpeurs Java peuvent developper des CLIs
Speaker(s): Fabrice Pipart
Date/Time: Tuesday 7 July 11:40 - 12:30
Room: Amphi 137 (260 places)
Language: French
Abstract: Tu es développeur? Ou pire DevOps? Et tu aimes coder en Java? De nos jours on a besoin de faire des automatisations de partout. Pour coder une automatisation, on a souvent recours a un outil en ligne de commande. Mais alors, quel langage, quel framework utiliser? Comment distribuer l'outil?

Jusqu’à maintenant, tu cachais un peu que ce que tu préfères c'est Java et tu as même osé coder en Python ou Go pour passer inaperçu et éviter de faire ton coming out. Mais c'est FINI !

Avec Quarkus, les développeurs Java ont maintenant tout ce qu'il faut pour développer efficacement un outil en ligne de commande !

Réunissons nous dans une salle, je vous montre en live coding comment mixer Java, des tests, des appels REST, Docker et Quarkus pour créer l'outil en ligne de commande parfait. Prêts?

Session: Agentic AI Patterns for Enterprise Software
Speaker(s): Kevin Dubois
Date/Time: Tuesday 7 July 10:40 - 11:30
Room: Amphi 139 (160 places)
Language: English
Abstract: Agentic AI is all the hype right now, but how do you actually implement such a system for real enterprise use cases?

The challenge for developers, architects and platform engineers alike lies in custom building agents, and even more so, orchestrating these agents to collaborate effectively towards a common goal. Unfortunately though, despite all the promises from vendors, a “one-size-fits-all” or “off-the-shelf” approach just doesn't work due to the complex nature of software. In addition, just like traditional apps, these agentic systems will likely need to be deployed, managed and observed in cloud environments.

In this session we'll explore:

• The spectrum of Agentic AI patterns
• A real world(-ish) implementation of a highly performant agentic system with Java, LangChain4j and Quarkus
• Deploying this agentic system to Kubernetes
• Other considerations such as observability and fault tolerance to get it all running smoothly in production.

Session: Beyond the Surface: Mastering Vulnerability Analysis with Quarkus
Speaker(s): Alexey Loubyansky
Date/Time: Tuesday 7 July 11:40 - 12:30
Room: Amphi 139 (160 places)
Language: English
Abstract: Quarkus has redefined Java development with its “Build-time First” philosophy, but this efficiency introduces unique complexities for security scanning. Standard Maven or Gradle dependency analysis often fails to capture the full picture of a Quarkus application’s footprint.

This session explores a comprehensive strategy for vulnerability management tailored to the Quarkus application lifecycle. We will start by dissecting the Quarkus dependency model, highlighting why traditional tools often miss transitives or build-time augmentations. Attendees will learn how to:

• Perform pre-build analysis to stop vulnerabilities before a single JAR is downloaded.
• Audit the application post-build using specialized scanning techniques.
• Leverage SBOMs (Software Bill of Materials) to maintain visibility long after the application has reached production.

Session: Six and a half ridiculous things to do with Quarkus
Speaker(s): Holly Cummins
Date/Time: Tuesday 7 July 14:00 - 14:50
Room: Amphi 139 (160 places)
Language: English
Abstract: Let’s abuse the tools! Everyone knows Quarkus is computationally efficient, expressive, and rock-solid for production.

But did you know that we can use Quarkus efficiency to build applications that shouldn’t go anywhere near production?

In this demo-driven session, Holly will put the joy into “developer joy”. She’ll show you all sorts of things you can do with Quarkus that you probably shouldn’t:

• Build an LLM-powered app that’s guaranteed to hallucinate, because you can do more than you think with guardrails, and truth is so boring
• Write your business code in rockstarlang, because everything should be a hair metal ballad
• Use Minecraft as your observability client, because the LGTM stack doesn’t have enough explosions
• Write a CLI for generating memes faster, because everything is better on the command-line
• Benchmark an application against a grapefruit, because metric units aren’t tasty

Business value? Learning? If you insist. As well as absurd demos, you’ll leave this session with a deeper understanding of how to get the most out of Quarkus and Java. There will be new Java 25 language features, Quarkus best practices, powerful integrations, and nifty use cases alongside the silly explosions and grapefruit.

Session: Introducing Data Access in Quarkus 4 with even more Panache
Speaker(s): Luca Molteni
Date/Time: Tuesday 7 July 15:00 - 15:50
Room: Amphi 139 (160 places)
Language: English
Abstract: If you’ve used Panache in Quarkus, you know it’s about making data access feel simpler. We know users love it, and in this talk, we’ll discuss the new, improved version the Quarkus team has delivered.

We’ll explore how this evolution acts as a gateway to different data access technologies, helping you choose the best tool for your specific needs. We’ll also discuss new features you might not be familiar with yet, such as Stateless Sessions, and how they fit into the modern Quarkus stack. Finally, we’ll take a look at the upgraded, easier-to-understand documentation and build a few demos together to show exactly how to get started.

Session: Nom d’un caillou ! Un site statique avec un CMS, de l’IA, maintenable, rapide… et fun.
Speaker(s): Andy Damevin
Date/Time: Tuesday 7 July 16:10 - 17:00
Room: Amphi 139 (160 places)
Language: French
Abstract: C’est un fait : les sites statiques générés (le HTML final) sont la meilleure option pour les sites orientés contenu, blogs, sites professionnels ou de projets, portfolios, etc. Ils sont excellents pour le SEO, extrêmement performants et pérennes, d’autant plus qu’ils sont idéaux pour la consommation par l’IA.

MAIS quand il faut deux heures à un ingénieur senior pour préparer un environnement pour un nouveau rédacteur (véritable anecdote), on comprend vite pourquoi WordPress est devenu si populaire.

Si tu as déjà utilisé un générateur de site statique, repense à la dernière fois où tu as dû ajuster des plugins, faire une mise à jour ou déboguer un truc qui n’aurait jamais dû casser. C’est vraiment frustrant !

Prends ce cas typique : ton inspiration est‑elle vraiment à son meilleur niveau lorsque la première étape consiste à créer manuellement un fichier sur le disque, avec un titre et une date dont tu n’es même pas certain ?

Roq redonne des couleurs à la génération de sites statiques et permet enfin à tes histoires, idées et concepts de circuler naturellement.

Et oui, fun fact : c’est du Java, construit sur Quarkus.

Session: Under the hood: Quarkus Native Choices and Implementation
Speaker(s): Foivos Zakkak
Date/Time: Tuesday 7 July 17:10 - 18:10
Room: Amphi 139 (160 places)
Language: English
Abstract: In this presentation, we will take a detailed look at how Quarkus implements native compilation with GraalVM, highlighting the architectural choices that set it apart from other frameworks.

We will start with an overview of the Quarkus “Build-time” model, specifically how it pre-processes application segments to minimize the heavy lifting usually required at runtime. From there, we will dive into the specific trade-offs made during the native image generation process—explaining the “why” behind the configuration and optimization decisions.

To wrap up, we will go directly into the Quarkus source code to show:

• How these decisions are practically implemented
• How Quarkus “fixes” third-party libraries for native compatibility without changing their original code
• The tangible performance benefits these implementation details provide to the end user.

Wednesday Sessions

Session: Quarkus and Leyden, the bumpy road ahead
Speaker(s): Guillaume Smet
Date/Time: Wednesday 8 July 10:10 - 11:00
Room: Amphi 139 (160 places)
Language: English
Abstract: Since its inception, Quarkus has been known for its fast startup times, whether running on the JVM or as a native image with GraalVM/Mandrel.

After years of optimizations to reduce startup costs, profiling JVM Quarkus applications startup today often shows the same recurring hotspots: class loading and reading from JAR files. This is not new to us, we already pushed these areas hard with custom packaging and class loading, but they remain a significant part of the startup profile.

Enter Project Leyden. It promises a major shift for the JVM with faster startup and lower warm-up costs, which looks like a match made in heaven for Quarkus. But it also raises important questions: how do we combine Leyden’s approach with Quarkus’ existing build-time and startup optimizations? Can we get the best of both worlds? In this talk, we share hands-on experience experimenting with Project Leyden from the perspective of Quarkus internals. We’ll look at what Leyden enables today, what it doesn’t yet, and how, at least in its current state, some of its limitations conflict with some of the optimizations Quarkus relies on, as well as how we hope to address this in the future.

Rather than a high-level overview, this session focuses on concrete findings: what worked, what surprised us, what broke, and what forced us to rethink parts of our design in order to preserve Quarkus’ performance while benefiting from Leyden. We’ll discuss performance characteristics, current limitations, crazy prototypes, and real-world optimization anecdotes.

Session: Reactive ❤️ Loom: A Forbidden Love Story
Speaker(s): Francesco Nigro
Date/Time: Wednesday 8 July 11:10 - 12:00
Room: Amphi 139 (160 places)
Language: English
Abstract: For years, the Java community has been told that Project Loom would kill reactive programming — that blocking and async were destined to be enemies. But what if that story was wrong?

In this talk, we’ll explore what happens when these two worlds actually fall in love.

Drawing from real-world work inside the Quarkus, Vert.x, Netty, and HotSpot teams, we’ll see how a custom Loom scheduler built on top of Netty brings together the performance of event-driven I/O and the simplicity of virtual-thread-friendly blocking APIs.

This isn’t a theoretical “what if”: it’s a data-driven exploration born from experiments and collaborations between IBM, Oracle Labs, Oracle and Apple engineering teams.

You’ll see how this approach reshapes how we think about async, concurrency, and scheduling — and why some of the long-held assumptions about “reactive vs blocking” simply don’t hold up when measured scientifically.

Along the way, we’ll dissect:

• How the Loom scheduler and virtual threads work under the hood.
• What happens when you run them over a Netty core
• Performance implications and trade-offs measured empirically.
• Why developers should challenge inherited dogmas and base design choices on data, not folklore

This talk is a technical love story, but also a call to reason: Measure, Don’t Guess. Because sometimes, the forbidden relationships are the ones that can move the platform forward.

Session: Talk to Your Data: Natural Language Data Access in Java with Hibernate, Quarkus, and LangChain4j
Speaker(s): Marco Belladelli
Date/Time: Wednesday 8 July 13:30 - 14:20
Room: Amphi 139 (160 places)
Language: English
Abstract: Explore how Hibernate ORM, Quarkus, and LangChain4j come together to enable natural language interactions with relational data in your Java application. Leveraging Hibernate’s deep understanding of your domain model and data access layer, new tools now bridge the gap between structured information and LLMs, allowing users and agents to query and explore data using plain language.

During this session we will demonstrate - with a live demo of a Quarkus application - how to interact in natural language with your existing Hibernate data model. In particular, we will show both how to manipulate data and how to use them to implement a simple but effective RAG pattern. This particular style of data interaction, including RAG, will have the advantage of leveraging Hibernate’s type-safe mappings, semantic-rich HQL, and fail-fast validation, making this data manipulation process more effective and less prone to hallucinations.

Finally, we will also demonstrate how to easily expose this tool as an MCP server through Quarkus, allowing it to empower other external agents with knowledge from your data.

Session: Quarkus Testing Joy
Speaker(s): Roberto Cortez
Date/Time: Wednesday 8 July 14:30 - 15:20
Room: Amphi 139 (160 places)
Language: English
Abstract: While most developers enjoy writing code for new applications or features, we cannot say the same when it is time to write tests for our new shiny code. Not only do we think our code is perfect, so obviously we don't need to test it, but it also requires us to write way more code to test our feature than the code we had to write to develop it.

With Quarkus, we also brought developer joy for testing to ease some of the pain. In this session, we will explore, through live coding, all aspects of testing applications and extensions in Quarkus, including setup, testing components, mocking, integration testing, native-image testing, continuous testing, and parallel testing.

Testing doesn't have to be boring or excruciating. Discover the joy of testing with Quarkus!

Session: The Bold, the Broken, and the Burned: Hard won lessons in the 6 years of developing Quarkus
Speaker(s): Guillaume Smet
Date/Time: Wednesday 8 July 15:40 - 16:30
Room: Amphi 139 (160 places)
Language: English
Abstract: As software engineers, we are faced with lots of choices. Additionally, when developing libraries or frameworks that are used by lots of other software engineers to build their products, then even small decisions can have unforeseeable and unintended consequences down the line.

From timeless classics like the importance of naming in software and the proper reuse of existing components, to the unknowns of build time optimization and all the way to bold decisions like rewriting the entire I/O layer and everything in between, this session will give you valuable insights into how and why important decisions were made when developing Quarkus, with the hope of helping you avoid our mistakes and leverage what we got right.

Although the story focuses on decisions made in the context of Quarkus, no actual knowledge of Quarkus itself is necessary to follow along this talk.