Persistence is the soul of modern architecture. It is a way to have a state in the stateless application, mainly in distributed systems such as microservices and cloud age app style.
We handle various persistence sources such as SQL, NoSQL, or even web services. With a considerable amount of options or flavors, how can we have a business away from these details or have a loose couple between the application and the persistence engine?
This presentation will discuss the new trends in the modern persistence model around enterprise architecture.
For years, we’ve been told that Java suffers from cold starts in AWS Lambda and Serverless in general. Believe it not. Java is extremely fast to start, the simplest Java program starts in milliseconds. It’s the Java frameworks and libraries that slow things down in general. But not all of them…
In this session, I want to show you the truth about Serverless Java and cold starts, what’s slow, what’s fast and why it matters. We’ll go through what a cold start is, how cold starts in AWS Lambda impact your application responsiveness and cloud costs, and what are the options to optimize both. We’ll explore and compare Quarkus and Piranha Cloud, the most modern and fastest Jakarta EE frameworks. We’ll test the limits of what they are capable of, how fast they start and whether we even need to think about any optimizations. Then I’ll explain what optimizations may help if you need to go further, like tuning the JVM, using a custom JVM runtime or building a OS-native binary with GraalVM. However, there are also a few limitations and cost implications of these optimizations, which we'll also explain.
I’ll show and tell, with very few slides. You’ll see live for yourselves how Java AWS Lambda functions built with Jakarta EE can start fast and decrease the cold starts to the absolute minimum which you can barely notice
The architecture and design of an application significantly influences its maintainability, testability, and quality in general. Spring has always been a versatile tool that supports architects implementing the practices and patterns that have emerged to align technical building blocks in their code bases with domain concepts and boundaries. It lets developers build applications that clearly reflect architectural ideas and that are ultimately more amendable and maintainable. Key aspects of that are code organization for encapsulation, the Spring bean relationship arrangement, and how to use domain events to decouple logically individual parts of the application even within a singular artifact.
This talk discusses those patterns and approaches to introduce libraries, such as jMolecules and Moduliths to, in turn, show how they uniquely position Spring developers to build better structured, more maintainable applications.
This talk shows you how to produce telemetry from your Java services using an open standard to retain control of data. OpenTelemetry allows you to instrument your application code through vendor-neutral APIs, libraries, and tools. It provides the tools necessary for you to gain visibility into the performance of your services and overall latency.
In this session, Anton introduces OpenTelementry and what's the current status in Java. He will show some real examples and all the required resources to start taking advantage of OpenTelemetry to monitor Java applications.
Java is innovative with each release, and to become a creative engineer for your company, you should know what is new in your language. This session will sweep the dust off Java SE's 19 hidden gems, including new cool language features, compiler changes, library additions, and critical bug fixes, and they're handy in your day-to-day work.
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 research … but it’s ok, because she promises that the Quarkus carbon data is exciting and interesting.
But what is awesome? Well, for instance, an awesome app reacts to failure and still remains functional, can provide information about its status, can provide an easy way of enabling easy way of toggling features, is easy to test, and is fast – it is ready to go to prod right away!
We talk about these and other features and show you some options while we build an (slightly opinionated?) demo application from scratch. Join us for this fun evolution of a few lines of code into a modern cloud-native application!
More and more developers are writing applications that will later run in a Kubernetes cluster. What can be so difficult about this? Starting with "How do I structure my repositories?", "Where do I put my code for deployment (container files, helmet charts, config values)?", "What needs to be considered when developing the application?", "How do I get the code tested locally?", "How do I get to see what is happening in the test cluster?"
Using a Java application as an example, this talk goes through the typical development steps from putting it in the VCS to deploying it on a cluster from a developer's perspective.
Our industry is rather amnesic. Today, most young Java developers ignore what happened during the early 2000’s that led us with the frameworks and tools we are using today.
That’s too bad because this knowledge would help them to be better developers by understanding the long and winding road, we went thru during these last 20 years.
In this session I’ll go back on the major events of this story with a trolling level at the minimum possible.
We will travel in time to understand the EJB curse and see the Spring 1.0 birth. Then we’ll explain EJB 3.0 reinvention, CDI emergence and Spring Boot launch.
The temporary end of the story will lead us to talk about MicroProfile, Quarkus and Spring Native.
During our journey we’ll try to understand the naming malediction that turned J2EE in Java EE and then Jakarta EE (and no, JEE doesn’t exists). We’ll also try to explore most Spring attempt to build a profitable business model.
At the end of this talk you should have a better overview of the Java Enterprise ecosystem and understand why you should remove J2EE or Java EE (and of course JEE) from your CV if you only are a Spring expert.
Apache Maven is an ubiquitous build tool in the Java ecosystem, some even claim it's the defacto standard build tool. Configuring Maven is deceptively simple, after all it's just a matter of writing XML, isn't it? Things look differently when the rubber meets the road. One must know the intricacies of the build lifecycle; how plugins, goals (mojos), and phases come together; rules for dependency resolution; configuration inheritance between parent - child POM files; enhancing the build with profiles; and more. These features may trip you over if the rules that govern them are unclear. We'll present a series of scenarios to test your knowledge on Maven rules. we guarantee you'll leave this session with a few bits of new information and better understanding of the Maven build tool.
Developer teams are constantly under pressure to deliver new features and functionality without impacting core applications. In this session we’ll show how to add and deploy new application features reliably and securely without changing the core application or impacting core business activity. Highlights will include feature flags, AB Testing, and blue-green deployments using GitHub actions and GitHub repos, plus powerful cloud services based on serverless technologies, and managed container orchestration using Kubernetes.
Do you fear missing the Serverless/Microservices/DDD/Reactive/GitOps era? You're not alone. Despite hyped technologies, not everyone is working at a FAANG and many consultants out-there struggle to modernize well-established development teams culture, technology and process. This talk presents a generic approach used in two mid-sized government institutions (500+ employees) running projects in Java and NodeJS. Describing how these institutions were evaluated, trained, and most importantly how DDD, Reactive, GitOps, Kubernetes . . . makes sense (or not) in this kind of context. Presenting the current results and how developer's life improved (or not) by reducing technical debt.
Improving security in the Open Source ecosystem is currently a priority on the global agenda. DevOps and DevSecOps have contributed to creating a framework with many opportunities but challenges in which the Java industry and ecosystem evolve regarding security.
In this session, we will deconstruct security in Open Source and the Java ecosystem. We will present the challenges, opportunities, and recommendations to improve the security management of your new and existing architectures under an approach supported by DevSecOps principles.
Duke needs your help in navigating through the Delta Quadrant. Join us on this incredible journey visiting new features of the JDK 19 system as well as the best features of previous versions of Java. During this journey, you can improve your craft as an engineer. These short challenges will keep your katas going at warp speed! Solve the puzzles to learn the full power of the Java language. Apply the techniques, and develop concise code where bugs will have a hard time hiding. Come to this session to boldly go where no Duke has gone before!
Virtual threads will be very likely the next big game changer in the Java ecosystem, allowing to have the scalability of asynchronous programming models with the simplicity of synchronous code. Their main claim is that, differently from native threads that are a costly and then scarce resource, you can create as many virtual threads as you want with known and much cheaper memory and performance impact than the native ones. But is this always true? What are the costs of scheduling thousands or even millions of virtual threads? Does the more frequent context switch have some performance implications? What about the cache misses that these context switches could potentially imply? During this talk we will try to answer these questions in a funny way, by analyzing an implementation of the traditional Conway's Game of Life based on the communicating sequential processes (CSP) model and using both virtual and native threads with different algorithms in order to compare their performances. Based on this analysis we will also try to derive some rules of thumb on when and how using virtual threads.
In 2003, Heinz was asked to fix bugs and add features to a bowl of spaghetti code. It was a dismal task. He had heard of IntelliJ IDEA's supernatural analyzing powers. At the end of his 30 day trial, he purchased his first IntelliJ license. Often after his talks, instead of asking about the topic he spoke about, curious onlookers wanted to know how he had performed his IntelliJ magic. Here are your answers.
A year ago I started with a couple of friends a new project to create a visual editor for integrations: based on a visual drag and drop selection on building blocks, generate deployable source code.
As responsible of the backend side, I obviously chose Java to do it. Some of the challenges were to have an extendable and customizable core where we could inject module languages to generate different outputs depending on how the user wanted to deploy. We also wanted to customize the catalog of building blocks to dynamically adapt to each user. Coming from the Java 8 world with shy traces of Java 11, I decided to jump directly to Quarkus on Java 17 and explore the serverless possibilities while, at the same time, keep the over-engineering and the over-fanciness of new features as reasonable as possible.
On this talk I will describe the bowels of Kaoto.io, the journey we had to implement a stable architecture, and how it evolved into the powerful tool it is now. I will discuss about the technologies used, their shortcomings and their black magic; and why the decisions made were the right ones (or not!).
This is a good talk if you want to see Quarkus in a real use case.
"Just leave the garbage outside and we will take care of it for you". This is the panacea promised by garbage collection mechanisms built into most software stacks available today. So, we don’t need to think about it anymore, right? Wrong! When misused, garbage collectors can fail miserably. When this happens they slow down your application and lead to unacceptable pauses. In this talk we will go over different garbage collectors approaches and understand under which conditions they function well.
We've all heard the hype: Quantum computers will leave our current machines wallowing in the dust. Quantum algorithms will crack our existing encryption schemes in seconds. Will it really happen? The answer depends on engineering problems that have yet to be solved. But for those of us who write code, many insights are already available. In this session, I'll run Java code from Johan Vos's Quantum Computing in Action book. I'll use the code to describe how quantum algorithms approach problems.
Have you ever peeked behind the curtain on Java? Beyond Java 8, there's a lot of cool stuff to be discovered. We talk about the "fun and shiny" features you may not even know about. See how the JDK, JVM, and the Java language have all evolved and improved--now making you more productive and forcing you to write more secure code. This session is jam-packed with fun and shiny areas to accelerate your developer productivity.
The JVM comes with more than 700 configurations. With all of these options, it can quickly become confusing as to which configurations you should set and how. Getting JVM configurations right with a container in the mix is enough to drive even the best of us mad. In this session, we'll explore memory and other settings that can have a significant impact on the performance and stability of your Java application. We'll also look at how to blend sensible JVM and container configurations.
Enabling applications to really thrive (and not just survive) in cloud environments can be challenging. The original 12 factor app methodology helped to lay out some of the key characteristics needed for cloud-native applications... but... as our cloud infrastructure and tooling has progressed, so too have these factors.
In this session we'll dive into the extended and updated 15 factors needed to build cloud native applications that are able to thrive in this environment, and we'll take a look at open source technologies and tools that can help us achieve this.
Who doesn’t want to work more effectively, to work smarter, and get more done? We want to focus on what adds value, increase our development speed, and cut out all the cumbersome, boring and repetitive tasks as possible.
This session shows principles how to accomplish the goal of being more effective and efficient as developer. We’ll see how to automate the boring parts of our job, what big and small tips and tricks help us, which mindsets to follow, why we have the best job ever, and how to enjoy our work even more.
We don’t have to exert much mental effort when writing blocking code, but this has drawbacks. Non-blocking code, on the other hand, could be used to increase application throughput. This is why non-blocking code is recommended in many scenarios. Over the last two decades, many approaches have been introduced to writing code that does not block.
In this session, we will look into those options that are available to us. To begin, I’ll go over the evolution of the Java concurrency model since its inception with the vanilla thread. Then I will introduce Future/Callable, and CompletableFuture, briefly go over reactive programming, and finally conclude with the Project Loom that was added in Java 19.
Wordle is a popular online game where you have up to six tries to guess a hidden five-letter word. By combining the power of the JavaFX UI toolkit with the latest Java Development Kit features, we show how to implement a version of Wordle for desktop and mobile devices (iOS and Android).
Learn how to create the main UI layout with Scene Builder and use specialized UI controls with pseudo-classes for CSS styling. Understand JavaFX property binding to control UI state and use JavaFX animation for cool looking effects. We'll also use modern Java including lambdas, streams, method references, records, and enhanced switch expressions.
Both MicroProfile and Jakarta EE are cloud native API standards for developing portable microservices.
Jakarta EE 10 Core Profile was the new profile in Jakarta EE 10. The new shining hot-in-the-press MicroProfile 6.0 has already fully embraced Jakarta EE 10 Core Profile. Apart from this, MicroProfile 6.0 also provided some major updates from MicroProfile Metrics, which enabled the adoption of Micrometer and MicroProfile Telemetry that consumed OpenTelemetry. Come to this session to learn all about the observibility standard for your microservices with a live demo on Open Liberty.
Up to 4 CPUs, allocations are cheap, GC is pretty cheap.
However, 4 busy CPUs may be enough to saturate your server's memory bus. Using more CPUs may result in little to no benefit unless you consider the total allocation rate of the physical server.
In this talk, I look at how to test this and a simple estimate of how much throughput is consumed by your allocations.
Virtual machines don't provide isolated use of the memory buses, allowing one 4 vCPU VM to slow all others on the same physical machine significantly, so it's essential to understand its impact.
The world is moving at an unprecedented pace and much of it has been powered by the innovations in software and systems. While event handling, messaging, and processing are not necessarily brand new concepts, the recent emergence in hardware such as virtualizations, multi-core processors, and so on, are in fact pushing the envelope in software design and development, elevating it to higher levels of capabilities never seen before. In the case of streaming which very often leverages on the underlying messaging mechanism(s) to bring distributed messaging to higher forms of purposes, such as IoT/IIoT applications, AI/ML data pipelines, or even eCommerce recommendations, event streaming platform has indeed become the "glue" in enabling data to flow through disparate systems in the pipeline and in a very dynamic fashion.
This talk on event streaming is meant for anyone interested in learning about it, and understanding how it fits into the modern software development design and architecture, as well as seeing some of the challenges it faces especially in the Cloud Native environment. We’ll then take a look at an open source platform - Apache Pulsar, which is poised to become the de facto new generation of distributed messaging and streaming platform that will bring joy to developers, and enable systems and applications to be highly responsive with its true real-time capabilities.