Traditional Java applications tend to be monolithic and long-running. Optimizations that work well for those applications may not work as well on a serverless platform. In this session, we will discuss the unique challenges for Java serverless applications and take you through some optimizations and tradeoffs that you can use to reduce startup time and memory usage.

Understanding complex Java systems is usually done by reading the code, using a profiler, debugging, and logging. A more effective way is to visualize what is going on inside the system, using a custom and domain-specific visualization. In this use case, Chris will show Project Cacophonia, to explore the internals of the Eclipse IDE. You will learn how it is constructed out of fragments, plugins, and features. We will see how they interact and how to easily find the code to make changes to the IDE itself. Lessons from this entertaining use case are expected to extend to your own applications or systems where you may consider using similar visualizations in the future.

As all known scala is little brother of Javabut do we all know what scala brings to the table. Which one is easier or which one is useful or complex. With this topic we will talk about pros/cons and will get decided who will win this fight!

Quarkus is a stack to build Cloud-Native applications in Java. Thanks to a novel built-time pipeline, it reduces the startup time and memory consumption of Java applications and offers the ability to compile Java applications into native executables. Also, Quarkus is a reactive framework. Since the incubation of the project, reactive has been a prominent characteristic of Quarkus.

In this talk, we will see the reasons behind making Quarkus reactive. We will cover different use cases for reactive and how reactive has been blended in the framework. We will also present the journey, as it didn't become reactive in one day. We will look at the individual steps, explaining the features provided by each of them and how they are making Quarkus a prominent actor in the reactive landscape.

Developers and security - it's a lot more than just turning on SSL. In this session we're going to show how to think differently about designing and coding in Java so that the application is less open to being attacked and (bonus) is often of higher quality. This taster talk will cover 7 types of development thinking that can get your application into trouble. With code examples (of course) we'll explore a serious of common code pitfalls and explain how to design and code differently. There is much to learn when creating a secure application - take your first steps here.

The Inner-Loop is changing: as Kubernetes becomes de-facto common fabric where to deploy our apps, it's important to prepare and boost local development into a so called cloud-native workspace. In this session attendees will get an overview of jKube, a collection of plugins and libraries that facilitate containerization and deployment to K8S in the Java way with Maven and a tookit to package Java apps trasparently.

Software development is riddled with people who choose to write their own solutions, even when there are valid existing alternatives. These developers are confident their solution is better. Most times they are wrong. This duplication and unnecessary activity leads to an accumulation of technical debt that is often owned by others. Examples are drawn from 25 years (as old as Java itself) of technical debt and hubris in the software verification space. This is a story about reducing roll-your-own solutions, choosing existing open-source tools and being humble in environments that often favour self-promotion over doing the right thing.

Do you want to explore and optimize even further your Java application? By having a better understanding of how Garbage Collection manages your application's memory, you'll have the power to implement a more optimized Java program. During this talk I will walk you through the Java Garbage Collection (GC) in some detail, how it is performed, why we need it, and how it differs from other memory management systems e.g. C++. Following that, there will be an explanation of the different ways the GC can manage the memory of a Java program, and I'll be using OpenJ9 GC as an example. After laying out the basics I'll explain the different policies that the GC contains and compare them to other policies such as G1, ZGC and Shenandoah. To conclude, I will mention an advanced feature of OpenJ9 GC, that is currently being implemented called double mapping arraylets, which is a way to improve the memory management of large arrays in Java in region based GC. This talk will be aimed to anyone with some knowledge of any programming language not just Java, being that basic, intermediate and advanced. The talk starts by covering the basics and gradually transition to more advanced topics.

As “the Cloud" becomes more and more widespread, now is a good time to assess how you can containerize your Java application. I assume you're able to write a a Dockerfile around the generated JAR. However, each time the application's code will change, the whole image will need to be rebuilt. If you're deploying to a local Kubernetes cluster environment, this increases that much the length of the feedback loop.

In this demo-based talk, I'll present different ways to get your Java app in a container: Dockerfile, Jib, and Cloud Native Buildpacks. We will also have a look at what kind of Docker image they generate, how they layer the images, whether those images are compatible with skaffold, etc.

Containers are all the rage these days. They're fast, they make deployment easy, they handle dependencies, they slice, they dice, they make julienne fries! But... what are they? What exactly is a container and how does it work? Just how does a container differ from the "old" silver bullet, virtual machines?

Here's a hint: It has nothing to do with boats, or whales, or shipping. That's all marketing fluff.

Containers are simply a shorthand name for leveraging newer features of operating system kernels that let the OS lie to programs about how they're running. In fact, all of modern software is built on lies. That's what's useful about it!

To understand how that works, why it's so useful, and where it's not, let's dive into how software actually works on a modern Linux system to see how those kernel features fit into the big picture, building up to "containers" along the way. Pull back the veil of lies and see how your computer really works.

"My team had a lot of products to manage, each in their own git repository.
All of the work involved with just keeping up-to-date was really limiting our progress into more exciting features.
Over a period of two years we've introduced a GitOps flow, migrated to a monorepo, built an auto-scaling test environment and started using Kubernetes namespaces for our testing.
In this talk we will look at both the technical solutions and the lessons learned. What worked? What didn't work? What was worth it? What would we have done differently if we knew better?
The talk is targeted towards Software Developers looking for ways to improve their workflow at the team level but the lessons learned should be relevant in a much broader sense."

With the rise of Distributed Architecture, independent DevOps teams and automated CI/CD the End-to-End test environments needs to be reconsidered.
They become flaky, shaky, untrustworthy and hard to maintain. Why are End-to-End test environments a dead End road and what are the alternatives.
Why are people still using these so called 'production-like' test environments and how can we achieve the same level of software quality without them.
I will give some ideas on how to solve the testing problems in a different way being less depending on those fragile environments.
After attending this talk I hope people are questioning the end-2-end test environments and have some ideas on how deliver without it.

We all write tests or pretend to do so, from some colleagues we've heard it is a must to have at least 90% coverage to sleep well at night, from others we learn that tests are not that necessary and only slow us down. Some say you need to write tests first, while others advice to write them afterwards. And which tests do you write among those categories: unit, integration, functional acceptance, component, system, contract tests?

I want to talk about all that comparing three different projects I've been working on, demonstrate how 'it depends' and some lessons learned.

When I joined ING, I was new to payments. I quickly learned that payments is a complex beast. Payments are in a lot of cases is based on "old" technologies, since it's usually one of the oldest service the bank runs. Most banks still run a considerable amount of COBOL code. That by itself poses a set of unique problems, and banks are moving over to modern Java technologies.

I was hired to start the reactive systems car, and quickly shift it into the fifth gear. Being an experience developer and architect with a great team is what really drove me for the past two years. We POC'd a number of reactive technologies and programming languages, to ultimately and up with Akka and Java.

Then we really started on our reactive journey : The initial design with took a month, the scoped target product, the actual development and at the end, the delivery and putting it in production. We had a few setbacks, messed things up, had success stories, and had a lot of lessons on implementing our reactive, scalable payment engine.

I want to share our story with you, and tell your how we did it, and delivered a modern, scalable, resilient system in a traditional world.

We will present a new Java based project combining two technologies which are seeing explosive growth in recent years: Blockchain and Online Gaming.
We will present the API design, Scaling Solutions, Decisions we took around cryptography and security as well as the integration of game bots with human players.

"Developers prefer working on their preferred workstation of choice, with an OS of choice and the most challenging problem working with other developers and developing teams to have projects running consistently across multiple operating systems. Besides creating fully-fledged development environment on a cloud, the benefits of docker is not only for deployment, also for development.
This talk will discuss how we've setup a consistent development environment for all our developers using Docker. We will discuss what has worked, what hasn't worked as well whether it's best to create your development workspace on your own workstation."

Leadership is not about knowing the way; it's about taking responsibility to find the path. Whether you are formally tasked with leading a team or just want people to trust your judgement, being a true leader will push your career forward and get you onto a path to success. This session will answer your questions and help you become a leader. Learn how to start now, no matter your official position in the company; what the correct leadership skills are; and how to acquire them. Stop feeling adrift. Start leading and forging your own path.

JHipster is a widely used, Open Source application generator platform for creating simple Spring Boot web apps and complex micro-services architectures with Spring Cloud, Eureka, Consul, Prometheus, ELK, Docker, Kubernetes, Istio, and much more!

In this session, I'll showcase how to use JHipster to build microservice architectures easily even if you are a junior developer. JHipster does the heavy lifting here with proven architecture models while you can focus on business needs and building your entity model. We will build a fully functional e-commerce microservice application during the session.

The major challenge during building a GitOps-based CI/CD system used by nearly a hundred teams, was how to automate the provisioning and long term management of the system. We opted to accomplish this by building a set of Kubernetes Operators and use Custom Resource as our API to the rest of the world. We created our Operators using Java, which turned out to be a good choice in a team full of Java developers.
In this talk I will explain the journey we went through and myriad design decisions we had to take to fully automate the management of the CI/CD system. At the same time I will explain how developing Operators using Java was like and what we did to help ourselves and others go down that journey.

Have you found in your team that your colleagues are building things but you don't know what are they doing or the reason why? Have you been struggling with some code someone pushed into your module without noticing it? Have you stayed in a team as the only one person who knows about X or Y?

If you have answered yes to any of these questions, then, this talk is for you. We will show you how in Dynatrace, and specifically in our team, we are applying eXtreme Programming (XP) techniques and how they are helping us to mitigate and even solve those kinds of problems.

We have managed to turn it around, and now we are happier at work. We have less bugs, less frictions and at the same time, we know more how to evolve our components as we need. Yes, we have invested more time in analysing or studying things in common but we have increased the knowledge sharing.

It has been (and still is) difficult. For example, we have invested a lot of time (and money) to run sessions of programming in pairs / mob programming and we have been repeatedly asked how that is? Really? More than one person in the same thing? Also, we have had to break down some reluctances and fears, and yes, these are tremendously difficult things to change. Imagine someone who has never practiced TDD, making her/him understand that s/he has to write tests first?

In summary, we will try to show you the advantages (and disadvantages) of applying techniques such as TDD, pair-programming and Continuous Integration and how they helped us to grow not just as better developers, but also as a well-connected and performant team.

In this talk we will cover concepts and applications of clean architecture, clean code, when and how to refactor our code and why it is important to write tests, with examples in Java and Spring Boot. I intend to pass on some good development practices that I have been learning and are widely used in the market.

Blockchain was a trending topic during the last years. To develop a distributed ledger in Java, you need to have the greatest skills possible, because a single bug might represent the loss of many tokens for your users. But that's not the only challenge: the distributed ledger has to be designed with a business-ready oriented functionality and a user-friendly integration and interface.

Therefore, I will explain what are the basic architecture components, how they are designed and the tools used to make it work like a Swiss clock, Jetty, IntelliJ as IDE, cryptography. Having a network of more than 1.000 nodes up&running worldwide is not a simple task.

There was never a better time to be a Java developer. Micronaut, Quarkus, GraalVM are just some of many. And with new (not so, actually) release cycle Java was pushed to the limits. In less then 1 year we will have our next LTS Java version. Predictions of the future were never very accurate, but we will try our best to predict how Java 23 will look like and what future prepare for us.

When containerization came out (7 years ago!), the only option to containerize a Java was to write a Dockerfile and ADD the jar to the image; container orchestration was not a thing yet.
Since then, many image building tools appeared (bazel, buildah) - even a Java based one! (Jib).
In this talk, we'll quickly discover the pros and cons of those options - we'll then focus on "buildpacks" (including how to create our own), that promise to free the developers from building concerns.

Today clean and code quality practices are what unit testing and continuous integration were 10 years ago.
We all know about them, we all agree with them, we all try to apply them. Some of us succeed some of us fail.

In this session, I will discuss my personal experience about code quality and clean and how we can take it to the next level using lean tools and practices.

Processing the unbounded streams of data in a distributed system sounds like a challenge. Fortunately, there is a tool that can make your way easier. Łukasz will share his experience as a "Storm Trooper", a user of Apache Storm framework, announced to be a first streaming engine to break the 1-microsecond latency barrier. His story will start by describing the processing model. He'll tell you how to build your distributed application using spouts, bolts, and topologies. Then he'll move to components that make your apps work in a distributed way. That's the part when three guys: Nimbuses, Supervisors, and Zookeepers join in and help to build a cluster. As a result, he'll be able to show you a demo app, running on Apache Storm. As you know, Storm Troopers are famous for missing targets. Łukasz will sum up the talk by sharing the drawbacks and ideas that he missed when he first met this technology. After the presentation, you can start playing with processing streams or compare your current approach with the Apache Storm model. And who knows, maybe you'll become a Storm Trooper.

"You need to develop microservices in Java and you don't know where to start. You need REST endpoints with OpenAPI contracts, you need to exchange asynchronous messages, check the health of the entire systems, gather metrics, all that in a resilient way, compiled with GraalVM and packaged with Docker. Where do you start?

What about MicroProfile? And what about Quarkus as the runtime?

This talk uses a little amount of slides and a all lot of code. I will start by presenting Quarkus and MicroProfile to then dive into developing a few microservices interacting with each other through REST calls and Kafka topics.

Join me in this hands-on talk"

Everyone knows it's important to stay relevant in a rapid changing world. In software craftsmanship, it's important to continously work toward your goal. Things aren't always easy or straightforward. In my talk I will take you along my journey of a software craftsman and how you can take your career into your own hands. I'll show you how books, courses, blogs and a healthy lifestyle are an important part of my career (and how I find the time for all that). I'll show you my most recent pet project, an exciting Deep Learning project, that is part of my journey of transforming data into value for a living.

"Alibaba Dragonwell is the engine that runs the distributed Java applications in extreme scaling at Alibaba, supporting various application scenarios covering e-commerce, logistics, and e-finance. In this talk, we will describe the challenges in scaling Java applications in the cloud and the solutions which have been open-sourced in Alibaba Dragonwell: (1) we developed a multi-tenant mechanism that allows running multiple applications inside one JVM instance. The resource consumption (CPU, memory) of each of them is constrained at the tenant-level. (2) we integrated the lightweight threads (coroutine) into JVM to support asynchronous programming. (3) We built a series of tools to help our developers do an efficient problem diagnostic.
Finally, this talk will give the audience an overview introduction about the Eclipse Jifa project, a web application based on the Eclipse Memory Analyzer Tooling (MAT), and describe how the Jifa can help the developers do the heap analysis in the cloud environment.
We will describe how the characterization of our Java workloads would guide us to implement these features. While your workloads are different, the thought process we went through could be useful for you too.

In this session I will be covering the lessons learned in creating Web3j, the Java integration library for the worlds most widely used blockchain, Ethereum (in 2020 the transaction volume and value on Ethereum overtook Bitcoin https://cointelegraph.com/news/ethereum-flippens-stablecoins-to-become-the-most-used-blockchain).

I first started working on Web3j back in 2016 as I wanted to work with Ethereum on the JVM, this sent me down a rabbit hole which resulted in Web3j.

4.5 years later Web3j is still going strong and approaching 1 million downloads. It has a team supporting it, but as with any technology it can always be improved. I'll cover some of these improvements and some of the great things we've been able to do with the library in this time.

In this session, Álvaro, a member of the Micronaut core development team, will showcase the options to deploy Micronaut application to public clouds such as AWS, GCP and Azure, including serverless scenarios, GraalVM-compiled native images and Kubernetes support.

Most developers have experience with dependency injection (DI), whether it's with Spring, Google Guice or CDI. But how many developers actually know how these frameworks make this magic happen? Or how dependency injection works in general? I, for one, didn't have a clue. That's the reason I built the Injectinator: my own DI implementation for Java SE. Creating the Injectinator has thought me a lot about DI and how the "magic" happens.

In this talk I will show the audience how Java reflection works, and how they can harness its capabilities to create their own dependency injection framework. The following subjects will be covered:

Reflection in Java
Inversion of Control
What is Dependency Injection?
Types of Dependency Injection
All of this will be demonstrated with a live demo.

After this talk you will have a better understanding of how a DI framework works and you should be able to build your own DI framework.

This lecture's objective is to make comparisons between points and weaknesses of Java frameworks that integrate with databases. On the one hand, the NoSQL MongoDB, Redis, Neo4J, and Cassandra, and on the other, the Java frameworks that integrate with them: Spring, Quarkus, Jakarta EE, Micronaut. The arena: the cloud!
In this ring, the one who best analyzes each tool's trade-offs wins in this epic battle.

"You need to develop microservices in Java and you don't know where to start. You need REST endpoints with OpenAPI contracts, you need to exchange asynchronous messages, check the health of the entire systems, gather metrics, all that in a resilient way, compiled with GraalVM and packaged with Docker. Where do you start?

What about MicroProfile? And what about Quarkus as the runtime?

This talk uses a little amount of slides and a all lot of code. I will start by presenting Quarkus and MicroProfile to then dive into developing a few microservices interacting with each other through REST calls and Kafka topics.

Join me in this hands-on talk"

Do you want to further optimize your Java application? Of course, you do. You will be happy to know that the everlasting pursuit to optimize Java applications is the driving force behind this new garbage collection (GC) feature that will be the focus of this talk. This feature is currently available on the OpenJ9 JVM, however in theory this can be implemented for any copying collector.

Legacy applications that were developed in bygone days may appear to be close to unsalvageable. In reality, these applications are still running in production and carrying out the important day-to-day missions for their respective companies. After all, companies have spent a considerable amount of time and money on developing those applications, and despite the lack of perfection, these applications nonetheless keep their companies in operation. So does it make sense for an entire legacy application to be re-written? Keep in mind that the implementation of certain business functionality can be a daunting task for the busy developers. How about if we re-design the system, and identify pieces of the complex business functionality in the legacy system that can potentially be «recycled», and retrofit them into the new system that leverages on the power of the reactive data flow pipeline?

This presentation will be a lively discussion with hands-on coding to illustrate how to construct a reactive, event-driven data flow pipeline, which are composed of different library implementations of the Reactive Streams specification, such as Akka Streams, Eclipse Vert.x and RxJava. The sample use case will mimic a real-life example of data being collected from multiple distributed sources, which will then be fed to a legacy processor as «wrapped» by a reactive microservice for transformation, after which the resulting data will flow to a «sink» to be prepared for further processing. We will highlight the strength of the Reactive Streams in controlling backpressure during processing.