Talks

Do you know what is inside of your class files? Are you ready to bet? Let's have fun by diving into bytecode pattern matching and explore how different compilers (Java/Kotlin) and their different versions transform your source code.

We'll tell about even more easy and, more importantly, standardized alternative to Spring Boot, designed precisely for microservices. Implementations of this specification, made by different companies, can work on various hardware from Raspberry Pi to large clusters. This specification proved successful and continues to evolve, offering new very useful features right out of the box.

Learn all about the recent Java releases from 9 to 11.

In practice, developing and testing, testing and developing, we'll see the compromises in developing on SB2 and Micronaut. We shall see who's the best of the best: the most reactive, the handiest, the "cloudiest" — and is "micro" even good for production?

Channels algorithms in Kotlin coroutines, comparison with other languages and libraries.

This talk is a "pitfalls digest", a collection of notes about which pitfalls you may encounter in the process of updating the Spring Boot framework to version 2.* and how to fix or bypass them.

A session about a research project with the goal to use mobile touch enabled devices to input data into desktop software (e.g. JavaFX, HTML5).

We'll talk about implementation details of different GC algorithms that cause some objects to be collected unexpectedly but others to stay on the heap for a long time after they have become unreachable. We'll also discuss whether this can be dangerous for your application and how to reduce the damage.

Q&A session with Joker 2018 organizers and the Program Committee. You ask questions, we answer them — it's as simple as that.

We will tell how and why we use generator of random Java programs, how this generator is built and what can be done for generating Scala, Kotlin and other such programs which can be compiled into Java bytecode.

Integrating .NET and Java virtual machines — from simple microservice to complicated in-process cooperation.

This talk aims to arm you with the knowledge to make informed decisions around introducing immutability in collections (and other related functional concepts) to your application.

Pavel will tell about his first meeting with Kotlin, first experiments and production usage. He'll walk you thru all core (in his opinion) aspects of enterprise development, look at difficulties they met and show their solutions of these difficulties. Also he'll talk a bit about interoperability and whether it is as good as described.

This talk deals with profiling small parts of code and learning why sometimes code works really slow. Sergey will show how to improvise a small profiler which will use Intel Processor Trace technology.

You'll learn about evolution of the Java ecosystem on ARM, features of the ARM port OpenJDK and performance of some workloads. We will tell how in two years AARCH64 became a real gem.

Together we'll explore the wacky, wonderful world of Reactive Spring.

In this session we'll demonstrate via examples new possibilities of Java 9 for self-contained systems, approach to migration of the applications and how this technology could be implemented for developing command-line tools and deploying of applications in containers.

Denis will go through the challenges that were faced in the scaling process and were also driving the evolution of their public API infrastructure. The story is filled with lessons learned and pitfalls, how-tos, and how-not-tos.

There will be tools, libraries and frameworks, which perplex common developers in their routines and lead to down times, screwing up deadlines, and prolonged depressions.

Konstantin will try to explain issues with Postgres scalability at MPP systems and possible ways of solving this problem.

We'll examine how the authors of Java see pattern matching, which new features are needed for its comfortable use, and is there any light at the end of the tunnel.

Serving hundred Gbps from several nodes: architecture, design, gotchas, and solutions.

In this session, Derek will show you how to create simple TensorFlow models, train sophisticated ones and obtain predictions from advanced neural networks — all from Java.

For the 2018 FIFA World Cup in Russia Jaroslav's team developed multiagent transportation model with decision support enterprise system and rendering husk for the Transport Directorate of FIFA World Cup 2018. Jaroslav will tell about development of this project and its architecture.

We'll look which problems would appear if Jigsaw had had explicit module versions, and how Jigsaw Layers together with Jigsaw services allow us to solve the Jar Hell problem safely.

There is a new way of app composition gaining popularity in the FP community. It allows to define the accurate description of the components' work without overhead charges and is a perfect realization of Dependency Inversion Principle. We'll discuss the history and the formal, technical and practical aspects of implementing this approach using Scala as an example.

Benjamin wants to show, using an application as an example, how to get started with introducing domain models, bounded contexts and implementing CQ(R)S where it makes most sense while trying to avoid the technical debt trap, e.g. misconceptions and fallacies.

We'll explore which structures of the virtual machine take in virtual memory, how to monitor and manage its consumption. We'll study different strategies of virtual memory management and learn what was changed in the new versions of JDK. We'll examine the real cases of native memory leak and get to know the tools of allocations analysis.

Yegor truly believes that quality is not what programmers should care about. They must care only about speed — close tasks as soon as possible — which means making the project move forward.

At TransferWise they use Kafka and local database transactions to achieve transactional behavior across multiple microservices. In this talk Harald will describe their architecture and design decisions. He'll compare their own solution with other alternatives and show why they chose to build their own. He'll also give a quick recap on database transactions and Kafka.

When developing big distributed apps, it is usually considered a good practice to separate the app configuration from its business logic. We've developed our own library for dynamic configuration, and we will tell about its internal design and how you can employ it in your own project.

In this session, we will see how you can delegate your identity and access management to an external service that will leverage OpenID Connect, JWT, Single Sign On etc. We will also cover how to integrate your existing infrastructure (LDAP, Kerberos) with these modern architectures.

No more puzzlers in Java, we thought — and then Oracle decides to bring in new ones every six months!

We'll look at what leads to complexities, the traps developers and organizations fall into, and what we can do to effectively deal with these common, recurring issues we see across domains and products.

Reactive-Streams brought a new, amazing standard for Reactive Libraries users as well as broader horizon of hardcore problems for the standard's adopters. During this talk, we will walk through all the steps of implementing RS Publisher<?> in Java. Finally, we will get an understanding how to build the CORRECT implementation of that interface, test it, and ensure that other popular solutions work similarly.

We'll talk about configuration of SubstrateVM, special aspects of its approach to code compiling and its limitations. We'll discuss which programs might and should be compiled ahead-of-time, look at applications already working and at their performance.

What can aggressive information environment do to our brain? What are the main problems of the human intellect? How to make our thinking more effective by using latest discoveries of the brain sciences? Andrey Kurpatov will tell what awaits us in the future and how we can prepare for it.

We explore the technical details of compiled lambda expressions and learn about the new JVM capabilities — which come with several performance benefits and could also be used for other JVM languages.

Anton will tell about varying approaches to the differentiation of access rights (RBAC and ABAC), about base architecture of ABAC solutions and say a few words about already existing products. Then he'll present their own framework for working with attributive access model.

This session will highlight the most important features developers should know to work with Java 9 and 10, combined with some practical tips and warnings.

Artem will tell about a set of methods tried on a "live" project, which helped make execution time of some jobs 5-20 times better. The talk's aimed at engineers working with big data and especially with Spark.

An overview of a variety of platform independent JVM serviceability tools and technologies that can be used for solving problems with applications running on the JVM.