Developer and creator of many things OSS, his passions includes Web Development and Software Architecture. Has authored a couple of books, a few courses and has been speaking at industry events for nearly 20 years.

Currently at JetBrains leading the Developer Advocacy team. Spends as much time as he can writing code.
Ktor is a web framework built from the ground up using Kotlin and coroutines. Amongst other things it allows for creating robust and performant HTTP server applications.

In this talk we're going to take a look at Ktor, the ideas behind it, and how we can easily create applications and have these deployed to Google Cloud with very little effort.
Mark Heckler is a Professional Problem Solver and Spring Developer & Advocate at VMware, conference speaker, published author, & Java Champion focusing upon developing innovative production-ready software at velocity for the Cloud.

He has worked with key players in the manufacturing, retail, medical, scientific, telecom, and financial industries and various public sector organizations to develop and deliver critical capabilities on time and on budget. Mark is an open source contributor and author/curator of a developer-focused blog (Hecklers in Development, brewing stronger Java) and an occasionally interesting Twitter account (@mkheck).
Most mission-critical systems have distributed elements or are entirely distributed, resulting in a number of challenges: performance, scalability, reliability, resilience…the eight fallacies of distributed computing are alive and well! Messaging platforms are often used to solve these problems and increase the "ilities", but they don't come without a few complexities of their own.

Come to this session to learn not only how to use open source solutions like Spring Cloud Stream, RabbitMQ, & Apache Kafka to maximize your distributed systems' capabilities while minimizing complexity…but also how to really use them!

There be dragons when dealing with messaging platforms; the presenter will show you several ways to tame and harness them for maximum fire, maximum altitude. All examples will be coded live & in real-time!
Rafael works as a software consultant in Oslo, Norway. He is a proponent of static typing and a JVM enthusiast with particular interest in code instrumentation, concurrency and functional programming.

Rafael blogs about software development, regularly presents at conferences and was pronounced a JavaOne Rock Star. When coding outside of his work place, he contributes to a wide range of open source projects and often works on Byte Buddy, a library for simple runtime code generation for the Java virtual machine.

For his work, Rafael received a Duke's Choice award, an Oracle groundbreaker award and was elected a Java Champion.
Java agents and their instrumentation API offer developers the most powerful toolset to interact with a Java application. Using this API, it becomes possible to alter the code of running applications, for example to add monitoring or to inject security checks as it is done by many enterprise products for the Java ecosystem.

In this session, developers will learn how to program Java agents of their own that make use of the instrumentation API. Doing so, developers learn how the majority of tooling for the JVM is implemented and will learn about Byte Buddy, a high level code generation library that does not require any knowledge of Java byte code that is normally required for writing agents.

In the process, developers will see how Java classes can be used as templates for implementing highly performant code changes that avoid the boilerplate of alternative solutions such as AspectJ or Javassist while still performing better than agents implemented in low-level libraries such as ASM.
Sebastian Daschner is a Java Developer Advocate at IBM, a consultant, author, and trainer. He is the author of the book 'Architecting Modern Java EE Applications'.

Sebastian is participating in open source standardization processes such as the JCP or the Eclipse Foundation, helping forming the future standards of Enterprise Java, and collaborating on various open source projects. For his contributions in the Java community and ecosystem he was recognized as a Java Champion, Oracle Developer Champion, and JavaOne Rockstar.

Besides Java, Sebastian is a heavy user of cloud native technologies and anything related to enterprise software. He evangelizes computer science practices on https://blog.sebastian-daschner.com, his newsletter, and on Twitter via @DaschnerS. Sebastian kickstarted the JOnsen and jSpirit unconferences that connect Java developers throughout the globe.

When not working with technology, he also loves coffee and to travel the world.
If you're working with modern Jakarta EE and MicroProfile, powered by runtimes such as Open Liberty, Quarkus, or WildFly, this interactive session is for you!

In this AMA session you can ask your questions to Java Champion and Developer Advocate Sebastian Daschner, who's an expert in all things enterprise Java and author of the book 'Architecting Modern Java EE Applications.

Whether you're struggling with specific enterprise APIs, code quality, efficiency of your tests, join us to shape the content yourself. In contrast to a presentation format, the content of this session will be interaction only, with your questions answered live, without slides but maybe some source code.
Software engineer, consultant, mentor and trainer at Bottega IT Minds. Speaker, and blogger at bartslota.com.

Gained experience working in numerous industries, including health care, telco, marketing, finance, and energy, for companies of sizes from tens to thousands of people.

Passionate about OOP, Domain Driven Design, software craftsmanship, microservices and software architecture in general. An enthusiast of Event Storming workshops.

In personal life - a husband and a father. Loves heavy metal music, guitar playing, angling and trekking.
In today's distributed enterprise systems it is not uncommon to see several actors interacting with the same resource at the same time. In order to prevent them from interfering with each other and to ensure data consistency, we often reach for the optimistic locking mechanism that is usually provided by Java Persistence API.

But how does concurrency control impact our API? In this presentation, that will be a live coding session, we will model and implement REST API fully supporting optimistic locking mechanism according to art. You will see what request and response headers should we use, and what response code should we return in which situation. We will also see how Spring Framework supports such implementation, and what do we need to take care of on our own.
Software enthusiast, a fan of designing and developing platform and software as a service application for various cloud infrastructures. He's a principal software developer, developer advocate at Oracle, concentrating on product development along with bringing well-designed and production-ready integration with cloud solutions, a contributor to various open-source projects, cloud-related technologies along with having fun with IoT devices and photography.

Blogger, photographer, traveler. Denis is a regular attendee and speaker at OpenStack summits (Atlanta, Austin, Paris, Barcelona, Boston) and PyCons (Hong Kong, Singapore, Italy), PyLondinium, Decompile.De. Co-author of OpenStack Application development, OpenStack Trove Essentials.
No matter what kind of jobs we do, all of us have a hobby, sometimes even more than one and it is great! So, I'm not an exception here. I do landscape photography and I found myself in love with the Northern Lights, astrophotography and many more sub-genres. Have you seen that Green Lady dancing over the sky? Oh boy, you better do this ASAP!

A friend of mine asked me about traveling north for the purpose of hunting the Northern Lights. This type of question is very complicated to answer, there are reasons for that. How would you compare landscapes (sceneries), experiences, culture, and people of that culture? They are all unique! It was really problematic to answer such an inquiry.

Having a background in data analysis (and a bit of science), I decided to solve this problem as a software engineer - define a problem, find consumable data sources and do some code for the sake of the result!

In this talk, I'll be covering the following parts:
• how a funny experiment turned into a case study;
• how Java turned into the most powerful tool in the context of data analysis;
• why Java and not Python.

The idea and the key takeaway of this talk are to showcase how your job skills and your hobby can work side-by-side to producing beautiful results and how useful Java could be for parallel data pipelines.
Oleg is a developer advocate at Oracle Labs working on GraalVM - the high-performance embeddable polyglot virtual machine.

He organizes VirtualJUG, the online Java User Group, and a GDG chapter in Tartu, Estonia. In 2017 became a Java Champion.
In this session we'll talk about building Java microservices that start instantly and have a low memory footprint, which makes them perfect for the cloud services. They can be built using GraalVM — a high-performance runtime, that can run your Java applications and also generate native executables ahead of time.

We'll show how to get started with GraalVM, share some experiences with frameworks that work with GraalVM native image well, and talk about optimizing performance of native images.

You'll learn what runtime performance you can expect from native images and how to make the very best of them, configure runtime memory usage and GC options, profile-guided optimizations and so on. All to be ready to use GraalVM as the platform for your cloud deployments.
Carola is managing director at WPS - Workplace Solutions and loves to design good structured, long-living software systems.

Since 2003, she and her teams are using DDD to achieve this goal. DDD and long-livingness of software architectures are the topic of many talks she has given on various conferences.

In 2015, she condensed her experience from over 300 analyses of software systems in the book "Sustainable Software Architecture".
Today programmers do not develop applications from scratch, but they spend their time fixing, extending, modifying, and enhancing existing applications. Finally, the whole system is woven into a messy knob and every adjustment becomes an incalculable cost screw.

In this talk, you will see how you can improve your architecture and source code to prevent technical debt growing unrestricted. Based on very simple rules for well-structured architecture, refactorings for tangled code can quickly be found. Complex code can be eliminated, and maintenance costs will be reduced.
Alex is a Director of Developer Experience at Red Hat. He is passionate about Java world, software automation and he believes in the open source software model.

Alex is the creator of NoSQLUnit project, member of JSR374 (Java API for JSON Processing) Expert Group, the co-author of Testing Java Microservices book for Manning and Quarkus Cookbook for O'Reilly.

A Java Champion since 2017, international speaker and teacher at Salle URL University, he has talked about new testing techniques for microservices and continuous delivery in the 21st century.
Serverless architecture is exactly the opposite of a monolith architecture, small services (or functions) running in a constrained running environment (limited access to CPU and memory). Furthermore, as we move to a model where we pay per usage, the services might need to go from 0 to infinite instances in a matter of milliseconds to start serving requests.

Because of these constraints, we have now seen a number of developers at many organizations considering moving to Node.js or Golang to get the performance and tiny memory footprint they need to run in a serverless environment.

In this session, we'll demonstrate how you can optimize your enterprise Java apps to become your next favourite language when developing "serverless architecture" — vastly smaller, vastly faster, and fundamentally more scalable.
Robin is a Senior Developer Advocate at Confluent, the company founded by the original creators of Apache Kafka, as well as an Oracle Groundbreaker Ambassador and ACE Director (Alumnus).

His career has always involved data, from the old worlds of COBOL and DB2, through the worlds of Oracle and Hadoop, and into the current world with Kafka. His particular interests are analytics, systems architecture, performance testing and optimization.

He blogs at http://cnfl.io/rmoff and http://rmoff.net/ (and previously http://ritt.md/rmoff) and can be found tweeting grumpy geek thoughts as @rmoff. Outside of work he enjoys drinking good beer and eating fried breakfasts, although generally not at the same time.
Integrating Apache Kafka with other systems in a reliable and scalable way is often a key part of a streaming platform. Fortunately, Apache Kafka includes the Connect API that enables streaming integration both in and out of Kafka. Like any technology, understanding its architecture and deployment patterns is key to successful use, as is knowing where to go looking when things aren't working.

This talk will discuss the key design concepts within Kafka Connect and the pros and cons of standalone vs distributed deployment modes.

We'll do a live demo of building pipelines with Kafka Connect for streaming data in from databases, and out to targets including Elasticsearch. With some gremlins along the way, we'll go hands-on in methodically diagnosing and resolving common issues encountered with Kafka Connect.

The talk will finish off by discussing more advanced topics including Single Message Transforms, and deployment of Kafka Connect in containers.
Guy works for Redis Labs as a Developer Advocate. Combining his decades of experience in writing software with a passion for sharing what he has learned, Guy goes out into developer communities and helps others build great software.

Teaching and community have long been a focus for Guy. He is President of the Columbus JavaScript Users Group, an organizer for the Columbus Machine Learners and Columbus Functional Programers, and has even helped teach programming at a prison in central Ohio.

In his personal life, Guy is a hard-boiled geek interested in role-playing games, science fiction, and technology. He also has a slightly less geeky interest in history and linguistics.

In his spare time, he volunteers for his local Cub Scout Pack, goes camping, and studies history and linguistics. Guy lives in Ohio with his wife, his three teenage sons, and an entire wall of games.
There are three reactions to the title of this talk:
- What the heck's a probabilistic data structure?
- UFO Sightings… wha?
- 112,092 is an oddly specific number.

This is a talk about the first bullet point with the second thrown in just for fun. I like weird stuff—UFOs, Bigfoot, peanut butter and bologna on toast—maybe you do too? As far as the third bullet point, well, that's how many sightings I have. Now, if you're like most developers, you probably have no idea what probabilistic data structures are.

In fact, I did a super-scientific poll on Twitter and found that out of 119 participants, 58% had never heard of them and 22% had heard the term but nothing more. I wonder what percentage of that 22% heard the term for the first time in the poll. We're a literal-minded lot at times.

Anyhow. That's 4 out of 5 developers or, as I like to call it, the Trident dentist ratio. (It's actually a manifestation of the Pareto principle but I'm a 70s kid). That's a lot of folks that need to be educated. So, let's do that.

A probabilistic data structure is, well, they're sort of like the TARDIS—bigger on the inside—and JPEG compression—a bit lossy. And, like both, they are fast, accurate enough, and can take you to interesting places of adventure. That last one might not be something a JPEG does.

More technically speaking, most probabilistic data structures use hashes to give you faster and smaller data structures in exchange for precision. If you've got a mountain of data to process, this is super useful. In this talk, we'll briefly go over some common probabilistic data structures; dive deep into a couple (Bloom Filter, MinHash, and Top-K); and show a running application that makes use of Top-K to analyze the most commonly used words in all 112,092 of my UFO sightings.

When we're done, you'll be ready to start using some of these structures in your own applications. And, if you use the UFO data, maybe you'll discover that the truth really is out there.
Developer Advocate with 15+ years experience consulting for many different customers, in a wide range of contexts (such as telecoms, banking, insurances, large retail and public sector).

Usually working on Java/Java EE and Spring technologies, but with focused interests like Rich Internet Applications, Testing, CI/CD and DevOps. Currently working for Hazelcast. Also double as a teacher in universities and higher education schools, a trainer and triples as a book author.
When one's app is challenged with poor performances, it's easy to set up a cache in front of one's SQL database. If the app is the only component that writes to the underlying database, it's a no-brainer to update the cache accordingly, so the cache is always up-to-date with the data in the database.

Things start to go sour when the app is not the only component writing to the DB. Among other sources of writes, there are batches, other apps, etc. Change-Data-Capture (CDC) has been described as turning the database inside out by Martin Kleppmann. Just opposite to Event Sourcing that aggregates events to produce state, CDC is about getting events out of state. CDC is quite in its early stage, and implementations are quite specific.

In this talk, I'll describe an easy-to-setup architecture that leverages CDC to have an evergreen cache.
Ana-Maria Mihalceanu is a custom application development enthusiast, co-founder of Bucharest Software Craftsmanship Community and a constant adopter of challenging technical scenarios.

Some of her older experiments are available on Dzone. Other passions? The knowledge hunt through reading and growing fashion skills through shopping.
Long time ago, when lambdas were rare, the Java applications Universe was made of EARs, WARs and JARs having complex install procedures on a dedicated well pampered application server. In those times the batch applications were employed as standalone projects for bulk-oriented, non-interactive data processing across monolithic applications.

During this session I will showcase and demo migration of two sample batch legacy applications (javaEE and spring-batch based) to a cloud native version, using Kubernetes objects and best practices from development and operational point of view.
Milen is a Developer Advocate at AxonIQ on a mission to help fellow Java developers around the globe design and build clean, modular and future proof software!

After more than 15 years developing, designing and consulting on various solutions for leading European companies, he currently spends most of his time supporting communities and organizations and speaking at conferences all over the world.
Most applications only know the present. Their current state is calculated and updated somewhere on every change, effectively losing any previous states and any information that only existed in the past. Can that be a limitation? Lost opportunity? What if your application could remember its entire past? Would that be any useful or is it a worthless effort?

This talk will provoke Java developers to start asking such questions. It will provide useful mental models to better understand Event Sourcing, DDD and CQRS concepts. It will also demonstrate what it takes to build such applications in Java.
Hugh McKee is a developer advocate at Lightbend. He has had a long career building applications that evolved slowly, that inefficiently utilized their infrastructure, and were brittle and prone to failure.

Hugh has learned from his past mistakes, battle scars, and a few wins. And the learning never stops. Now his focus is on helping other developers and architects build resilient, scalable, leading-edge systems.

Hugh frequently speaks at conferences around the world. He is the author of Designing Reactive Systems: The Role Of Actors In Distributed Architecture.
Oh, now what? Another technobabble name - megaservice! What is a megaservice?

A megaservice is a microservice that is capable of processing up to one million logical operations per second. In this context, the service prefix indicates the expected maximum sustained per second logical operation throughput.

In this talk, we will look at the more common deca-service (tens of LOPS), hecto-service (hundreds of LOPS), and kilo-service (thousands of LOPS) implementation techniques. We examine some of the common performance bottlenecks and look at methods used to push services to higher throughput levels.

I'll share our experiences with a demo microservice application that we are using to push the cloud service providers to their limits. The demo application is composed of two Akka CQRS microservices. The app provides an interactive world map UI that visualizes the distribution of IoT devices spread across the planet. With the click of the mouse, we generate thousands, tens of thousands, even millions of IoT devices and observe how various databases and cloud systems react when push to the limit.

All of the application code is built using OSS such as Akka, Java, JavaScript, and Kubernetes. The demo app is available for you to use as a learning tool for building your megaservices.
Bas is a programmer, scientist, and IT manager. He works as a Technology Lead in the AI and big data domain. His academic background is in Artificial Intelligence and Informatics. Bas has a background in software development, design and architecture with a broad technical view from C++ to Prolog to Scala.

He occasionally teaches programming courses and is a regular speaker on conferences and informal meetings, where he brings a mixture of market context, his own vision, business cases, architecture and source code in an enthusiastic way towards his audience.
Streaming Analytics (or Fast Data) is becoming an increasingly popular subject in enterprise organizations. The reason for this is that customers want to have real-time experiences, such as notifications and advise based on their online behavior and other users' actions.

A typical streaming analytics solution consists of three steps: reading event data, evaluating the events with the aid of business rules and machine learning alogithms, and producing meaningful output. All three steps will be covered with an example use case. The streaming analytics engine is powered by Flink. I'll use Kafka for the message bus and Cassandra for the state management. The machine learning models are made with Knime and Spark, exported to PMML formant, and evaluated using the Openscoring.io library.

After this session, the attendees will have a good overview of a typical streaming analytics solution and have a better understanding of Apache Flink as a key data streaming technology.
Miro is a Co-founder and VP Engineering at DNAstack, where he builds a leading genomics cloud platform.
He is a Java enthusiast with expertise in distributed systems and middleware, passionate about genetics and making meaningful software.

Miro is the creator of the largest search and discovery engine of human genetic data, and the author of a book on parallelization of genomic queries.

In his spare time, he blogs and contributes to several open-source projects.
In the last few years, over 20 years after the introduction of threads, the Java community has been reimagining what modern concurrency should look like.

In this live-coding session, we explore the past, the present, and the future of the concurrency model in Java. With focus on the upcoming Project Loom and its high-throughput and lightweight parallelization, we dive deep into the APIs our applications can leverage, talk about how the new constructs affect the way we currently write software, and imagine what the future of concurrency will look like.
Software engineer at Lohika and active open source contributor.

Always curious and open-minded. 6+ years of experience building distributed systems in different domains, like a health-care alarming system, networking debugging application, etc.
In the era of microservices, a lot of this can and will go wrong. The network will fail, the services will crash, the errors will occur. But the application must sustain. That's why you have to build a fault tolerant application. Kubernetes and Istio are here to help.
Fabio is a software engineer and community leader based in Amsterdam - he runs the 2000-member strong Reactive Amsterdam meetup and the annual Kubernetes Community Days conference.

When not in front of a screen, he enjoys long distance bike rides and fingerpicking his guitar.
Do you want to get started with deep learning using Java? This talk introduces AI / deep learning from scratch and guides you through an unique image classification use case, for which both dataset and code are provided. At the end of this talk, you will have a basic understanding of the mechanics behind deep learning and a solid starting point for your own experiments.

We will build a neural network using Java and deeplearning4j, train it and then run it on a Raspberry PI to classify images taken with its camera. The goal is to detect reliably if the image contains a plane or not. When so, the picture is tweeted at @PlanesOnBridge. Akka Streams is the engine that ties it all together.

This project will give us a chance to observe AI bias and briefly touch upon controversial aspects of AI.
Grzegorz Piwowarek is a senior software engineer at Hazelcast, trainer, blogger at 4comprehension.com, and an OSS contributor.
At night, he is a retired professional yo-yo player and a guitarist in a progressive metal band - Visions of Tondal.

There are rumors that he exists only at compile-time.
Most of you probably heard about the distributed caching being the most common application of Hazelcast – but I bet not many of you heard about CRDTs, HyperLogLog, or the CP Subsystem.

During this talk, we'll go for a quick journey around Hazelcast's ecosystem, revisit basic functionality, and have a look at some of its hidden flavours. Even if that's way too much for your use case, there's still a lot for an engineer to learn from studying these concepts.
Being an optimistic bubble of enthusiasm since the day I was born did not help with getting some focus in my life.

However when building rockets, breathing fire in Romania or chopping wood in France didn't pan out, I decided to give this Software Engineering thing a go. That was over ten years ago and I haven't looked back since.

The last five years at bol I've focussed heavily on backend software, which lead me to conclude that we need to find a better way to balance innovation with reliability. SRE just might be that way.
Kotlin has been the new superhero on the JVM team for the last couple of years now. With significant support from both JetBrains and the community Kotlin has managed to find a good balance between new features and understandability.

However, with great power comes great responsibility. Every new feature holds new ways to shoot yourself in the foot. Every bit of syntactic sugar has the potential to introduce an incomprehensible layer of abstraction.

Amongst all the awesome features of Kotlin, which ones have the potential to harm more than they help? Which ones should you handle with care? How do you make sure that your Kotlin code is not only shiny and new, but also genuinely better? Get ready for the superhero (code)blockbuster of the summer, "The dangerous side of Kotlin"!
Holly Cummins is an IBMer, and leads the developer discipline in the IBM Garage. As part of the Garage, Holly uses technology to enable innovation, for clients across a range of industries, from banking to catering to retail to NGOs. She has led projects to count fish, help a blind athlete run ultra-marathons in the desert solo, improve health care for the elderly, and change how city parking works.

Holly is also an Oracle Java Champion, IBM Q Ambassador, and JavaOne Rock Star. Before joining the IBM Garage, she was Delivery Lead for the WebSphere Liberty Profile (now Open Liberty).

Holly co-authored Manning's Enterprise OSGi in Action. She is an active speaker and has spoken at KubeCon (keynote), GOTO, JavaOne, Devoxx, Sonar+D, JavaZone, JFokus, The ServerSide Java Symposium, GOTO, JAX London, QCon, GeeCon, and the Great Indian Developer Summit, as well as a number of user groups.
The way we use Java has changed. Applets - or any browser-side Java - are a long, long, time ago. Java moved to the back end, and stayed there, but the back-end has gotten bigger, more distributed, and more complicated.

Some things that were a good idea ten years ago turn out to be a terrible idea in the cloud; and what used to be 'good enough' for testing really isn't anymore. Managing microservices architecture demands a lot of us, to ensure observability, operational resiliency, and organisational agility.

This talk will introduce some of the new tools, patterns, and best practices for Java development in 2020. It also gives a tour of some of the most painful anti-patterns Holly as seen as a consultant with the IBM Garage.
Patrycja Wegrzynowicz is a software visionary and expert specialized in automated software engineering, security, and Java technologies. She is the founder and CTO of Yon Labs, a start-up focused on automated detection and refactoring of software defects, including security vulnerabilities, performance and concurrency anti-patterns, and database issues.

Patrycja is a regular speaker at major academic as well as industrial conferences, including JavaOne, Devoxx, JavaZone, OOPSLA, ASE, and others. She is Oracle Groundbreaker Ambassador and was named as one of Top 10 Women in Tech in Poland 2016 by Girls in Tech.

Patrycja's interests focus on patterns and anti-patterns in software along with automated software engineering, particularly static and dynamic analysis techniques to support program verification, comprehension, and optimization.
JSON Web Token (JWT) is an open standard for creating tokens that assert some number of claims like a logged-in user and his/her roles. JWT is widely used in modern applications as a stateless authentication mechanism. Therefore, it is important to understand JWT security risks, especially when broken authentication is among the most prominent security vulnerabilities according to the OWASP Top 10 list.

This talk guides you through various security risks of JWT, including confidentiality problems, vulnerabilities in algorithms and libraries, token cracking, token sidejacking, and more.

In live demos, you'll learn how to hijack a user account exploiting common security vulnerabilities on the client-side, on the server-side, and in transport. You'll also find out about common mistakes and vulnerabilities along with the best practices related to the implementation of JWT authentication and the usage of available JWT libraries.
Java Champion, Monica Beckwith has several published articles and gets regular invitations to give talks on JVM/JIT Compilation/Garbage Collection (GC).

She is also a JavaOne Rock Star. Monica has co-authored the 'Java Performance Companion' book and is currently working on a book titled 'JVM Performance Engineering: Inside the OpenJDK HotSpot VM'.

Monica is considered one of the influential women in Java and Scala
Since JDK 9, G1 GC is the default garbage collector (JEP 248). Up until 2017, I have shared some G1 GC details, performance tips, optimizations that help G1's adaptiveness and provided advice on manual tuning. But G1 has come a long way in improving its adaptiveness.

In this session I will cover most of the important optimizations that are delivered from JDK9+ and how they can help your application's responsiveness, its throughput and help with footprint reduction. This is a saga that involves various regions and generations (all pun intended).

SCHEDULE
UTC/GMT±0:00 Time Zone. All talks are in English.
CHECK OUT THE LOCAL TIMING ⬇

DAY 1
DAY 2
October 23
UTC±0:00
12:00–12:10
Opening Ceremony
12:10–12:50
12:10–12:50
12:10–12:50
TRACK 1
TRACK 2
CLOUD TRACK
#Kotlin #coroutines #webdev #Ktor #multiplatform
#streaming #dataprocessing
#messaging #Kafka
#K8S #cloud #microservices, #faulttolerance #servicemesh
12:50–13:00
Q&A
13:00–13:40
13:00–13:40
13:00–13:40
TRACK 1
TRACK 2
CLOUD TRACK
#pureJava, #lowlevelJava #hardcore #performance
#dataprocessing #PDS #BloomFilter #MinHash #TopK

#K8S #cloud #JavaEE #Spring
13:40–13:50
Q&A
13:50–14:20
Coffee break
14:20–15:00
14:20–15:00
14:20–15:00
TRACK 1
TRACK 2
CLOUD TRACK
#Spring #performance
#DL #ML #AkkaStreams #RaspberryPI #ioT #binaryclassification

15:00–15:10
Q&A
15:10–15:50
15:10–15:50
15:10–15:50
TRACK 1
TRACK 2
CLOUD TRACK
#microservices #performance #Akka
#streaming #dataprocessing #ML #Flink #Kafka #Cassandra #PMML

#pureJava #hardcore #microservices #cloud #Quarkus
15:50–16:00
Q&A
16:00–16:30
KEYNOTE
#dataprocessing #ML
16:30–16:35
Closing Day 1
October 24
UTC±0:00
12:00–12:10
Opening Ceremony
12:10–12:45
KEYNOTE
#modularity #legacy #architecture #technicaldebt
12:45–12:55
Q&A
12:55–13:35
12:55–13:35
TRACK 1
TRACK 2
#Kotlin #OO #cleancode #FP #DDD
#streaming #dataprocessing #messaging #cache
13:35–13:45
Q&A
13:45–14:10
13:45–14:10
TRACK 1
AMA session
#performance, #G1GC, #JDK9+
#enterprise Java, #Jakarta EE, #MicroProfile
14:10–14:40
Coffee break
14:40–15:20
14:40–15:20
TRACK 1
TRACK 2
#pureJava #lowlevelJava #hardcore #microservices #performance
#eventsourcing #DDD,#CQRS
15:20–15:30
Q&A
15:30–16:10
15:30–16:10
TRACK 1
TRACK 2
#JWTsecurity #authentification #JWTlibraries #performance
#CRDTs #HyperLogLog #CPsubsystem
16:10–16:20
Q&A
16:20–17:00
16:20–17:00
TRACK 1
TRACK 2
#ProjectLoom #JDK #performance
#streaming #dataprocessing #messaging
17:00
Closing Day 2
UTC/GMT
California/PDT UTC-7
London UTC+1
New York/EDT UTC-4
12:00pm–5:00pm
5:00am–10:00am
8:00am–1:00pm
1:00pm–6:00pm
Berlin UTC+2
Delhi UTC+5:30
2:00pm–7:00pm
5:30pm–11:30pm

LOCAL TIMING ON
OCT 23 AND OCT 24

Sydney UTC+10
10:00pm–3:00am
Minsk UTC+3
3:00pm–8:00pm