Modularity is not the only news of Java 9. Let's turn our attetion to other ones.

In this talk you'll see that you should think in terms of tasks, not threads, to write concurrent code.

In this talk you'll learn how to decrease data storage redundancy and get a higher level of system reliability and availability.

What has been done already, what challenges do the project creators face, how can we play with it and suggest our own incredible ideas.

In this session how to transforme a lowly Raspberry Pi Zero webcam into a smart security camera by combining open source software with cloud based image analysis.

Talk aims to reveal at least part of Spring Boot magic by discovering the way it works, letting you debug your apps easier.

Talk aims to reveal at least part of Spring Boot magic by discovering the way it works, letting you debug your apps easier.

We will go on an example-driven tour of the new extension API using real-world testing scenarios. We will learn about the utilities an extension can use, e.g. how it should store state, so you will be ready to write your own extensions after this session.

Where Java 8 features are misused or poorly used and how certain things could have been better implemented.

We'll discuss battle-tested solutions to implement effective logging for microservices in an auto-scaling world.

We’ll discuss Graal and the way it works. With standard Java IDEs and visualisation tools, we’ll show you how your code goes all the way from Java bytecode down to efficient machine code.

Look, ma, we have more puzzlers! Looks like Java 8 and Java 9 are infinite source of puzzling stuff that will leave you, well, puzzled.

In this talk we'll cover different principles of data types serialization, ways of working with classes metadata, cross-platform and code generation issues. Also, we'll dwell on how we created a cross-platform serialization engine for Apache Ignite.

This talk is about the internals of ToroDB, how some significant problems are solved and what techniques and frameworks are used and why.

Big picture of the "battlefield" for the new, modern and rapidly evolving Java: Graal/Truffle, Value Types, Valhalla, Loom, Shenandoah.

In this talk we'll see what are the perks of Spring 5/Reactor for a developer. We'll take a simple synchronous system from a couple of services and databases, we'll solve its problems step by step using reactive approaches. We'll try to figure out how it all works together and how we use streams in various situations.

This talk is about how Kubernetes can help you to scale your CI/CD environment, along with how to use Jenkins to help you to take advantage of this technology.

We'll dwell on what really happens under the hood at compile time vs. runtime by making an analogy between C++ and Java. The talk reveals how Just-in-time compiler from HotSpot/OpenJDK internally manages runtime performance optimizations for hot methods in comparison with compile time optimizations triggered on similar C++ source code using clang, emphasizing all of the internals and strategies used by each of them to achieve better performance.

In this talk we will explore the life cycle of a Java class in depth.

Nowadays GPU resources are available not only on gaming PCs, and in some cases utilizing them delivers huge gains. How and when to use GPU in Java?

We will re-visit our broken assumptions about profilers and try and make sense of broken measurements and how they come about.

We'll dwell on the concept and benefits of CQRS (including eventual consistency, event-driven architectures, event sourcing), how to realise a CQRS application, could it be done with Java EE technology, where the framework already offers solutions and where it has to be extended. We'll go into the details of both approaches.

REST-ish APIs have become the de-facto standard, but is it always the right choice? We'll examine an evolving standard GraphQL in real, practical action.

This talk is about actual problems faced by the low-latency collector like Shenandoah and what can JVM developers do about it.

From reusing an existing Apache Cayenne ORM model for the REST service to delving into alternative backends, graph access security and parallel data processing.

This talk will examine both interesting details of one-cloud structure and Odnoklassniki experience in using highload Java apps in containers.

We'll dwell on Twitter experimenting with Graal to improve Java performance and reduce CPU utilization by generating better machine code.

Examining a Java library that provides lightweight, throwaway instances of common databases, Selenium web browsers, or anything else that can run in a Docker container.

What it takes to implement cloud-ready, adaptive and scalable application using Java EE, which extensions are out there that help us do the job and why Java EE perfectly fits the container and orchestration world.

Why it was preferred to develop a new compiler instead of improving C2, and how does it make Java code run faster?

In this talk we'll explore tools for creating your own Groovy DSL (using Gradle scripts realization as an example).

How Scala libraries help data science meet growing demands, benefitting from Scala functional aspects, its big data ecosystem and hybrid functional and object-oriented approach.

During this panel discussion between the performance experts, the specialists will dwell on methodology from different sides of the process: both particular applications optimization, as well as platform level and runtime. The participants can pass their notes with questions or to send them online with a special hashtag #jokerconf_perf_bof.

How to develop 8 times more board games without increasing the team eightfold.

gRPC is a high-performance HTTP/2-first RPC framework from Google. How does it help to build reactive microservice architecture, what are the use-cases and what are the reasons for using it?

Java 9 Modules vs. OSGi comparison.

Why would we need Event Sourcing and CQRS, and how does it work in practice with PostgreSQL and ElasticSearch?

From the language overview to the real world experience with it and the problems faced while using it.

Which one will win? Which voice assistant has better support for modern, robust and easy development of voice interfaces in Java?

This talk is about a very complicated metabolism inside text editors being discussed in details.

This talk is about various strategies and techniques for checking for linearizability, as well as how to test your data structures using the provided API.

The implementation details of the library and, as JaCoCo is fully based on Java bytecode, a deep dive into some internals of the JVM, different Java compilers and into corner cases of the respective specifications and implementations.