Сloud Builders: Java Conf

3:00 pm

The Past, Present, and Future of Cloud Native API Gateways

Daniel Bryant

Watch this session to learn about:

The evolution of API gateways over the past ten years, and how the original problems they were solving have shifted in relation to cloud native technologies and workflow

Java After Eleven

Nicolai Parlog

A live-coding talk during which I update a Java 11 code base to Java 17, making good use of new language features, additional and improved APIs, and JVM capabilities.

In this talk, we'll take a simple Java 11 code base, update it to 18, and refactor it to use the new language features and APIs. You'll be surprised how much the code changes!

3:45 pm

What the CRaC - Superfast JVM startup

Gerrit Grunwald

In a world where microservices are more and more a standard architecture for Java based applications running in the cloud, the JVM warmup time can become a limitation.

Especially when you look at spinning up new instances of an app as response to changes in load, the warmup time can be a problem. Native images are one solution to solve these problems because their statically ahead of time compiled code simply doesn’t have to warmup and so has short startup time. But even with the shorter startup time and smaller footprint it doesn’t come without a drawback. The overall performance might be slower because of the missing JIT optimizations at runtime.

There is a new OpenJDK project called CRaC (Coordinated Restore at Checkpoint) which goal it is to address the JVM warmup problem with a different approach. The idea is to take a snapshot of the running JVM, store it in files and restore the JVM at a later point in time (or even on another machine).

This session will give you a short overview of the CRaC project and shows some results from a proof of concept implementation.

Elevator Pitch: Are you sick of trying to improve jvm startup times when running your app in microservice environments? Attend this session and see how you can startup your jvm based application in milliseconds without using native images but only the pure jvm in combination with CRaC.

Delightful integration tests with testcontainers

Oleg Šelajev

Dockerized services are an excellent tool for creating repeatable, isolated environments ideal for integration tests. In this session, we'll look at the Testcontainers libraries which provide flexible and intuitive API for programmatically controlling lifecycle of your service dependencies in Docker containers.

Running databases, Kafka, Elasticsearch, and even cloud technologies, straight from your test code ensures environment config is always up-to-date and consistent during local development and in CI pipelines.You’ll learn everything necessary to start adding powerful integration tests to your codebase without the headache of managing external service dependencies manually!

4:30 pm

Project Loom - A Friend or Foe of Reactive?

Oleh Dokuka and Andrii Rodionov

We heard about Project Loom - the new programming models on the Java platform for high-throughput lightweight concurrency and threading.

Project Loom will give a structured concurrency in Java which enables writing efficient async apps using imperative paradigm. With that, many started questioning whether the Functional and Reactive approach remains with that in the Java ecosystem.

In that talk, we going to busters the myth of Loom killing Reactive and instead discuss how Loom will improve the Reactive ecosystem and make it more robust and simpler to use.

Fantastic Java Apps and how to kubify them with Dekorate

Ana-Maria Mihalceanu

Kubernetes is growing in popularity with developers because it allows you to replicate infrastructure in your development environment. Yet, working with Kubernetes and its family of tools - Knative, Helm or Tekton - often involves creating and maintaining cumbersome YAML files.

Join us to learn how to generate Kubernetes, Knative, Helm, or Tekton resources for Java applications using the comfort of developer-friendly Dekorate configurations in your favorite Quarkus or SpringBoot application. Working with these resources will be as easy as adding a jar into the class path, and customizing them will be possible using Java Annotations, properties files, or both. Let's Dekorate together the next generation of kubified Java applications!

5:30 pm

Performance and polyglot superpowers for Java with GraalVM

Alina Yurenko

GraalVM is a high-performance virtual machine, bringing new performance optimizations for individual languages and seamless interoperability for polyglot applications. In this session we'll talk about the performance boost you can get from running your programs on GraalVM, see examples of using JavaScript and Python in Java applications, and will go all the way from starting with GraalVM to using it to make the most out of your application.

We'll see how see different Java applications, as well as those written in JavaScript, Ruby, R or Python, can use GraalVM for better performance and smooth interoperability. We’ll also talk about Native Image and how it enables fast startup and love memory footprint for Java applications.

Tradeoffs, Bad Science, and Polar Bears – The World of Java Optimisation

Holly Cummins

Welcome to the Java optimisation jungle. Why can’t we “just make it go faster”? It turns out, in most cases, we need to first work out “faster for whom?” and “why do we want to go faster?” and “what even is faster?”

This talk introduces the basic principles of optimisation, before bouncing through the pitfalls of optimisation; why the exact same techniques which make Quarkus rocket-fast used to be a terrible idea fifteen years ago, why fast benchmarks make for slow programs, and why even though it can be easy to get wrong, optimisation really really matters. Along the way we’ll talk about measuring things, bad advice, garbage collection, and climate change.

6:30 pm

Event Streaming and Processing with Apache Pulsar

Mary Grygleski

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.

Kube-native development practices with Quarkus

Alexey Loubyansky

Quarkus became famous for enabling applications to boot super fast and operate in a tiny amount of RAM, which is essential to perform efficiently and cost-effectively in the cloud.

However, application developers switching to Quarkus for its performance characteristics, soon find themselves being attracted to a different side of it - the development experience.Addressing major technical weaknesses of traditional Java has opened up a new perspective on the application development tools and practices.This talk will reveal how Quarkus takes certain aspects of building, testing and deploying applications to the next level, boosting developer productivity with such features as live reload, continuous testing, automatic bootstrap of external services in dev and test modes, development dashboard and more, including the fundamentals of the bootstrap mechanism that enables these features for Java developers.

7:10 pm

Great speaker will be here soon

Great speaker will be soon

TBD

Addressing the transaction challenge in a cloud-native world

Grace Jansen

With microservices comes great benefits but also great challenges! One such challenge is data consistency and integrity.

Traditionally, tightly coupled transactions were used to ensure strong consistency and isolation. However, this results in strong coupling between services due to data locking and decreasing concurrency, both of which are unsuitable for microservices. So, how do we provide consistency guarantees for flows that span long periods of time in cloud-native applications? We'll address this challenge by investigating the Saga pattern for distributed transactions, the MicroProfile Long Running Action (LRA) specification and how these can be used to develop effective cloud-native Java microservices.

8:00 pm

Great speaker will be here soon

TBD

TBD

Great speaker will be here soon

TBD

TBD

8:45 pm

Deploying to the cloud with GitHub Actions, feature flags, blue-green deployments, and AB testing

Brian Benz

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 new application features reliably and securely without changing the core application or impacting core business activity.

Highlights will include employing 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. All the demos and technologies used are open-source and free.

Great speaker will be here soon

TBD

TBD

9:30 pm

Spring in cloud-native world

Josh Long

Spring is all about helping developers get to production quickly and safely. These days, "production" is all but guaranteed to mean Kubernetes, and Spring has you covered.

Join me, Spring Developer Advocate Josh Long (@starbuxman), and we'll look at how Spring Boot makes writing blisteringly fast, cloud-native, and scalable services more effortless than ever.