A different flavor of the distributed transaction
10:30 - 11:20
|
Martin Stefanko |
Abstract
Transactions are one of the most complex and yet very important areas of computing. They can get particularly hard when the system moves to the distributed environments as almost every component in the distributed system is liable to failures. Traditional locking protocols, used in transaction solutions today, are then very prone to holding locks on resources for unnecessarily long periods. The saga pattern provides an alternative non-blocking solution with the design that allows individual parts of the transaction to be commited immediately and independently. This design is specifically suitable for long running transactions and distributed systems. In this session, we will present a newly created MicroProfile specification called Long Running Actions (LRA) which provides a definition of the transactional protocol and a simple API for the distributed transactions in the Java microservices environment based on the saga pattern. We will show you why the saga pattern is a very suitable transactional solution for many distributed microservices applications and demonstrate the usage of the LRA specification with the live coded demo.
|
On schedule: Artificial Intelligence plans that meets expectations
11:40 - 12:30
|
Geoffrey De Smet, Anna Dupliak |
Abstract
Automate your business decisions in Java with Artificial Intelligence algorithms to improve your organization’s schedules, operations and processes. Optimize results. Find the best solution with hard and soft constraints.
Learn how to solve real business problems with OptaPlanner, the open source (Apache licensed) constraint solver in Java. Reuse sophisticated algorithms. Use it to write scalable, maintainable and reproducible code.
In this session, we will compare Brute Force, Greedy Heuristics and Metaheuristics. In our live coding session, we’re going to explore the impact of adding business constraints one by one on the resulting schedule.
|
Quarkus: the Java stack back from the future
13:30 - 14:20
|
Sébastien Blanc |
Abstract
Java is dead, they said, Java is fat and slow, they also said. Join me for a 100% live coding session where I will prove them that they are completely wrong. The JVM ecosystem has never been so innovative than today and Quarkus is one of those new Java stacks that will blow your mind, embrace Cloud Native while keeping using technologies and frameworks that you already master like JAX-RS, Hibernate, Vertx, Microprofile ... Even if you are a Spring Boot developer, we will show how you can easily migrate without any pitfalls. Starting your app in 0.018 seconds with a memory print of 30Mb is now a reality and at the same time Quarkus brings Developer Experience to the next level : Live reload, continuous testing and way more that will be demonstrated during this live coding session.
|
Productive Developer of the Cloud Era
14:40 - 15:30
|
Bartosz Majsak |
Abstract
With the advent of the cloud, we quickly realized its flexibility and business benefits. But did we come prepared for the cognitive load it introduced? Can we still easily develop and ship our apps in this environment? Over the years we've established tools and practices to work with the platforms, not to fight them. Can we say the same about the Cloud Era?
In this talk, we will go over challenges that developers face every day while shipping code to the cloud platform. By looking at the typical developer task we will identify the right tools to run, debug and analyze the behavior, test, deploy and eventually promote it.
You will leave this demo-driven presentation equipped with tools and techniques to reach your full potential. Knowing them will let you focus on the fun part of being a programmer rather than struggling with the vast and frequently complex land of the cloud.
|
The automation challenge: Kubernetes Operators vs Helm Charts
16:00 - 16:50
|
Ana-Maria Mihalceanu |
Abstract
Working with Kubernetes for some time or you just started your journey?
If you love automation and dislike having to perform repetitive tasks manually, you have come across concepts of Helm charts and Kubernetes operators. Although they solve similar types of problems, they are not exactly interchangeable tools, but rather complementary. During this session I will highlight which to use and when by sharing several code based examples and lessons learned.
|
Efficient communication with Quarkus and gRPC
17:10 - 18:00
|
Michał Szynkiewicz |
Abstract
gRPC is a contract-first, high performance communication protocol. It can efficiently connect services implemented using various languages and frameworks.
With Quarkus you can easily expose and consume gRPC services, get super-productive with development mode which also covers protoc contracts, effortlessly test the services you expose by using auto-configured clients, and manually test your work with the Dev UI.
This talk will introduce gRPC, discuss when to use it versus REST and show how to use it with Quarkus.
|
After Party
18:00 - 21:00
|
|
Sponsored by Quarkus World Tour |
LAB: Enter Serverless Functions Journey with Quarkus
09:00-12:00
Friday June 24
|
Daniel Oh, Shaaf Syed
|
Abstract
This workshop is designed to be hands-on experiences on how developers can get started with scaffolding serverless functions projects using Quarkus, a new Kubernetes native Java framework with familiar tools (e.g. CLI, Maven, Gradel). The workshop covers deploying service functions to AWS Lambda, optimizing the functions, making them portable across multiple serverless platforms ( e.g., AWS Lambda, Azure Function, Google Cloud Platform, Kubernetes Knative), and using the latest handy command-line tool (e.g. Kn func) to enable a Buildpack for function development & deployment in minutes. Lab participants will be provided a free sandbox for serverless deployments. The lab instruction(WIP) is here: https://github.com/RedHat-Middleware-Workshops/enter-serverless-functions/blob/main/README.md.
|
