How to: run Java as a shell script, run a Java app without compiling, print an emoji, run an HTTP dev server, use libraries without compiling, colorful logs,&nbsp;access LLMs,run timer jobs, access the clipboard, implement a file watch, main in interfaces, easy file parsing (...) and ~100 other popular Java snippets from http://youtube.com/@bienadam/shorts.No builds, no Maven, no dependencies, just javac and Visual Studio code.

The Best of Java Shorts Show: 100 Snippets in 50 Minutes by Adam Bien

Design Patterns Revisited inModern Java, more details will follow soon in the near future.

Design Patterns Revisited in Modern Java by Venkat Subramaniam

Using streams everywhere: is that really a good idea? Certainly, stream code is often much clearer and more concise than iteration over a collection. But sometimes a stream solution requires a complex combination of collectors, reduction over a primitive stream, or nested FlatMap operations, and the verdict isn’t so obvious. In this talk, we’ll look at some sample use cases, evolve the best solutions we can, in both imperative and functional styles, and then argue over which is better. You’ll get a vote too!This session is for everyone who needs to write code in Java for bulk data processing – every Java developer, in fact. You’ll leave hopefully entertained, and with a better idea of the use cases where streams excel, and where you’re better staying with old-fashioned ways.

If Streams Are So Great, Let’s Use Them Everywhere... Right?? by Maurice Naftalin, José Paumard

An entertaining tour of the most common mistakes in designing an API (with examples): Domain Leakage, Sensitive Data Exposure, Performance issues, CQRS, PUT overload, and breaking changes. Collected with love from over 150 companies.- DM leak- Privacy Leak- Performance: Lazy, N+1- CQRS- PUT overload / ISP- SemVer

Top REST API Design Pitfalls by Victor Rentea

Hibernate - the most popular persistence technology for Java - also the most controversial one. Some people love it, some people hate it. No matter in which group you are, the chances you will work in Hibernate in at least one project are close to 100% - and you have no other choice than learning it. Not only the basics, but most importantly - how to leverage the power of Hibernate without sacrificing application and database performance.In this session you will learn how to configure Hibernate and Spring Data JPA for efficient database connection management, what is a N+1 problem and how to solve it, how and when to use projections for fast data retrieval ... and more!

Performance oriented Spring Data JPA & Hibernate by Maciej Walkowiak

You created your app from start.spring.io, you can run it, and you can also test it! There's a @SpringBootTest test case, and things are quick and easy. Fast-forward 6 months and your test suite now takes 12 minutes to run, and randomly fails at least once a day. You have mocks everywhere, and your integration tests are 197 lines long.@SpringBootTest sparks joy, and brings great value, immediately. But it's so easy to splatter it everywhere that devs miss out on all there other testing utilities Spring Boot provides. They don't put enough thought into te architecture of their test suite, they don't make their tests easy to read and write, they lose sight of the multiple goals that tests help us achieve: fast feedback, high confidence, support for design...In this talk, you'll learn about the entire Spring Boot testing toolkit, through many live-coded examples. We'll talk about slices testing, context caching, custom test configuration, testcontainers integration, and all the HTTP testing capabilities. We'll see that JUnit can offer much more than @BeforeEach &amp; @Test. We will also dive into all the little gems that are bundled with Spring-Boot-Test, such as Awaitility and JSONassert. You'll learn testing best practices - applied to Spring.

Spring Boot testing: Zero to Hero by Daniel Garnier-Moiroux

We spend half of our coding time reading, writing or fixing tests. But who likes that? To quickly fix this chore, we often copy-cat older tests or write new ones without paying much attention to their quality.  This deep-dive walks you through a variety of practical testing techniques and tricks you must have in your toolbox to write expressive tests with a higher signal/noise ratio. In the agenda: test structure &amp; naming, mutation testing (vs AI-gen tests), ObjectMother, why never to use assertEquals, nested fixtures, parameterized use/abuse, Gherkin, plus a few surprises. All this through an entertaining and interactive session that puts the joy back into testing.

The Joy of Testing by Victor Rentea

Brian will give an update on Project Valhalla.  Valhalla is augmenting the Java object model with value objects, combining the abstractions of object-oriented programming with the performance characteristics of simple primitives. Supplementary changes to Java’s generics will carry these performance gains into generic APIs.

Valhalla - Where Are We? by Brian Goetz

The Java platform has added many major features over the years -- generics, lambdas, modules, virtual threads, and others. Each of these is a bet-the-platform effort, in that a mistake could mean permanent damage. While each feature is unique, such decade-scale evolution projects often have surprising structural similarities. In this talk, Java Language Architect Brian Goetz offers some insights, war stories, and lessons learned from the development of several major Java features.

Postcards from the Peak of Complexity by Brian Goetz

In the dynamic landscape of Spring Boot applications, choosing the right concurrency approach is crucial. But which option is the best fit for your specific business case? This presentation will explore a range of technologies, from traditional core Java threads to the asynchronous capabilities of CompletableFuture, the reactive paradigm, the use of @Async methods, and the adoption of virtual threads. Drawing on extensive experience from diverse projects, the presenter will share valuable insights, recommendations, and best practices for developing highly efficient concurrent applications with parallel data processing requirements. Whether you're an engineer or architect involved in designing Spring Boot applications, this talk will provide essential guidance to optimize your development journey.

Concurrency in Spring Boot Applications: Making the Right Choice by Andrei Shakirin

Spring Boot 3.x and Java 21 are here, and there's never been a better time to be a Java developer! In this talk we'll look at the incredible opportunities that lay ahead for the Spring Boot developer, and especially those using Java 21 and later. Spring Boot continues to offer the most sophisticated and robust ecosystem of integrations - supporting AI, modularity, easy data access, and so much more. And, it offers cutting edge support for production-centric optimizations like Project Loom's virtual threads, GraalVM, and more. Join me Spring Developer Advocate Josh Long (@starbuxman) and we’ll explore next-gen Spring together

Deep Dive : Bootiful Spring Boot 3.x by Josh Long

Almost three decades have passed since the creation of Java Serialization—a feature which is widely frowned upon—and application requirements for externalization of objects have changed significantly.In this presentation we will explore how a changed set of requirements and constraints, paired with recent enhancements of the Java Language, can lead to a dramatically simpler and safer model for programmatically reasoning about the structure of Objects, and offer greater flexibility in state extraction, encoding, and reconstruction.It's time for a data-oriented approach to serialization, are you ready?

Serialization: A New Hope by Viktor Klang, Brian Goetz

Have you wondered how virtual threads in Java are able to provide such high scalability? How is JVM able to switch between so many virtual threads while executing a single platform thread? If you did then this talk is for you.A Continuation is the magic that powers Virtual Threads. It can be viewed as a representation of the current state of the program or it can be viewed as a reference to the rest of the program. It helps us to pause execution of a program (or part thereof) and then resume it later. This ability to pause/resume is a powerful mechanism and is the basis for providing virtual threads.In this talk, we will start with explaining what continuations are and how does Continuation API in Java work. We will also explore the uses of continuations. And more importantly, we will write our own simple VirtualThread class using the Continuation API provided by JDK. This gives clear idea about the role of continuations in the nature of virtual threads.

Continuations: The magic behind virtual threads in Java by Balkrishna Rawool

Last January a challenge was posted online by Gunnar Morling:How fast can you parse a file with one billion rows of weather data using Java?Little did we know this deceivingly simple question would lead us down a path that covered: parallelism, memory mapped files, SWAR techniques (SIMD as a register), bit twiddling, branchless code, mechanical sympathy, Graal native compilation and finally... turning to the dark side:&nbsp;using sun.misc.Unsafe.Join Thomas and Roy during this deep dive where they explain all the improvements and tricks that enabled them to go from a &gt;4 minute reference implementation to processing a billion rows in under two seconds.Who knew Java could be _this_ fast?

Pushing Java to the Limits: Processing a Billion Rows in under 2 Seconds by Thomas Wuerthinger

There always comes a point where software becomes so complex and old that it becomes unmaintainable. Updating the technical stack without breaking everything becomes impossible, implementing new features takes longer, and the technical debt is so overwhelming that refactoring becomes exorbitant.What if we told you that all of this is more of a practice problem than a software aging problem?Come and discover through hands-on experience in this 100% live coding session how Hexagonal Architecture can tackle software complexity, making it possible for you to be adaptable and sustainable while helping you manage your technical debt more effectively.

Hexagonal Architecture in Practice, Live Coding That Will Make Your Applications More Sustainable by

Want to learn, explore or use Java instantly without setup ?Do you like Java but use python, groovy, kotlin or similar languages for scripts, experimentation and exploration ?Ever wanted to just be able to run java from anywhere without any or very minimal setup ? Ever tried out Java 11+ support for running .java files directly in your shell but felt it was a bit too cumbersome ?If yes, then this talk is for you.

jbang - Unleash the power of Java by Max Rydahl Andersen

Code reviews are vital for ensuring good code quality and fostering teamwork. They serve as one of our last lines of defense against bugs and suboptimal code reaching production. Yet, they often turn into annoying tasks riddled with frustration, hostility, unclear feedback and lack of standard practices. How can we improve this crucial process? In this session we will cover: - Streamlining the Review Process: How to create the most review friendly pull requests- The Art of Effective Code Reviews: Learn how you should approach a review, how to empower colleagues and how to improve collaboration.- Elevating Reviews with Automated Tools: Explore tools that reinforce code consistency and quality, from automated style fixes to architecture checks. Let's cut through the noise of bikeshedding and focus on the essence of the changes!This session will leave you with practical tactics for improving pull requests, performing better code reviews, and a suite of tools to streamline the review process and boost code quality.

Cracking the Code Review by Paco van Beckhoven

Ever wondered what would happen if you used IntelliJ IDEA as a game engine? Probably not, but Alexander did, and it turns out, it’s absurd and a lot of fun! Join Alexander for a lighthearted yet insightful dive into the absurdness of using one of the most sophisticated IDEs to create games within your codebase because... well, why not?In this talk, Alexander will walk you through his adventure of using the IntelliJ plugin platform to implement game logic, render graphics, and more. He’ll share the head-scratching moments, the "aha!" breakthroughs, and the plain stupidity of making this idea work. You'll see IntelliJ handling sprites, game physics, and maybe even a rogue mutable variable trying to destroy your cursor!This session is for anyone who believes that the best projects are born from a spark of curiosity and a sense of fun. Discover how pushing the boundaries of your tools can lead to unexpected innovations and a lot of laughs along the way. After all, the most important work we do is often the work we find the most fun. Come ready to chuckle, learn, and maybe even be inspired to try your own offbeat experiments!

Let’s use IntelliJ as a game engine, just because we can by Alexander Chatzizacharias

In the last 25 years, the Java Collections Framework has become arguably the most used data structures on the planet, part of everyday life for millions of developers. And yet, the world in which the Collections Framework was designed is very different from the one we inhabit now. How should we avoid pitfalls from older paradigms, and how do we teach a 25-year-old framework to embrace current concepts? We’ll cover the following topics:– Concurrent programming is driving Java towards a functional style, but collections were designed around in-place mutation. Does unmodifiability help? Should persistent data structures now be added? We’ll argue these questions, with examples to illustrate the tradeoffs;– Anything as complex and long-lived as the collections framework is bound to attract controversies, which we’ll explain;– We’ll take some examples of code using collections and improve them, discovering good practices as we go;– The Collections Framework is fundamentally about shared abstractions. Is the current set of abstractions sufficient, and if not, what is missing? We’ll discuss some new abstractions we’re exploring for the future.This session is for every Java developer who needs to use the collections framework – that’s every Java developer. You’ll leave with a deeper understanding of the design forces that shaped the framework, and with sharpened practical knowledge of how to get the very best from it, and some ideas for where the framework is heading.

Escape from the Planet of the Collections by Stuart Marks, Maurice Naftalin

Dealing with JSON in the relational world by Andres Almiray

The next phase of Project Loom and Virtual Threads

The next phase of Project Loom and Virtual Threads by Alan Bateman

The Java Programming Language is evolving fast. In this talk we’ll summarise many of the recent changes that have appeared as well as looking ahead to directions and features that are in development and will appear in future editions.

Java Language Futures by Gavin Bierman

It may surprise you to learn that we developers are a patient, tolerant species. People pay us to do what we enjoy - write code and create working applications. In return, we will put up with all sorts of blockages and toil that get in the way of this - long build times, flaky tests, hard-to-debug toolchain failures and so on.Is this truly the price we need to pay? Could there be a better world, where the build is as fast as it could possibly be? A world where problems that affect many developers are quickly identified and fixed?Welcome to the world of Developer Productivity Engineering, where we can get computers to do what they’re good at (automation) to make developers’ lives easier, and make us more effective at our jobs. And while developer joy may be a difficult thing to sell to decision-makers, effective developers who are making the best use of their time, and their hardware, have a direct impact on an organization’s ROI.In this talk, Trisha will explore what DPE is, give you some practical ways to get started, and discuss ways to help the leaders in your organisation to understand the enormous value DPE could unlock.

Developer Productivity Engineering: What's in it for me? by Trisha Gee

Cruising Along with Java: Benefiting from the Modern Features, details will follow :)

Cruising Along with Java: Benefiting from the Modern Features by Venkat Subramaniam

Most of the time when we make mistakes in our code, a message gets displayed wrong or an invoice doesn’t get sent. But sometimes when people make mistakes in code, things literally explode, or bankrupt companies, or make web development a living hell for millions of programmers for years to come. Join Mark on a tour through some of the worst mistakes in the history of programming. Learn what went wrong, why it went wrong, how much it cost, and how things can be pretty funny when they’re not happening to you.

Programming’s Greatest Mistakes by Mark Rendle

In the era of AI, the demand for computational power has never been higher. While high-end GPUs remain the go-to solution for AI processing, they come with a hefty price tag and significant energy consumption. Enter exo, an innovative open-source project that&#39;s turning the world of home AI on its head.This talk will introduce exo, a groundbreaking software that allows you to create your own AI cluster using everyday devices. We&#39;ll explore how exo unifies the computational power of your iPhone, iPad, Android devices, Macs, and Linux machines to run sophisticated AI models without the need for expensive hardware.Run your own cluster at home @ https://github.com/exo-explore/exo

Exo: Run your own AI cluster at home by Mohamed Baioumy

Ask them anything related to the Java language with the Oracle engineers making it happen!

Ask the Architect by Stuart Marks, Alan Bateman, Per Minborg, Gavin Bierman, Brian Goetz

The opening keynote will feature several speakers who will provide updates on the Genesis of AI-generated tools, open-source projects, and cutting-edge techniques.

Genesis Keynote by Stephan Janssen

Safe travels to all Devoxxians making their way to Belgium! #SeeYouSoon #DevoxxRap 🎤 🤩

Devoxx Belgium 2024 #SafeTravels 🎤 😎

Garbage collection (GC) is a key feature of the Java Platform that enables automatic memory management, allowing developers to focus on solving problems other than low-level memory management.Since JDK 8, the GC performance have improved significantly, removing much of the overhead usually associated with automatic memory management. In this talk we will explore:- the basics of GC- what different GC algorithms are available and their key differences- how choosing the right GC and upgrading to a recent JDK can improve the performance of your services

Garbage Collection in Java: The progress since JDK 8  by Stefan Johansson

Do you know how your data moves into your Apache Kafka® instance? From the programmer’s point of view, it’s relatively simple. But under the hood, writing to Kafka is a complex process with a fascinating life cycle that’s worth understanding.
Anytime you call producer.send(), those calls are translated into low-level requests which are sent along to the brokers for processing. In this session, we’ll dive into the world of Kafka producers to follow a request from an initial call to send(), all the way to disk, and back to the client via the broker’s final response. Along the way, we’ll explore a number of client and broker configurations that affect how these requests are handled and discuss the metrics that you can monitor to help you to keep track of every stage of the request life cycle.
By the end of this session, you’ll know the ins and outs of the read and write requests that your Kafka clients make, making your next debugging or performance analysis session a breeze.

A Kafka Producer’s Request: Or, There and Back Again by Danica Fine

Are architects supposed to be the smartest people on the team, making all the important decisions for developers to fill in the blanks? Certainly not. Rather, architects make everyone else smarter, for example by sharing decision models or revealing blind spots. Architects also communicate across many organizational layers by using models and metaphors. This talk reflects on two decades working as an architect, ranging from the executive penthouse to the serverless engine room.

Thinking Like an Architect by Gregor Hohpe

Devoxx Belgium 2024 GENESIS Intro Movie

Jakarta Data 1.0 and Jakarta Persistence 3.2 introduce an entirely new and much more typesafe programming model for persistence in Java. In this session we explore how to take advantage of this model, and learn about how Hibernate 7 implements these specifications.

Jakarta Data and Jakarta Persistence by Gavin King

GraalVM has been around for a while, and more and more developers and teams use it to run Java applications faster, more efficiently, and more securely. According to the latest State of Spring survey, 37% of Spring users either already run applications natively compiled GraalVM in production, or are currently evaluating it, and 31% more have such plans.For those who haven't moved to GraalVM yet though, the questions and concerns are usually similar: how hard is to migrate? Can I use libraries and tools? Can I monitor such native applications? What about using latest Java features?In this no-slides, all-code session we'll talk about all the practical aspects of building and running applications with GraalVM, tooling, monitoring, using popular libraries, and cover common questions that we get from users.

Bring the action: using GraalVM in production by Alina Yurenko

In modern application development, engineers frequently encounter the challenge of synchronizing database transactions with messaging activities. Ensuring that a message is sent only when a database transaction is successfully committed, and vice versa, is crucial. This synchronization is essential for scenarios like updating order statuses while triggering payments, or modifying bookings and sending confirmation emails. This talk will explore techniques to achieve atomicity and consistency between message queues and databases. We will delve into various approaches, considerations, and real-world experiences, highlighting different methods along with their advantages and disadvantages. Practical use cases from actual projects will be provided to illustrate the effective application of each approach.

Atomicity and Consistency Across Databases and Messaging Systems by Andrei Shakirin

Java is constantly evolving in terms of performance, allowing unchanged application code to run faster and faster with each new Java release.In this talk we will take a closer look at five recent performance improvements made in the JDK involving both the standard Java libraries, the JIT compiler, and in garbage collectors. We will explore some of the design considerations made and how performance is evaluated by the JDK developers in a world of conflicting optimization criterion and varying platform properties,One of the five improvements under the microscope is the newly introduced “MergeStore” feature of the JIT-complier allowing several write operations to an array to be merged into one single bulk operation. We will learn how this feature works, how much performance can improve, and how your code can take advantage of it by avoiding common pitfalls that would otherwise disable the feature altogether.

Java Performance Update 2024 by Per Minborg

Spring Boot in Native Images are all the rage now: faster startup, stable performance and optimized resource usage, what's not to like? While it is super easy to integrate in a brand new, greenfield application, there are a few things you need to know to migrate older, already existing apps.While the Spring Ahead-Of-Time compilation process can infer a lot about an application, it is not enough. There are general patterns to follow, and common pitfalls that can be avoided.In this live demo, you will learn practical recipes for migrating an existing JVM-based Spring Boot application to Native Image, tips for improving your workflows, and how to measure the improvements Spring Native brings.

Migrating Spring Boot apps to GraalVM by Alina Yurenko, Daniel Garnier-Moiroux

This session throws open the doors to Project Panama! Dive into its functionalities by building a practical, yet fun, project - a custom file system in Java. We'll explore virtual threads for efficient I/O operations, unveil Panama's capabilities through hands-on exercises, and leverage Fuse for a complete user-space experience. This engaging journey will equip you to confidently navigate Project Panama for real-world applications.

Project Panama in Action: Building a File System by David Vlijmincx

The new HTTP/3 and QUIC protocols are taking the world by storm, accounting for over 25% of worldwide Internet traffic in July 2024. While these new technologies carry a plethora of (still somewhat unproven) promises for improved performance and privacy/security, this comes at the cost of increasing complexity, and not everyone agrees the juice is worth the squeeze.In this session we look at the historical context for the new protocols to better understand where they come from. We discuss some of the new performance and especially security features (for example connection migration, 0-RTT handshakes, head-of-line-blocking removal, amplification prevention, …) and the inherent tradeoffs that are made within. We also look at some “funny” anecdotes of things that have gone wrong while trying to deploy the new protocols at scale (spoiler alert: from now on, it’s no longer “always DNS”).You will walk away with a better overall understanding of why the protocols were needed, where and when they can be useful, and how they might be useful to you, now and in the future.

HTTP/3 and QUIC: Who, what, where, when and, WHY? by Robin Marx

You may feel that Apache Maven is done by now. For many people, Maven 3 is the only version of Maven they have ever used, and it has never seen large breaking changes. Those who have been using Maven 2 before may remember that transitioning to Maven 3 was a fairly painless journey.Did you know it's been roughly ten years since the first steps were made on the road to Maven 4? Yet it was only this year that the first beta releases of Maven 4 were published. What a release Maven 4 will be! In the last years, there have been numerous blogs, videos and talks about things that the Maven team has been working on. In this talk, we will bring everything together to give you a thorough review of the things that are ahead.We will cover both internal changes and external changes, highlighting the impact it will have on you as a user of Maven. Whatever your role, if you use Maven you can't miss this session.

Wait no more, here comes Maven 4! by Robert Scholte, Maarten Mulders

This is an AI generated podcast based on the Devoxx Belgium opening keynote transcript.  #Enjoy

AI-generated recap of Devoxx Belgium 2024 opening keynote : Genesis with Stephan Janssen & friends

Mario Fusco got his hair cut during the opening keynote of Devoxx Belgium 2024.

Mario Fusco : 20 years younger 🤩 💈 ✂️

With a "Co-pilot for everything," our interaction with technology and daily tasks is evolving. Organizations are increasingly integrating LLMs into their applications, enhancing features like search tools, chatbots, and internal information systems.Chances are, you're already working with Generative AI or will be soon. But are you aware of the risks before diving into use cases or development? Curiosity drives us to explore limits, which can lead to finding ways around "Guard Rails." These guard rails prevent misuse, like asking ChatGPT how to build a bomb. But what if clever wordplay confuses LLMs into bypassing these safeguards?In "The dark arts of Prompt Engineering," we'll explore Prompt Injections. We'll cover what Guard Rails are, how they function, and how to circumvent them using Prompt Injections—purely for educational purposes. Understanding these risks is crucial for knowing where to implement safeguards or reconsider actions. This session goes beyond tech details. It’s about real-life impacts. You'll see examples that will make you rethink AI's role in our lives. We'll also discuss the ethical aspect—how to use AI responsibly and safely. Plus, learn a fun trick: hide some "words as weapons" in your CV to trick recruiters!As AI is here to stay, let's get secure and join this session!Learn from the mistakes other companies have already made.Don’t miss this important and eye-opening session!

Words as weapons: The dark arts of Prompt Engineering by Jeroen Egelmeers

Bootiful Spring Boot 3.x by Josh Long

Large Language Models (LLMs) have become essential in many applications, but integrating them effectively into Java environments can still be challenging. This session will explore practical approaches to implementing local LLM inference using modern Java.We'll demonstrate how to leverage the latest Java features to implement local inference for a variety of open-source LLMs, starting with Llama 2&amp;3 (Meta). Importantly, we'll show how the same approach can easily be extended to run other popular open-source models on standard CPUs without the need for specialized hardware.Key topics we'll cover:- Implementing efficient LLM inference engines in modern Java for local execution- Utilizing Java 21+ features for optimized CPU-based performance- Creating a flexible framework adaptable to multiple LLM architectures- Maximizing standard CPU utilization for inference without GPU dependencies- Integrating with LangChain4j for streamlined local inference execution- Optimizing performance with Java Vector API for accelerated matrix operations and leveraging GraalVM to reduce latency and memory consumption.Join us to learn about implementing and optimizing local LLM inference for open-source models in your Java projects and creating fast and efficient AI applications using the latest Java technologies.

Practical LLM Inference in Modern Java by Alfonso² Peterssen, Alina Yurenko

There are many approaches to concurrency all with different ways of handling cancellation and errors.&nbsp; Structured Concurrency is an approach that makes typical fan-out and fan-in use cases like races, easier to manage especially when sub-tasks need to be canceled or can produce errors.&nbsp; This talk will introduce the concept of Structured Concurrency and compare different approaches (with and without Loom) in Java, Kotlin, and Scala.&nbsp; Additionally, we will explore the seamless integration of Scoped Values with Structured Concurrency, enabling the propagation of contextual information across concurrency boundaries without explicitly passing them through method parameters.

Structured Concurrency: Managing the Hierarchical Cancelation and Error Handling by James Ward

Docker is the cornerstone of today's development! Let's overview quickly how we use it in JVM development, and then transition to practical examples. We will start with a simple Docker image containing a popular "one fat JAR" and look into its downsides (deployment speed, traffic volume). To address them, we will discuss the strategy of splitting the JAR into multiple layers and using multi-stage Dockerfiles, gradually improving our image.Join me to learn how to build the ultimate Docker image for Spring applications.

Crafting the Ultimate Docker Image for Spring Applications by Pasha Finkelshteyn

Data professionals and software developers of every stripe are moving rapidly into the world of real time, streaming data. There's no question that this is our future, and that its promises are already being realized, but how did we get here? Is real-time really the natural evolution of batch processing? When did we start thinking of what we call "data" itself, and has has that influenced the way we build systems how have our data management tools evolved from the earliest days?We'll start with a frustrated Belgian astronomer who went on a quest to compute the statistics of the "average man." Then we'll follow automated computing technology as it proceeds from the Difference Engine to tabulating machines to the first digital computers to mainframes to data warehouses to Hadoop to Kafka to Apache Pinot. As we tell the stories of the main technologies along the way, we'll look at how developments in data storage, information management, and computation all conspired to give us not just just the data stack we have now, but the very ideas we use to think about data, put it to use, and move its associated technologies forward.

A Brief History of Data by Tim Berglund

In the rapidly evolving landscape of AI, Java developers deserve native building blocks for creating innovative AI applications. While Python has enabled rapid development and is the backbone of model training, production-grade services and enterprises running on Java require access to local models and AI tools.Enter JLama, a modern inference engine designed to bring the power of AI directly into the Java ecosystem without requiring GPUs. JLama supports most open models like Llama, Gemma, and Mixtral, leveraging the new Vector API in Java 21 for faster inference.Key features include:Advanced model support and tokenizer compatibilityImplementation of the latest techniques like Flash Attention, Mixture of Experts, and Group Query AttentionSupport for HuggingFace standard model formats and quantizationDistributed inference capabilitiesJLama is integrated into the LangChain4j project and, combined with the Java native vector search capabilities of JVector, forms a comprehensive AI stack for Java.This talk will delve into JLama's technical intricacies and practical applications, including a live demo. Discover how JLama revolutionizes Java-AI integration, paving the way for innovative applications that harness the full potential of large language models.

Jlama: A Native Java LLM inference engine by Jake Luciani

When asking GPT4 if it is difficult to parse dates in Java, it replied:Ah, parsing dates in Java. It's the kind of task that sounds so simple, you might think it's a first-week-of-coding-bootcamp kind of problem. But oh, how wrong you would be! It's more like a "I've been coding for ten years and I still get nightmares about this" kind of problem.Which is a fair answer. If you've never experienced the anguish of time-travel when you're parsing a date, then you haven't tried hard enough.This is partly caused by API design choices (looking at you `new Date(0) != new Date()`), but generally speaking stems from the fact that dates, calendars, locales, leap seconds, leap years, time-zones...etc, are just very complicated.But parsing data always serves a purpose, and we frequently attempt to tailor the data to fit our needs, although it's usually the opposite that's true. The main goal is parsing the data itself. When you're faced with the challenge of consuming an API from Evil Corp, which had the audacity to create a proprietary date format, your managers likely won't care (or understand) why none of your sophisticated libraries can handle it.This talkwill navigate the treacherous terrain of our beloved APIs, while also highlighting the traps in our thought processes. So buckle up for a conclusion that promises solutions wrapped in humorous anecdotes (with a pinch of date forensics).

The Pearls and Pitfalls of DateTime by Mahmoud Abdelghany

Streams were a very nice addition to Java 8, based on lambdas. They allow streamlined data processing without side effects, taking us gently towards functional style. With newer additions to Java, like records and pattern matching, they shine even more in data-driven flows.However, they don’t come without flaws.For starters, the only available extension point was collectors: if your needs for gathering data weren’t satisfied by the whole Collectors ZOO, you could always fall back to creating your own Collector. However, if map, filter or flatMap weren’t enough, you couldn’t add your own intermediate operation.Secondly, parallel streams were limited to ForkJoin pool, effectively rendering them unusable for scenarios involving any IO.Since Java 22, Stream Gatherers are our extension point for intermediate operations in streams.If you’d like to comprehend how they work, find nice use cases and hunt for more performance, this talk is for you.

Hunting with Stream Gatherers by Piotr Przybyl

Java 21 was an explosive release, but 22 and 23 are no slouches either:from unnamed patterns to module importsfrom the foreign-function and memory API to stream gatherers and the class-file APIfrom a simpler main to launching multi-source-file programsfrom Markdown in JavaDoc to improved garbage collectionThere are plenty of features in the language, API, and runtime to discuss - whether new, improved, or finalized. So let's go over them!

Java 23 - Better Language, Better APIs, Better Runtime by Nicolai Parlog

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.

Java meets AI: Build LLM-Powered Apps with LangChain4j by Deandrea,  Andrianakis,  Escoffier

In the dynamic landscape of software engineering, navigating one’s career path can be akin to traversing a minefield, fraught with potential pitfalls and challenges. However, by adopting a well-grounded approach, software engineers can steer clear of common traps and setbacks, ultimately achieving success and fulfillment in their profession.This talk aims to highlight the essential strategies and principles that empower software engineers to build resilient and rewarding careers. Through practical advice and industry insights, attendees will gain valuable perspectives on how to:Cultivate a strong engineering foundationSet achievable goals to mark progressEmbrace communication and soft skillsRecognize and mitigate burnout or overworkSeek mentorship for continued growthBy proactively addressing these key areas, software engineers can fortify themselves against common career pitfalls, ensuring fulfillment and resilience in an ever-evolving industry. Join us as we delve into the strategies and insights that pave the way for a well-grounded and flourishing career in software engineering.

Avoiding career pitfalls — A well-grounded software engineer by Martin Stefanko

A modern web app needs more than just requesting JSON from the server and submitting form values back as JSON. Users expect more than just another REST-backed CRUD view. They expect real-time updates, offline synchronization, and a seamless experience across devices. It takes lots of development effort to do that with only low-level conventions such as REST and WebSockets.Many UI frameworks have adopted a concept called "signals" to simplify how different parts of the UI are updated whenever any part of the UI state changes. The same approach can also be used across the network as a full-stack solution to easily update the UIs of multiple users who collaborate through a shared UI state.This hands-on talk will show you how to use the full-stack signal concept to easily synchronize application data between users through the whole application stack from the UI to the database. You will learn how to build applications that delight your users.

Beyond REST: Using Full-Stack Signals for Real-Time Reactive UIs by Leif Åstrand

From REST API and SDKs to langchain4j to fully managed cloud solutions to local integration of open source foundation models.In this session I will present architectures, ideas, hacks, and workarounds for integrating LLM with Java enterprise applications.&nbsp;I will illustrate the concepts with Java 21 and Quarkus / MicroProfile code and integrate the latest Claude, ChatGPT, Llama and AWS Bedrock models. Your questions will be given priority and answered interactively.

Pure Java Enterprise AI/LLM Integration (EAI 2.0) by Adam Bien

Java's concurrency journey has been a long and winding one. We departed from the 'classic threads' station and traveled through Runnables, ExecutorService, 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 Deep-Dive, 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. (and of course there will be live demos!)

Java's Concurrency Journey Continues! Exploring Structured Concurrency and Scoped Values by Embregts

A Java program consists of objects that have references to each other. This is called the "object graph." It's easy to set up an object graph with cycles. If you do this, some things work, but other things break, sometimes in a surprising fashion. Cyclic object graphs don't come up very often, but when they do, they often result in difficult and subtle problems. Worse, the JDK doesn't provide much help here.Garbage collection works perfectly with cyclic object graphs. Early reference-counted GCs had problems with cycles, but modern tracing collectors handle them perfectly fine. This is a solved problem.The picture is less rosy in other parts of the system. A cyclic object graph using records or collections often results in a stack overflow or out-of-memory error.Java serialization claims to support cyclic object graphs. This works only in the simplest of cases. In more complex cases, deserialization will fail in subtle and unpleasant ways. There is a whole family of bug reports in the JDK Bug System that represents these different failure modes.I'll show several examples of cyclic object graphs that cause failures, and I'll explain these failures. I'll also explain why it's very difficult for the JDK to do anything effective to prevent them.Yet there are times when it's useful for Java applications to represent relationships that have cycles. I'll describe a set of techniques that can be used to represent cycles and that avoid the problems I've described.

The Cycling Tour – Java's Fraught Relationship with Cyclic Object Graphs by Stuart Marks

`switch` and `instanceof` have been the gates of data introspection in Java since 1.0. In modern times, the same constructs have been rehabilitated to enable full-blown pattern matching and offer a vision of data-oriented programming to Java developers. In this talk we are going to have a look into what `switch` and `instanceof` are for Java developers today and offer a holistic view of all the exciting directions that can be a possible future for Java's pattern matching abilities.

Pattern Matching in Java: Past, Present, Future by Angelos Bimpoudis

Project Leyden aims to improve the startup time, warmup time, and footprint of Java applications by enabling developers to shift computation forward and backward in time. In this joint talk, we’ll dive into what that means, review recent progress, and see a concrete use case and performance metrics with some typical Spring applications.Learn how to cut the startup time into half already today and see how that could be improved even more in the coming Java versions!

Project Leyden: Improving Java’s Startup Time by Per Minborg, Sébastien Deleuze

It’s easy to get started with Retrieval Augmented Generation, but you’ll quickly be disappointed with the generated answers: inaccurate or incomplete, missing context or outdated information, bad text chunking strategy, not the best documents returned by your vector database, and the list goes on.After meeting thousands of developers across Europe, we’ve explored those pain points, and will share with you how to overcome them. As part of the team building a vector database we are aware of the different flavors of searches (semantic, meta-data, full text, multimodal) and embedding model choices. We have been implementing RAG pipelines across different projects and frameworks and are contributing to LangChain4j.In this deep-dive, we will examine various techniques using LangChain4j to bring your RAG to the next level: with semantic chunking, query expansion &amp; compression, metadata filtering, document reranking, data lifecycle processes, and how to best evaluate and present the results to your users.

From naive to advanced RAG: the complete guide by Cédrick Lunven, Guillaume Laforge

JavaScript was famously created in 10 days as a proof-of-concept for Netscape Navigator 2.0. Today it is one of the most-used languages in the world. Some people even like it. In this talk we will chart the path from the dark days before programming languages, through the ups and downs of the early pioneers, all the way to 1995 and the creation of JavaScript.We will meet the giants on whose shoulders Brendan Eich stood, and speculate about what they might think of modern JavaScript. You will learn interesting things about language design (good and bad), computer internals (weird), and committees (just bad). You’ll see FizzBuzz implemented at least a dozen times. It’ll be fun.

How JavaScript Happened: A Short History of Programming Languages  by Mark Rendle

Kotlin 2.0, released in May 2024, marked a significant milestone in the language&#39;s evolution. At the heart of this major version lies the new compiler front-end, codenamed K2. The release delivered better performance and stabilization of the language features across multiple compilation targets. Despite being a major release, Kotlin 2.0 prioritized a smooth migration path, focusing on refinement rather than introducing drastic changes.We will first take a look at improvements in Kotlin 2.0 release, highlighting the introduction of frontend intermediate representation (FIR) and the new control flow engine.Then, we&#39;ll shift our focus to the horizon, and discuss the new ideas on Kotlin&#39;s roadmap:* Guard conditions - enhancing control flow and null safety* Context parameters - improving code organization* Union types for errors - bringing more expressiveness to type systems* Named-based destructuring - for better readability and reducing errors* Contracts - enabling more precise static analysisWhether you&#39;re a seasoned Kotlin developer or just starting out, this talk promises to expand your understanding of the language.

Kotlin 2.0 and beyond by Anton Arhipov

Many companies are interested in running open large language models such as Gemma and Llama because it gives them full control over the deployment options, the timing of model upgrades, and the private data that goes into the model. Ollama is a very popular open-source LLM inference server that works great on localhost and in a container. In this talk, you’ll learn how to deploy an application that uses an open model with Ollama on Cloud Run with scale to zero, serverless GPUs.

Running open large language models in production with Ollama and serverless GPUs by Wietse Venema

Devoxx Genie is a fully Java-based LLM Code Assistant plugin for IntelliJ IDEA, designed to integrate with local LLM providers such as Ollama, LMStudio, GPT4All and Exo but also cloud based LLM&#39;s such as OpenAI, Anthropic, Mistral, Groq, Gemini and DeepInfra.  With Claude 3.5 Sonnet, DevoxxGenie isn&#39;t just another developer tool... it&#39;s a glimpse into the future of software engineering. As we eagerly await Claude 3.5 Opus, one thing is clear: we&#39;re witnessing a paradigm shift in Ai Augmented Programming (AAP) 🐒

DevoxxGenie: Your AI Assistant for IDEA by Gunter Rotsaert

As developers, we spend a lot of time learning to write code, while spending little to no time learning to read code. Meanwhile, we often spend more time reading code than actually writing it. Shouldn’t we be spending at least the same amount of time and effort improving this skill? Deliberate practice can help us get better at reading code. Learning how to better read and understand code, can in turn teach us what makes code readable. This might even help us to write code that is easier to read.In this talk we will discuss the benefits of deliberately practicing reading code in a code reading club or session without an IDE, as well as common strategies to navigate a new codebase and familiarise ourselves with the code using the IDE.

https://maritvandijk.com/presentations/reading-code/

Reading code by Marit van Dijk

In the rapidly evolving landscape of the banking industry, the integration of advanced technologies is key for maintaining competitive advantage and driving innovation. This conference talk will dive into the transformative potential of Generative AI (GenAI) technology, Retrieval-Augmented Generation (RAG), and Multi-Agent Systems within the banking and insurance sector. Our team has embarked on a journey to harness these cutting-edge technologies to redefine banking operations, customer engagement, and knowledge management.Our presentation will showcase real-world applications and case studies, demonstrating how these technologies have been successfully integrated into banking operations. We will highlight the challenges encountered, solutions devised, and the measurable impact on efficiency, quality, and employee and customer satisfaction. Through this session, we aim to share our insights, foster collaborative discussions, and inspire further innovation in the banking industry.Join us to explore the future of banking, driven by GenAI, RAG, and Multi-Agent Systems, and discover how our commitment to technological excellence is shaping a new era of financial services.

Transforming Banking with Advanced AI: GenAI, RAG, and Multi-Agent Systems by Kevin Suys

The software license model of Docker can be problematic for its adoption in enterprises.Are you familiar with Podman, a free alternative to Docker? Podman implements Docker's REST API, allowing you to easily replace Docker with Podman while keeping your existing tools.Podman operates in rootless mode or without a daemon and provides comprehensive container management, including the creation and running of OCI images/containers and even support for WebAssembly/WASM.One advantage is its native management of certain Kubernetes objects, such as pods (a group of containers).We will demonstrate how to use Podman Desktop for launching and managing containers, along with the entire ecosystem of components/applications revolving around Podman. We will also show the support for WebAssembly in Podman Desktop.Finally, we will illustrate how transitioning to Kubernetes is facilitated by the support in this tool.

A Free Alternative to Docker: Podman by Florent Benoit

Large Language Models (LLMs) have become increasingly popular recently, and many models are now available, such as OpenAI, Llama, Gemma, Mistral, etc. These models can be incorporated into your enterprise code to enhance the customer experience by eliminating the need for customers to navigate through an entire website or improving the search process of on-site documentation.However, AI encompasses more than just LLMs; it includes fraud detection, image classification, sentiment analysis, and more. In this session, we will explore how to integrate Java with AI and large language models, covering topics like how to consume, train/retrain, and infer them. We’ll expand your knowledge beyond the typical chatbots to make your enterprise enter into the AI era.We will also demonstrate how to seamlessly deploy these models to Kubernetes, ensuring the deployment parameters are configured correctly or using tools like KNative to make your models more sustainable.If you are interested in hands-on experience with AI, LLMs, and Java, with a focus on practical applications rather than theory, then this session is for you. You do not require any prior knowledge of AI to attend.

Developing Cloud-Native Java AI applications with DJL and LangChain4J by Sébastien Blanc, Alex Soto

In this talk, we will explore strategies to optimize the success rate of storing and retaining new information. We will discuss scientifically proven ideal learning intervals and content structures. Additionally, we will examine how to create an environment that improves our focus while you remain in the “flow”. Lastly we will also address the influence of AI on learning capabilities.In the dynamic field of software development, this knowledge will empower you to accelerate your learning curve and support others in their learning journeys.

Wired 2.0! Create your ultimate learning environment by Simone de Gijt

Java application performance can be something of a dark art. In addition to performance improvements that you get "for free" by updating to a more recent JVM, there are endless knobs and switches that you can use to tune application performance, based on your application's bottlenecks and critical performance indicators.In this presentation, I will review a number of axes of application performance, with a filter of optimizing workload performance on Arm64 processors. That starts with performance improvements in the JVM: out-of-the-box performance on Arm64 improved by 30% between Java 11 and Java 21. I will share some of the improvements integrated by Oracle that led to these improvements, which will give some insight into performance-related architectural differences.Beyond JVM improvements, there are also numerous JVM configuration options that can have a dramatic effect on application performance, including JVM ergonomics around garbage collection and heap size that are often sub-optimal for a long-running cloud workload that expects to have access to almost all the resources of a VM, configuration options around memory page size that can differ across different compute architectures, and efficient usage of JVM threads to optimize consumption of hardware resources.One layer beneath that, it is possible to tune operating system configuration to allow the JVM to make more effective use of system resources by matching JVM page size to kernel memory page size, optimizing various system parameters related to system threads, I/O, or networking to reduce the time that that the operating system is the bottleneck for your application.To show the impact of some of these settings, I will use some performance analysis and debugging tools to show how you can figure out good (perhaps not optimal) values for sizing VMs, and configuring the operating system and JVM, to allow you to get the most oout of your application, while running on fast, cheap, and power-efficient Arm64 CPU cores.

Accelerating performance of Java applications on Arm64 by Dave Neary

What can aviation teach us about software? More specifically, what can aviation disasters teach us?&nbsp;A lot actually.In the first edition of this talk, I focused on the human factor of aviation disasters. An important element of both software engineering and aviation. But that is just the tip of the iceberg.In this talk, I will go deeper into the technical oddities of some of the most famous aviation disasters. Buckle up for more case studies, more geeky stuff, and yeah, also some more human stuff.We will cover- Most common causes of aviation disasters and how that has changed over time- Redundancy in systems- Deadly UX- Project failures and (wrong) incentivesDespite the subject matter, this talk is not doom and gloom. It is a practical look at the methods and insights that almost 100 years of investigating commercial aviation disasters can teach us as software engineers.

Mayday Mark 2! More Software Lessons From Aviation Disasters. by Adele Carpenter

So you learned about all these new Java features but want to see how they come together? Then let's write a GitHub Crawler and let's throw in everything Java (23) has to offer:virtual threads and structured concurrencypattern matching and data-oriented programmingtype inference, records, and sealed typestext blocks and template stringsa modern HTTP client and improved collectionsmodules and OS-specific binariesThe end result will look very different from just a few years ago, let alone 10. This is not your parents' Java!

Modern Java in Action by Nicolai Parlog

The word "reactivity" is ubiquitous whenever you read an article or listen to a podcast about a frontend framework.But what does this term mean? More concretely, how is this reactivity translated into code within our favorite frameworks?I propose we perform an open-heart surgery on Vue, React, Svelte, and Angular to understand their internal "refresh" mechanisms of the DOM.We will then focus a bit more on the latter, which is completely changing its reactive logic.The aim of this focus is to present the challenges the core team is currently facing and, most importantly, the near future of Angular.So, if you want to be reactive, follow the guide! 😉

Deep dive into modern frameworks Reactivity🔬⚛️ by Sylvain Dedieu

Using Kafka effectively requires following best practices. In this session, we’ll share 15 essential do’s and don’ts for working with Kafka, based on our real-life experiences.Naming things might be the biggest problem in IT, and we’ll discuss how to do it right in Kafka. We’ll dive into managing replication factors, controlling a high number of partitions, and enforcing critical properties like min.insync.replicas (min.isr) and acks. Additionally, we’ll explore controlling idempotency and preventing overcommits.We’ll also cover managing poison pills and ensuring data quality, with or without a schema registry. Learn how to navigate these challenges and improve your Kafka environment.Whether you are a developer or an architect, join us to gain practical insights and actionable advice for getting the most out of Kafka.

15 Essential Do’s and Don’ts with Apache Kafka by Stephane Derosiaux

In this session, we'll show how to build an advanced Agentic Retrieval-Augmented Generation (RAG) system using entirely open-source technologies. RAG has been the cool kid for a while now, but there is a new cool kid in the bloc, Agentic RAG! This makes it possible to empower RAG with automated decision capabilities.We will talk about the different strategies to build an Agentic RAG system using Langchain, Ollama and Milvus. You will see how your RAG system can browse the internet, correct itself by adding self-reflection or self-grading on retrieved documents, and many more.The talk will include a live demo, showcasing the end-to-end workflow and performance of the Agentic RAG system. Whether you're a seasoned developer or new to the field, this session will provide valuable insights into building sophisticated RAG systems using open-source technologies.

Build an Agentic RAG system using Langchain, Ollama and Milvus by Stephen Batifol

We all know that LLMs hallucinate and RAG can help by providing current, relevant information to the model for generative tasks.But can we do better than just vector retrievals? A knowledge graph can represent data (and reality) at high fidelity and can make this&nbsp;rich context available based on the user's questions. But how to turn your text data into graphs data structures?&nbsp;Here is where the language skills of LLM can help to extract entities and relationships from text, which you then can correlate with sources,cluster into communities and navigate while answering the questions.In this talk we will both dive into Microsoft Research's GraphRAG approach as well as run the indexing and search live with Neo4j and LangChain.

Practical GraphRAG - Making LLMs smarter with Knowledge Graphs by Michael Hunger

Modern software systems are complex beasts. We need the right tools and signals to understand their behavior, performance, and potential problems. There are now so many ways to instrument our software that, as an engineer, it’s hard to pick the correct signal.This talk dives into the science behind telemetry signals like traces, metrics, logs, and profiling data. This knowledge will help you pick the right signal, make informed compromises, and create good data points. It’s also important to know when to use auto instrumentation or when to take over the steering wheel and manually instrument your code.By the end, you'll be equipped to make more informed decisions about which signals to use, when to use them, and how to leverage them in your stack to achieve top-notch observability cost-effectively.In this session, we’ll use the OpenTelemetry Java SDK to support the theory, but this is not an OpenTelemetry talk; we will focus on the why, not the how.

The Science of Signals: Mastering Telemetry for Observability by Alex Van Boxel, Maximilien Richer

While the Gradle Build Tool has been around for a while, it continuously evolves. The next major version, Gradle 9, brings a couple of key features that will impact users and the ecosystem.For users, the focus is on two tracks: scalability and comprehensibility. For scalability, the Gradle team aims to deliver features that make builds as fast as possible, even for massive projects. For comprehensibility, it is all about making Gradle easier to adopt and use for teams of all sizes and skill levels.Offering all of the above will require the plugin ecosystem to match the updated Gradle APIs and patterns, including stronger constraints, which are required to continue offering the strongest reliability guarantees.This session will cover topics like:Continued investment in configuration caching,Upcoming isolated projects feature,Higher level modeling of software projects,Separation of concerns for build users and build authorsAll of these topics will be illustrated by released features available in the Gradle 8.x line and by looking at what is coming in 9.0 and beyond. Both build users and plugin authors will learn what to do now and tomorrow to leverage the most of Gradle 9.

The road to Gradle 9 by Alex Semin, Louis Jacomet

The quality of AI-generated code is directly influenced by the quality of the data and coding standards it receives. In an environment where AI acts as a co-pilot for the development team, the code it generates will ultimately be read, maintained, and extended by the team itself. To ensure that the time saved by AI isn’t lost on tedious maintenance tasks, it is crucial that the generated code adheres to the team’s established best practices, including security constraints, design patterns, accessibility, and technical decisions. Moreover, maximizing the benefits of AI requires highly skilled individuals who can establish clear standards and critically evaluate the AI&#39;s output.At Packmind, we aim to tackle this challenge by accelerating developers’ skill growth through AI coaching and by integrating team best practices with AI coding assistants.In this session, we will explore how teams can easily and continuously define and maintain their development standards, and how AI can help extract those standards from the current codebase. Once these standards are established, AI can assist in enforcing them, help train the entire team, and generate code that aligns with validated human expertise. Through concrete examples, we will demonstrate how AI can become a true co-pilot for the team, contributing to the project&#39;s success while continuously improving the team’s development practices.

AI and Code Quality: Building a Synergy with Human Intelligence by Arthur Magne

Using the off-heap memory to store and process large amounts of data didn't change in Java since Java SE 4, when ByteBuffer was introduced. Since then, operating systems moved from 32 bits to 64 bits, and the available RAM in a regular machine moved from megabytes to gigabytes, and more. Another API was much needed, as a ByteBuffer is a 32 bits buffer, not enough for modern applications. First published as a preview feature in Java SE 19, the Foreign Function and Memory API made it as a final feature in Java SE 22. The Memory part brings several new concepts. Among them Arenas and MemorySegments now give you the possibility to manage gigabytes of contiguous off-heap memory, with a very elegant layout model. On the other hand, MemoryLayout allows for a C-struct like organization of your data in memory.&nbsp;This presentation shows you this complex API, in a step by step approach. It explains how your data is organized and aligned in memory, and the impact it has on the API. It also focuses on the delicate use of VarHandle, a critical element to access your data. It then shows you how you can load large files in memory segments, and shows you the performance you can get in the processing of billions of data elements.

Memory API: Patterns, Uses Cases, and Performance by José Paumard, Remi Forax

Digma is a free IDE plugin for finding performance issues in Java code.It uses OpenTelemetry behind the scenes to gather important traces and metrics and more importantly analyze them continuously to spot issues such as scaling problems, bottlenecks, N+1 Selects, or other inefficiencies. In this session, we'll take a look at how coding with OpenTelemetry feedback can improve your coding practices but also help find performance issues early, instead of dealing with them when they're already reported in production.There are no prerequisites to using the Digma plugin, no prior OTEL instrumentation is required and no code changes are necessary to get started. Crucially, the entire analysis is done locally on your laptop.

Find and fix performance issues in your code usign Digma by Roni Dover

In this session, I explore the transformation to becoming a more effective architect through pragmatism. Drawing inspiration from "The Pragmatic Programmer" book, I discuss the core principles of pragmatic architecture, striking a balance between complexity and simplicity. I emphasize adaptive decision-making with "Just-in-time" and "Just-enough-architecture" while promoting a culture of learning through the "Fail-fast" approach.I encourage architects to think big and start small, fostering adaptability with the Elsa Mindset. The Asoh Defense principle underscores the importance of taking responsibility for mistakes. Throughout, we stress the significance of effective communication in successful architectural endeavors. In conclusion, embracing pragmatism equips architects with valuable tools to make informed decisions, adapt to change, and efficiently deliver value to clients.

Architecting for Tomorrow: A Pragmatic Perspective by Marcel Schutte

Selenium is an open source umbrella project devoted to web browser automation. Although it can be used to automate different tasks in the browser, Selenium is used primarily to carry out automated end-to-end tests for web applications. Selenium WebDriver (usually called simply Selenium), the main component of the Selenium project, automates browsers by providing an Application Programming Interface (API) in different programming languages. The latest stable version of Selenium is version 4, released in October 2021. Many things have changed since then, and the Selenium project (to which I belong as an active committer) is currently working on the next major release: Selenium 5. This talk provides an overview of the most relevant features to be shipped in this new major version using Java as the programming language.To that aim, first, I will introduce the required setup to start developing Selenium tests, including build tools (Maven, Gradle), unit testing framework (JUnit 4/5, TestNG), or assertion libraries (like AssertJ).Then, I present Selenium Manager, a helper tool fully integrated into Selenium to ease the development of Selenium scripts by providing automated driver management. This feature has been implemented thanks to the lessons learned in the maintenance of WebDriverManager (i.e., the automated driver management library for Java), and it is available in all the Selenium languages. In addition to driver management, Selenium Manager provides automated browser management (for instance, based on Chrome-for-Testing -CfT-).Then, I explain another hot topic to be shipped in Selenium 5: the WebDriver bidirectional (BiDi) protocol. The WebDriver BiDi is a W3C draft that defines the bidirectional WebDriver protocol. WebDriver BiDi will allow different operations using a fast bidirectional transport (i.e., without polling the browser to get responses). In Selenium, the aim is for BiDi to be a standardized replacement for advanced operations currently supported by the non-standard Chrome DevTools Protocol (CDP).Finally, I discuss the importance of the Selenium ecosystem. Selenium has become central to existing libraries, testing frameworks, and other tools.

Test Automation with Selenium 5 and Java by Boni García

Let’s be honest, the tech we have today is amazing but it can also be complex. So, it’s only natural that the platforms we build want to hide that complexity to improve productivity, avoid mistakes, and reduce cognitive load. So, the more complexity we can hide, the better our platform? Actually no - we need to be careful that we create useful abstractions, not dangerous illusions. This talk reflects on two decades of building complex distributed systems, highlighting where abstractions helped and where illusions led to major disappointments.

Platforms: Build abstractions, not illusions by Gregor Hohpe

Embarking on your RAG journey may seem effortless, but achieving satisfying results often proves challenging. Inaccurate, incomplete, or outdated answers, suboptimal document retrieval, and poor text chunking can quickly dampen your initial enthusiasm.In this session, we'll leverage LangChain4j to elevate your RAG implementations. We'll explore:Advanced Chunking Strategies: Optimize document segmentation for improved context and relevance.Query Refinement Techniques: Expand and compress queries to enhance retrieval accuracy.Metadata Filtering: Leverage metadata to pinpoint the most relevant documents.Document Reranking: Reorder retrieved documents for optimal result presentation.Data Lifecycle Management: Implement processes to maintain data freshness and relevance.Evaluation and Presentation: Assess the effectiveness of your RAG pipeline and deliver results that meet user expectations.Join us as we transform your simplistic RAG experience from one of frustration to delight your users with meaningful and accurate answers.

RAG: from dumb implementation to serious results by Guillaume Laforge

Writing good code can be quite a challenge! While coding itself might not seem too tough, making sure your code behaves exactly as you want, now and in the future, takes a lot of dedication and hard work.One way to make sure your code is doing what it's supposed to is by writing tests. But here's the thing: not all tests have the same value!In this talk, I'll share my own journey from thinking "Unit tests are the ultimate solution to ensuring my code is solid!" to realizing "Wait, why did this problem pop up? My unit tests said everything was fine... I didn't think this could ever happen!".We'll delve into the core principles of writing good tests (and, naturally, good code). We'll also explore different types of automated tests, so by the end, you'll feel more confident in trusting your own tests.Our journey will take us through the testing pyramid, where we'll discuss how it's set up and its pros and cons. Then, we'll check out the testing trophy, which has a slightly different focus. This approach lets us achieve more with fewer tests, giving us more time to focus on delivering value to our customers and, of course, doing what we enjoy most: writing quality code!And don't worry, we'll have plenty of practical, real-world code examples to illustrate each topic, making it easier for you to put these ideas into action in your own projects.

Testing done right: From bugs to brilliance by Wouter Bauweraerts

Javaflame&nbsp;is a debugging tool that captures all function calls including argument and return values and plot them on a flamegraph.It runs locally, no servers required, and the output is a simple html.Just plug the agent and get the results.

Javaflame - Capture function arguments, visualize them in a flamegraph by Lucas de Carvalho Bueno

Masks are being used for thousands of years, all across the physical world, for reasons such as physical protection, rituals and hiding the identity of the bearer. Physical masks are probably the oldest privacy protection technology.When writing and printing, authors of books and articles used pseudonyms to hide their identity. Voltaire, Lenin and Banksy are well known pseudonyms: modern, written versions of the physical mask. In the digital age we now replace citizens’ identifiers by unique codes – having remarkably powerful and even counter-intuitive properties when based on cryptography.The public sector has two seemingly contradictory tasks: protecting citizens and their privacy, while maximizing value and efficiency for individuals and society. So should we minimize or maximize data?The Belgian public sector increasingly adopts cryptography for pseudonymization – a crucial, and yet sufficiently practical element in realizing the seemingly impossible.In this talk, Kristof introduces three practical cryptographic systems for pseudonymization. He has designed them, based on specific needs within social security and healthcare. If you live in Belgium, your personal data is probably already protected by one of these systems, today.

Privacy in Practice with Smart Pseudonymization: Lessons from the Belgian Public Sector by Verslype

Explore the innovative intersection of a multi-agent system (MAS) and music with MusicAgent, a groundbreaking homegrown project.This session delves into the creation of multiple unique agents capable of composing, arranging, and producing music through the fusion of coding with Python, Sonic Pi using large language models (LLM's).Witness the intricacies of using Sonic Pi for live music creation through code and generative AI models in crafting musical pieces. Learn about the challenges and triumphs in MAS-driven music creation and envision the future of music and technology.And not to forget, you'll experience the thrill of live electronic music performance, generated on the spot using MusicAgent.Discover how anyone can easily control the full music creation flow, from conceptualization to recording, and even creating album cover art.Are you ready to start coding and generating and creating your own songs?Join me to see how MusicAgent can transform the musical landscape!

Harmonizing Code and Melody: making electronical music in a matter of speaking! by Jan Van Wassenhov

Your mission, should you decide to accept it, is the following: aggregate temperature values from a CSV file and group them by weather station name. There’s only one caveat: the file has one 1,000,000,000 rows!This is the task of the “One Billion Row Challenge” which went viral within the Java community earlier this year. Come and join me for this talk where I’ll dive into some of the tricks employed by the fastest solutions for processing the challenge’s 13 GB input file within less than two seconds. Parallelization and efficient memory access, optimized parsing routines using SIMD and SWAR, as well as custom map implementations are just some of the topics which we are going to discuss.I will also share some of the personal experiences and learnings which I made while running this challenge for and with the community.

1BRC – Nerd Sniping the Java Community by Roy van Rijn, Gunnar Morling

The rapid evolution of AI applied to software development has given rise to powerful tools such as Github Copilot. However, dependence on an internet connection, lack of control over the model, associated costs and concerns about data confidentiality have paved the way for a revolutionary alternative: Tabby.Tabby offers a similar experience to Github Copilot, but stands out for its 100% FREE accessibility and open source status, giving its users complete autonomy. With one click, you can deploy your own Tabby instance, either locally or on your own servers. Imagine AI-assisted coding on a plane or train, regardless of Wi-Fi availability! The Tabby extension for VSCode, IntelliJ and others lets you start coding without worry.With Tabby, the AI model used for code generation can be chosen from various Huggingface Hub models, and the whole thing can run directly on your computer, without requiring an internet connection.In this presentation, we'll explore Tabby's features, its architecture, and how it's redefining our approach to AI-based code generation. Join us to discover how Tabby can unleash your creative potential while preserving your freedom and privacy.

Tabby, my free "Copilot" by Rafik Ferroukh

Every backend developer has struggled with the problem of endpoint versioning. There are several ways to address this, but existing solutions did not meet all my needs. So, I decided to create my own library to solve this problem in Spring Boot.In this talk, I will explain the characteristics I expect from a proper URI path versioning solution. Furthermore, I will demonstrate, with live coding, how you can solve this problem. We will start with a simple hardcoded solution and gradually improve it until we reach the final, robust solution.After attending this talk, you will have a clear idea of how to elegantly solve the endpoint versioning problem in Spring Boot. Even if you prefer other frameworks, you will be able to apply these techniques and create your own library.

Endpoint versioning made simple by Bouke Nijhuis

Join us for a tour of the new possibilities in coding with AI and LLMs. We’ll demonstrate practical ways to speed up development and break down knowledge silos. You’ll see what's already possible in Java today and learn about the imminent shifts in our coding practices. Discover how to effectively integrate AI into your applications and business processes, and get inspired to harness its potential for a positive societal impact. Learn how to thrive as a developer in an AI-driven future and start unlocking a world of innovative solutions with hands-on examples that you can start using immediately.

AI-Powered Development: Hands-On Techniques for Immediate Impact by Lize Raes

The internet is full of micro benchmarks explaining the world to beginners. Everyone able to use JMH is trying to explain the world, but only a few do it right. Most benchmarks are either entirely wrong, or draw the wrong conclusions. We're going on a journey to discover and question published microbenchmarks, figure out when you need your own, and decide when you shouldn't run any.The presentation begins with a straightforward introduction to microbenchmarking, using a simple approach that anyone can grasp. You will gain insights into potential pitfalls and learn how to avoid them, ensuring the validity of benchmark results. By the end of the presentation, you will not only be equipped with the skills to conduct meaningful microbenchmarking, but also develop a critical eye for evaluating the validity of results from others.Besides the obvious microbenchmarking tools and techniques, you will also learn a lot about the inner workings of the JVM, your hardware, and how they interact with each other. At the end, you will hopefully be able to make the call whether microbenchmarking is needed at all in your daily work.

Micro Benchmarking - The Art of Realizing One is Wrong by René Schwietzke

Doctolib, a renowned company across several European countries, offers comprehensive online services for healthcare professionals and patients.Originally built as a Rails monolith, Doctolib is undergoing a significant technical transformation towards a multi-services architecture, leveraging a diverse range of technologies including Java, Spring Boot, and many others.In this session, we will delve into how a platform engineering approach is essential to support such a transformation. We will explore the critical challenges and engineering practices that differentiate a monolithic architecture from a multi-services architecture. Attendees will gain insights into:The key principles of platform engineering and their role in modernising legacy systems.Strategies for seamless migration from a monolithic structure to a multi-services framework.Real-world challenges faced during the transformation and effective solutions.Best practices for maintaining and scaling a multi-services architecture.

From monolith to multi-services, how a platform engineering approach transforms your business ? by

The term “developer experience” (DevEx) emerged in the early 2010s as a response to the growing importance of developer communities in the tech industry, ensuring happy and productive developers through a seamless experience. While numerous theoretical guidelines exist for DevEX, this talk focuses on practical implementation and case studies. Drawing from our own experiences in large organizations like Rabobank &amp; Bol.com, we explore diverse approaches to fostering a DevEx culture. We will show how different high-level incentives behind DevEx Culture adoption, change the strategies of big and medium size organizations toward the implementation. Finally we will also introduce qualitative metrics that guide strategic decisions while fostering a culture of continuous improvement.Takeaways:Understanding the importance of relation between Developer Experience (DX) and Platform Engineering.Learned lessons from real-world examples of large/mid-sized companies.Practical tips on what services can bring more value for your companyBest measurements to help your company to weight their success in developer experience and platform engineeringDiscovering how AI can enhance Developer Experience.

Developer Experience : From Hype to Reality by Soroosh Khodami, Makan Sepehrifar

Every day, hundreds of thousands of users around the globe interact with applications built on Java, many of which were developed over a decade ago. With the increasing dominance of mature, modern web technologies, these applications now require a fresh, responsive and dynamic user interface. To address this, developers often turn to JavaScript and TypeScript UI frameworks like Angular or React. However, integrating multiple tech stacks within a team can be more complex than anticipated, especially when combined with design patterns such as microservices.This session explores the contrast between this multi-stack approach and another powerful development paradigm: modern single-stack Java UI frameworks. These frameworks allow developers to homogeneously build both the frontend and backend entirely in Java - allowing businesses to optimize their application development in a low-risk stepwise fashion while eliminating potential friction between disparate development teams.

Java-Centric Web Development: The Advantages of a Single Stack Approach by Matthew Hawkins

Spring AI is a framework that helps Java developers to effortlessly incorporate AI into enterprise applications. At its core, Spring AI addresses the fundamental challenge of AI integration: connecting enterprise Data and APIs with AI models.In this session, the Spring AI project leads will introduce key AI concepts essential for Java developers and demonstrate how to rapidly develop AI applications using Spring AI. We'll showcase Spring AI's components and design principles, including portability and modular design, POJO-based architecture for AI applications, a portable client API for AI model interaction, techniques for creating effective AI prompts and handling responses, and support for calling user-defined Functions.We'll explore practical use cases, such as "query over your docs," highlighting Spring AI features like creating and managing embeddings, semantic search and integrating with vector databases, and utilizing a lightweight ETL framework for document processing.The session will cover the popular RAG (Retrieval-Augmented Generation) and Function Calling patterns and methods for evaluating AI application correctness.&nbsp;

Most viewed talks Devoxx Belgium 2023.

Last updated at 2024-10-30 13:24:41(Stockholm/Sweden)