Which code/framework is faster in my use case? What is the maximum throughput? How my system degrade? We have to deal with these questions on a daily basis but we still choose to leave them unanswered as we “don’t have time to benchmark it”.

In this session, you will get a gentle review of the JVM internals, get a guide of how to build proper benchmarks, avoid the most common pitfalls and hands-on with the most popular benchmark frameworks for the JVM. After this session, you will be able to build your own benchmarks in minutes and finally test by yourself what is faster.

Ever wondered what makes a cloud-native application “cloud-native”? Ever wondered what the unique challenges are and how best to address them on fully-open Java technologies? In this session, you’ll learn what it means to be cloud-native and how that impacts application development. You’ll learn about Eclipse MicroProfile, an industry collaboration defining technologies for the development and management of cloud-native microservices. Once you’ve developed your microservice, you’ll learn how to package it in a Docker container and deploy it to a Kubernetes cluster.

Finally, you’ll learn how to use Istio to manage your microservice interactions. Come to this session to understand the Cloud Native Ecosystem: MicroProfile, Kubernetes and Istio, with a live demo on creating microservices using MicroProfile and Open Liberty and deploying the cloud-native microservices to Kubernetes and Istio. After this session, you should understand how to best develop Cloud Native Microservices by using MicroProfile to work well with Cloud infrastructure, such as Kubernetes and Istio.

In this talk, we will develop a neural network backed artificial intelligence from scratch in Java showing base concepts of reinforced learning approach and how to connect it with neural networks.

Reactive Streams: what it actually is and what advantages we gain by using it? Can you use this technology on your language platform and should you use this paradigm at all? In this talk, Oleh will share the current state of Reactive Streams and what happens to this specification on different language platforms. We’ll learn what libraries can be used today if you’re JS developer or dedicated .NET/Java/Ruby/Python back-end developer.

In this Deep Dive session, we will go through the design process of modern CI/CD for the microservices-based system with Kubernetes support. We will discuss how to verify consistency between microservices, apply different levels of quality gates and promote artifacts between environments. Thanks to Kubernetes we will review different approaches of environment resources optimization for development needs during CI/CD cycles.

We have been using Spring Webflux with Kotlin in production for quite a while and recently decided to give coroutines a try. A few thousand LoC later, let’s take a look at them with the benefit of hindsight.

Can coroutines help in taking the reactive plunge? How do they impact performance? Is it still an “early adopter” technology?

Java developers, especially those who are engaged in custom development, are constantly struggling to write less boilerplate code, be it trivial setters, getters, constructors, etc. or CRUD repositories and controllers. Often the answer is code generation in different forms: source code generation support in IDE, bytecode generation using Lombok, annotation processors generating new code, various frameworks that allow you to get an (almost) ready-made application from the model description and much more, not excluding new and traditional JVM languages that allow you to write more concise code and implement DSL for solving applied problems.

With undeniable benefits in the simplest cases, there are some limitations that do not allow to realize what is required in a particular project, and worst of all, when the generated code becomes a source of hardly detectable defects, and special crutches on top of generated code are needed to fix it.

In this talk, we will give a retrospective of the most commonly used approaches, overview their strengths, limitations and practical applicability, and most importantly, we’ll try to take control of the code generation situation so that it becomes a really useful tool for an effective developer.

In this session, we will learn how to use the Optional class the way it was intended? Here I will show you common mistakes, anti-patterns, and panic code that most of the developers do when they use Optional. So, let’s tackle this topic with 25+ recipes that try to address Optional in your code through an elegant and painless approach, and covers all enhancements added to it until Java 12 release.

What exactly is an SSL Certificate? Do rolling out tools with mTLS enabled seem impossible? Can you test that your infrastructure tools properly uphold the security claims they make regarding mTLS? Does the thought of rotating the certificate authority your service mesh rely on scare you? In this talk, we will begin our journey looking at the RFCs behind these technologies. Next, we will use OpenSSL, CFSSL, and mkcert to validate what we have learned about X509 v3 certificates. We will then bootstrap Consul to quickly demonstrate server, client, and browser usages of certificates. After that, we’ll do a deep-dive into how Kafka uses certificates to secure its brokers and clients, and possibly (KIP-515) its connections to Zookeeper.

Do you write in Kotlin but still using Java infrastructure for testing? With the Kotlin ecosystem, the number of tools for Kotlin testing is growing too. Pavel will talk about Kotlin’s role in testing and about its ways to simplify the life of test developer — either he’s developer, QA or somebody else.

TBD

Java is a simple but very verbose language. Often it feels like it’s too verbose and we miss many features that other languages can offer. Can we continue using our favorite frameworks, benefit from JVM reliability and robustness but use more modern and concise programming language? Yes, thanks to Kotlin!

Spring & Kotlin is a great match – a fantastic foundation for building modern applications. If you haven’t used Kotlin ever before there is nothing to worry about. In this talk, you will learn step by step how to develop Spring Boot application leveraging Kotlin idioms and Kotlin specific DSLs baked into the Spring ecosystem. You will see what’s already possible and what can be the future of developing Spring applications with Kotlin.

The non-goal of this talk is to teach Go syntax or learn its basic constructions. It is rather a philosophical view of two different ecosystems: Java and Go.

The first thoughts that come to mind when mentioning the Go programming language are cloud-nativeness, concurrency, low memory footprint, fast compilation, and fast execution. And these still remain hot topics in 2020.

This talk shows what we, as the seasoned java developers, can learn and use from the Golang experience. We will cover modeling instruments and approaches available in both ecosystems such as package design, building blocks, error handling, dealing with collections, documentation, testing, building and debugging tools, etc.

The talk is based on the assumption that programming language is a tool and tightly coupled to philosophy and thought expression. The target audience is the engineers who want to understand why the Go programming language is considered to be the de-facto standard when it comes to cloud-native development and tooling. In fact, Go has become so popular that a report on it is submitted to the Java conference.

Your Spring Boot application is up and running. You are ready to move it to production and obviously, you want to add some logging. How do you do that while avoiding unnecessary work and getting the most out of your logs?

The practical examples are based on Spring Boot and the Elastic Stack (or ELK Stack) though the general principles will generally apply:

• Don’t parse with regular expressions if you can avoid it.
• Do use the features of log appenders for more structured events.
• Don’t write log files in Docker or Kubernetes.
• Do add correlation IDs for distributed tracing.

Stop making logging complicated and get it to production quicker.

There are lots of challenges in building complex distributed systems. One of the caveats that help to move forward with iterative features delivery is proper organized testing of the entire system.

With the contract testing approach, we can define contracts between consumer and producer services. These contracts allow to generate tests on the producer side, create Wiremock-based stubs and use them on the consumer side for verifying API compatibility.

Contract testings allow getting fast feedback in case of API became incompatible for downstream services. This is a perfect initial layer in CI pipeline before bootstrapping and running resource expensive end-to-end infrastructure for verification.

With demo sessions, we will take a look at these features and discuss how to use them in Spring ecosystem and other languages/frameworks.

In today’s Software Development world the number one demand from employers is to deliver features as soon as possible. Everything else is secondary. That means engineers are doing only one thing: writing new code, debugging, and writing new code again. And most of the time this code is running in one of the very convenient clouds. Rarely anyone ever stops and thinks about performance as a whole. If performance is an issue the to-go solution is to throw more money at it. Which usually means buying more computing power in the cloud. But is this really the best way of solving that issue? We should make ourselves aware of how wasteful our industry is sometimes and think about ways to avoid that.

This talk is meant to demystify how garbage collection (GC) works in a Java runtime. The beginning of the talk will be focused on what GC is, discuss truths and myths, and how it is useful for the lifetime of a program. After laying out the basics I’ll explain how each GC algorithm work and how they can be implemented in real-world JVM (e.g. OpenJ9, Hotspot). How can these algorithms be put together to make a good GC policy, and how one can better select a configuration/policy for their application? These are some of the questions that I will be addressing during this talk. I will do so by tying these algorithms to OpenJ9 GC policies and compare them to other policies such as G1 and Shenandoah.

Different programs have different behaviors; by using the more appropriate policy for your application, it can improve its performance considerably. Lastly, I will conclude the talk by mentioning one advanced feature of OpenJ9 GC called double mapping arraylets, which is a way to improve memory management of large arrays in region-based GCs. By the end of the talk, you will have a better understanding of how the JVM manages its memory and be able to choose the more appropriate GC policy for your application.

It will be the second part of my “Micro Optimizations in Java” talk that I made a few years ago on the JEEConf. Time goes and every day we discover new and new hot paths in our code that we have to optimize in order to keep our hardware cost as low as possible while handling hundreds of billions of requests a month. In this talk, I’ll continue to demonstrate typical java constructions that slow down your code execution. And will show you what you can do with it.

How many of you have been tasked with improving performance or solving a performance bottleneck? How many times have the data you gathered confused the situation more than it helped? It is very common for the data to point to a symptom and not the actual cause. During this talk, I will discuss a few common performance issues and how they manifest in profile data. For each of the issues, I will cover how I gathered the data, my initial suspicion about the problem and what I did to solve the actual problem. The talk will cover JVM object allocation, garbage collection logs, Java and JVM profilers and data structures.

Years ago, the choice by default for microservices was Spring Cloud. There are thousands of systems where Netflix stack covers all microservices needs: configuration management, load balance, service discovery, obtaining secrets and much more. In the new era of clouds without vendor locks, the new default is Kubernetes. Container orchestrator out of the box covers a huge part of microservices concerns, but for use this, it is required to change the code and remove a couple of dependencies.

At our company, we recently transferred tens of systems to the new approach. Each team has chosen its most comfortable way. This talk will observe moving strategies, problems that need to be taken into account, and our experience in choosing the most optimal ride to Kubernetes.

Most developers continue doing their job as they always have. However, once in a while it makes sense to look and reflect whether we’re doing things in the most effective way. This session shows 20 tips for Java developers on how to maximize their efficiency. We’ll have a look at how to improve our IDE usage, command line experience, and automation. We see which technology enables us to develop with efficiency, and how to keep feedback loops short. Altogether, all the points cover the topic of how to become a better developer.

This talk will firstly cover standard data-storage migration approaches for the microservices and the challenges you’ll be faced with using/implementing them. After that, we will talk about event-driven design pattern (microservices local state) that enables simple storage/schema migration. At Playtika our latest use-case was migration for at least 100 microservices from Couchbase to Aerospike, under the hood we used Spring Data project. Combining of the 2 approaches enables you fast, reliable and head-ache free migrations.

A full reactive stack may not be on your radar, but reactive APIs are becoming more common and widely used, from database access with R2DBC to HTTP remote calls with the WebClient to full-on reactive, remote communication with RSocket. These libraries do some pretty useful things that would otherwise be quite difficult. However, to take advantage you need to be more comfortable with reactive programming. This session aims to introduce you to reactive programming with practical steps, doing practical useful things that will make you want to learn more.

In this talk, I’d like to be a myth-buster for 50 mins just to convince people that the upgrade path is the only way to make both Java and their apps/businesses successful. But this is a game of two: Java community and Java consumers. There should be no blockers in the evolution of both. So, as part of this talk, I’d like to myth-bust 6 common signs that people have no idea of what’s going on with modern Java.

gRPC became more and more popular. It has a set of advantages over REST. However, the support of gRPC in the browsers is not mature enough. It would be great to have gRPC for inter-service communication but REST for client-to-service communication. Do we have to implement our API twice? Short answer: No.

Join the talk, and you will learn how with the help of gRPC and Envoy you can have both, REST and gRPC APIs.

We had 1 week, 2 Scala devs, 1 Scala artifact, a bunch of Kotlin libraries, 1 Kotlin book, a couple of microservices, 2 build systems and an IntelliJ Idea… Not that we needed all that for the task, but once you get locked into a serious drug collection, the tendency is to push it as far as you can…

Java, the runtime, likes memory. And it is also a fact well known to those who know it well, that subtle differences in code, result in drastic changes to applications memory and runtime profiles. I’ll take you through the memory lane part of my work, and show how do I approach analysis, problems, and troubleshooting. Tools, what information can they surface, and how to navigate back to the code. Techniques and libraries, how do they affect what the application does. Feel invited if you believe troubleshooting memory in Java is ‘magic’, or ‘only tuning the GC can save us’.

Too many languages we have, too many frameworks for each of them. Some of them are so awesome that you wish you can use it in your regular project. Java is for high performance server, Node.JS is for simple performance server, Python/R is for DS/ML, C/C++ for embedded, etc. Is it possible to unite them all under the same application?

I will show you how it is possible. Some theory and a lot of practice is on the way.