Quarkus at Devoxx UK 2023

[insectengine]

Event Description: Devoxx UK is a space for developers to learn, sharpen their skills and get hands-on experience with the latest tech.

Date: May 10-12, 2023
Location: London, England
Event Type: In Person

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

Quarkus Sessions

WEDNESDAY

Writing Greener Java Applications
View the Youtube Session Recording
Date and Time: Wednesday from 11:00 - 11:50 in the Room D
Speaker(s): Holly Cummins
Session Link: https://www.devoxx.co.uk/talk/?id=1965
Abstract: The code we write has a climate impact. But how big is that impact? How do we measure it? How do we reduce it? Is the cloud helping? What’s going on with Virginia? Are we still allowed to do CI/CD? Will native compilation save us? Is Java even a good choice anymore? This talk discusses some of the trade-offs for a modern software developer, and provides a roadmap to figuring out the right thing.
Disclosure: Holly works on Quarkus. Along the way, she will talk about Quarkus sustainability measurements we’ve been doing … but it’s ok, because she promises that the Quarkus carbon data is exciting and interesting.

Quarkus for Spring Developers
View the Youtube Session Recording
Date and Time: Wednesday from 14:50 - 15:40 in the Auditorium
Speaker(s): Eric Deandrea
Session Link: https://www.devoxx.co.uk/talk/?id=1971
Abstract: Are you familiar with Spring and like learning new things?
In this session, I will show concepts and conventions familiar to Spring developers and how those same concepts and conventions can be implemented in Quarkus, all while highlighting similarities and differences between them. Additionally, I will show similarities and differences in how testing is done, highlighting Quarkus Dev Services and continuous testing.
This session will be mostly live coding while minimizing the amount of slides. I will introduce an existing Spring application with a full test suite and build a Quarkus equivalent version of it, live. Content will come from my book, "Quarkus for Spring Developers."

Thursday

Kiota, this is not your father's OpenAPI Code Generator
Date and Time: Thursday from 08:15 - 8:20 in Room A
Speaker(s): Andrea Peruffo
Session Link: https://www.devoxx.co.uk/talk/?id=18953
Abstract: Everyone used to struggle with OpenAPI client code generation, and we often fallback to manually rolling out HTTP calls which is a boring, error-prone and time consuming activity.
In this session I'll show you the breath of fresh air that Kiota(a project by Microsoft) is bringing into this space, aiming to quickly rise the bar and provide the best-in-class developer experience.

Java in the Cloud
View the Youtube Session Recording
Date and Time: Thursday from 09:00 - 9:50 in Room B
Speaker(s): Mark Little
Session Link: https://www.devoxx.co.uk/talk/?id=20265
Abstract: In recent years, Java and Java frameworks have evolved significantly, especially due to changing environments in which they must be deployed. Developers have had the most impact on Java in recent years as they have adopted Cloud and specifically Kubernetes. A number of significant changes are coming for developers, such as the push for Secure Software Supply Chain, AI/ML, and Edge Computing. Keeping Java relevant to these growing developer communities will require continued evolution. In this session, we will examine these influences and others and suggest how Java should adapt to these changes.

How to avoid common pitfalls with modern microservices testing
View the Youtube Session Recording
Date and Time: Thursday from 10:00 - 10:50 in Room B
Speaker(s): Holly Cummins & Eric Dandrea
Session Link: https://www.devoxx.co.uk/talk/?id=1970
Abstract: Have you ever wondered why your microservices break in production after all the tests have passed during CI/CD? Have you ever wondered if you’re testing too much or too little? If you want to learn about common pitfalls and how to catch them at build time rather than at runtime, this session is for you!
In this session we’ll share some common battle scars from our experiences in the field. Additionally, we will introduce the testing pyramid and explain why it is important in helping to continuously deploy microservices independently without fear. We will demonstrate, through a test-driven development approach, how the combination of Pact contract testing combined with Quarkus developer joy can help prevent your microservices from breaking in production.

Write You An Actor (System) For Great Good! (with JBang, JDK 19, records, pattern matching and virtual threads!)
Date and Time: Thursday from 10:00 - 11:00 in the Code Cafe
Speaker(s): Andrea Peruffo & Edoardo Vacchi
Session Link: https://www.devoxx.co.uk/talk/?id=4275
Abstract: Learn everything about all the fanciest recent features of the JDK, by implementing an actor system from scratch!
In this mini-lab, we will explain how an actor system works, and live-code it right before your eyes using expression switches, records, sealed type hierarchies, and virtual threads!
We will compare our actor system to other languages and actor runtimes, and will bring all of this to your fingertips with the power of JBang!

Event-driven autoscaling for Serverless Java
View the Youtube Session Recording
Date and Time: Thursday from 11:20 - 12:10 in Room B
Speaker(s): Daniel Oh
Session Link: https://www.devoxx.co.uk/talk/?id=1968
Abstract: Kubernetes makes it possible to autoscale various business use cases from web apps to mobile, IoT edge streaming, and AI/ML in more reliable and stable ways. One caveat of Kubernetes autoscaling is based on hardware resource utilization (CPU, memory) through Horizontal Pod Autoscaling. This causes a new challenge to build an event-driven serverless Java on Kubernetes because the event metrics from multiple event sources (e.g., Apache Kafka, AWS SQS) are more relevant than a pod's CPU usage for deciding when applications need to be scaled out and in.
Fortunately, KEDA and Knative on Kubernetes are designed to solve this challenge by autoscaling both standard apps and serverless by event metrics in a separate way. This session will teach you how to redesign your Kubernetes autoscaling architecture by event-driven metrics from Apache Kafka over standard resources (CPU, Memory) with Knative and KEDA integration for serverless Java using Quarkus.

Taming Apache Kafka on Kubernetes using GitOps
View the Youtube Session Recording
Date and Time: Thursday from 12:20 - 13:10 in Room B
Speaker(s): Alex Soto
Session Link: https://www.devoxx.co.uk/talk/?id=7017
Abstract: Deploying an Apache Kafka cluster to Kubernetes is not an easy task. There are a lot of aspects to consider and components to configure, like ZooKeeper, the Kafka brokers themselves, topics, and users (ACLs/RBAC).
One option is doing everything by hand, writing all the YAML files manually, ad-hoc, according to your requirements. However, difficulties will arise from day two after the initial setup. For instance, how to manage the Kafka cluster, the creation and configuration of users and topics, security aspects, the replication of content to different clusters, or what about maintaining different environments?
The Strimzi project simplifies the management of Apache Kafka clusters on Kubernetes in various deployment configurations while following GitOps methodologies.
If you think running Kafka on Kubernetes is a natural choice, come to this session to learn how Strimzi and GitOps methodologies give you superpowers for managing Apache Kafka operations on a production Kubernetes cluster.

Cracking the scalability wall
View the Youtube Session Recording
Date and Time: Thursday from 14:10 - 15:00 in Room D
Speaker(s): Francesco Nigro & Sanne Grinovero
Session Link: https://www.devoxx.co.uk/talk/?id=2741
Abstract: Small things matter: sometimes the smallest detail can have an impact far beyond your imagination.
In this talk, we'll discuss a severe JVM performance issue discovered while working on Quarkus performance, but affecting the whole Java ecosystem. It is caused by a scalability bottleneck in OpenJDK existing for decades and is related to how CPUs are designed; the most surprising aspect is how common idioms will trigger the issue.
After explaining the issue Franz and Sanne will show how they improved performance by significant margins of several popular Java frameworks with simple, small changes.

Java, my life is short!
View the Youtube Session Recording
Date and Time: Thursday from 14:10 - 15:00 in Room B
Speaker(s): Kevin Dubois
Session Link: https://www.devoxx.co.uk/talk/?id=3484
Abstract: Java is a great language with a ton of features and capabilities that have made it into (arguably) the most popular programming language for enterprise organizations. It is robust, performant, scalable and rather feature complete.
But let’s face it. Java development can be slow and tedious.
The cycle of code > build > deploy > test and repeat is not ideal. Installing and keeping (multiple) versions of dependencies on your machine is a pain. Let alone building and deploying Java applications for Cloud Native / Kubernetes environments.
And most of all, we lose so much time waiting. Waiting for compilation. Waiting for (all) tests to pass. Waiting for native builds to finish. Waiting for Security scans. Waiting for a database to be provisioned, or a VM, or a Kafka cluster, or …
In this session we will try to show some interesting ways of shortening the inner and outer development loop. How to speed up local development. How to hit the ground running with dependencies like databases, kafka clusters and other dependencies. How to get more insight into how your app behaves and any security considerations for shorter feedback loops.
Spoiler alert, many these features come out-of-the-box with Quarkus, so it will be the go-to stack for this talk.
Takeaways:
Using a next-gen Java stack like Quarkus can exponentially increase developer productivity and joy.
Learn about tools like Dependency Analytics, Micrometer, TestContainers, Prometheus, etc.

Atomic Decomposition in AI systems using Knative Eventing and Quarkus
View the Youtube Session Recording
Date and Time: Thursday from 15:10 - 16:00 in Room B
Speaker(s): Ian Lawson
Session Link: https://www.devoxx.co.uk/talk/?id=24601
Abstract: A dive into the cool new technology of Knative Eventing using Quarkus to build complex applications using simple to write and agile components.

In this presentation and demo Ian will talk in depth about why atomic decomposition of applications combined with 'on-demand application capabilities' via Knative is so important for writing complex applications that take a much smaller resource footprint than microservices/monoliths. Also, using Quarkus, how easy it is to get started on this form of Event Driven Architecture approach to application design. In particular the use of these techniques in an AI perspective, building dynamic and fluid Neural Net simulations that allow complex applications to be easily realised quickly and resource efficiently.

This talk will include a demo assuming the demo Gods allow.

Metamorphosis of a Developer into an Architect
View the Youtube Session Recording
Date and Time: Thursday from 16:30 - 17:20 in Room B
Speaker(s): Pranjal Bathia
Session Link: https://www.devoxx.co.uk/talk/?id=8999
Abstract: As passionate technologists, we all think of solving complex business problems by designing and developing software systems end to end which add significant value to the business. In order to achieve this dream of becoming an established software architect, we need to understand what are the different roles we need to play at different stages as we progress in our journey. The responsibilities vary at every step of this journey which requires developing a mindset to have a holistic approach to solving business problems. The way you communicate your thoughts becomes equally important as you progress in your career and interact with a variety of stakeholders. It needs to be concise, simple and effective to grab the attention of leaders in a short span of time.
Please join me to understand how I planned my journey to become an established software architect, the phases of my career, the skills needed at every stage and the effective techniques that I used to keep progressing towards my dream.

From Cloud-Native Java and Quarkus with Love
View the Youtube Session Recording
Date and Time: Thursday from 17:30 - 18:00 in Room B
Speaker(s): Hans-Peter Grahsl
Session Link: https://www.devoxx.co.uk/talk/?id=7022
Abstract: Over the last couple of years, our industry faced many naysayers doubting that Java is ready for today's, let alone tomorrow's application development requirements. Too rigid, too fat, too slow, and too resource hungry were the usual suspects to question Java's "fitness" for developing cloud-native applications targeting Kubernetes. One day, Quarkus came along to demonstrate the exact opposite. Join this fast-paced session to learn about Quarkus, which is a new breed of Java application development framework. It builds upon well-established standards and technologies as well as battle-tested libraries, many of which you might already master or at least be familiar with. If you want to experience some of the goodness and love that Quarkus offers around its dev services and native image building capabilities on top of GraalVM this talk is for you. After this session, you'll have a first impression about what it means and how it feels to develop supersonic subatomic Java applications for the cloud era.

Friday

Service discovery and selection like a pro with Stork
View the Youtube Session Recording
Date and Time: Friday from 12:20 - 12:50 in Exec Centre
Speaker(s): Aurea Muñoz Hernandez
Session Link: https://www.devoxx.co.uk/talk/?id=10447
Abstract: In this era of microservice-based architecture where multiple services are interacting with each other, service discovery becomes an integral part as it provides a mechanism to find the service instances. However, it leads to another issue which is “How to select the right service instance in case we have multiple instances of a service running?”
SmallRye Stork is a service discovery and client-side service instance selection framework. It comes pre-configured with integrations for Kubernetes, Eureka, and Hashicorp Consul as well as a few selection methods, including round-robin. But the most noteworthy feature of Stork is its extensibility. You can create your own service selection strategy or plug in your own service discovery mechanism.
Come discover Stork and be ready to customize your own service discovery strategy!

In-Booth Code Jam

Swing by the booth and chat out our code rock stars as they go through some interesting coding sessions.

Wednesday, May 10th

Quarkus Makes Kubernetes Easier
Presenter: Daniel Oh
Time: 10:30 - 10:55

Building and running Containers with Quarkus and Podman Desktop
Presenter: Kevin Dubois
Time: 12:50 - 13:15

Supersonic, Subatomic, Spring
Presenter: Eric Deandrea
Time: 13:20 - 13:45

Openshift Sandbox: Kubernetes made easy
Presenter: Kevin Dubois
Time: 15:40 - 16:05

Thursday, May 11th

Openshift Sandbox: Kubernetes made easy
Presenter: Kevin Dubois
Time: 10:50 - 11:15

Accelerate Inner Loop with Quarkus Dev Services
Presenter: Daniel Oh
Time: 13:30 - 13:55

Supersonic, Subatomic, Spring
Presenter: Eric Deandrea
Time: 16:00 - 16:25

Friday, May 11th

Build Serverless Java from Scratch to Kubernetes in 5 min
Presenter: Daniel Oh
Time: 10:50 - 11:15

Building and running Containers with Quarkus and Podman Desktop
Presenter: Kevin Dubois
Time: 12:55 - 13:20

Quarkus supercharges native Java with GraalVM
Presenter: Daniel Oh
Time: 13:25 - 13:45

After Hours: DevROXX Party Sponsored by Quarkus and Red Hat

Date and Time: Thursday from 6:45 - Late
Location: Brewhouse & Kitchen Highbury
Address: 2A Corsica St, London H5 1JJ
Make sure you swing by the Red Hat booth to get your tickets!

[danieloh30]

@insectengine Can you add a space here? **Abstract:**Kubernetes