Oleg Šelajev

Oleg Šelajev

GraalVM all the things

Oleg Šelajev 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.

Current sessions

What makes the GraalVM compiler so good?

In this talk we would like to give you a short overview of GraalVM and then move on to why the GraalVM JIT compiler is so fast / efficient, and where it really excels.
We will show some examples that will allow us to take a look at the internal IR graph that GraalVM uses to generate native code.
You'll learn about some of the most important optimisations in the GraalVM compiler
And finally we would like to talk about what it is about GraalVM that lends itself to being improved - and as an example of this we will look at some recent improvements.

GraalVM often shows the best results on a variety of Java workloads. Even more so for the JVM languages like Scala and Clojure and others.

While it's not necessary to understand how the JIT compilers work, or the particular optimizations to use the fastest runtime you can (you just need to measure and assess your options carefully), it's a very interesting topic that can be educational to Java developers.

You'll learn which code patterns get optimized well or not, you'll learn some patterns where GraalVM compiler completely outclasses its competition, and will be able to recognize them in the code you write.

You'll also get a better idea what C2 -- the default top tier JIT compiler in OpenJDK does for those code patterns and if needed could maybe use that information to manually optimize code for it.


GraalVM for Java developers

GraalVM is a high-performance runtime for dynamic, static, and native languages. GraalVM supports Java, Scala, Kotlin, Groovy, and other JVM-based languages. At the same time, it can run the dynamic scripting languages JavaScript including node.js, Ruby, R, and Python.

In this session we'll talk about the performance boost you can get from running your code on GraalVM, look at the examples of running typical web-applications with it, enhancing them with code in other languages, creating native images for incredibly fast startup and low memory overhead for your services.

GraalVM offers you the opportunity to write the code in the language you want, and run the resulting program really fast.


Maximizing performance with GraalVM

In this session we will discuss the best practices for Java code and compiler configurations to maximize performance with GraalVM and how to measure performance in a reliable manner. We will talk about how to achieve minimal memory footprint and binary size of GraalVM native images — programs compiled ahead of time to native executables. A comparison of profile-guided optimizations for ahead-of-time compilation and just-in-time compilation will show the benefits and drawbacks of the two approaches. After this session you will have a better idea how to use GraalVM for the maximum potential to run your applications faster!


GraalVM workshop

In this workshop, participants will learn about the main benefits of GraalVM by running example programs on their laptops. First, we will cover how to improve peak performance for JVM-based applications. Then, we will create a native image for fast startup and low footprint. Finally, participants will create a multilingual application with interoperability between multiple languages including Java and JavaScript. You will learn first-hand how the versatility of GraalVM allows running your code in the best suitable mode maximising performance or minimising footprint.

Workshop, attendees should bring their own computers and can try GraalVM themselves


Faster and more powerful Scala with GraalVM

GraalVM offers a high-performance runtime for JVM languages with support for others like JavaScript, Python, Ruby, R. In this session, you'll learn how Scala developers can benefit from GraalVM. We'll look at the performance of Scala on GraalVM, and discuss what to remember when making the comparisons. We'll talk about how you can use known and trusted Scala libraries to power Node.js microservices and touch on the subject of the GraalVM native images and faster startup. This session shows the versatility and power of GraalVM and teaches everything one needs to know to start their tests.


GraalVM as a Platform for Cloud Native Java

GraalVM is a high-performance polyglot runtime for dynamic, static, and native languages. Among other things it can compile Java applications ahead-of-time to native binaries which start up really fast, are immediately ready to do useful work, and have much lower memory usage than a typical Java apps. As in milliseconds to start and run well with just a few MB of memory. This ability makes GraalVM ideal runtime for deploying Java applications to the cloud, autoscale to 0, or Function as a Service environments where otherwise you'd think it's a bit awkward to use Java.

You will learn how to use GraalVM as a platform for your cloud Java deployments: building native binaries, profiling your code for the best AOT compilation results, configuring resource consumption based on the best practices and historic data, and reducing the container startup overhead for ultimately fast startup.


Polyglot done right with GraalVM

GraalVM offers a polyglot runtime where you can mix JVM languages with JavaScript, Python, Ruby, R, WebAssembly, and so on without the performance penalty for language changes. It allows us to write applications that take the best from the respective language ecosystems, machine learning, data science. However, to adequately implement the polyglot application you need to know some GraalVM details: API, concurrency models for different languages, interoperability patterns, and so on.
In this session, we'll go through the necessary minimum amount of information needed for writing good polyglot apps on GraalVM. Currently, there are a few companies that use GraalVM in production mixing Java (and Scala) with JavaScript and R. Learn how GraalVM helps to create polyglot applications and when you should use it.


Fast and Efficient Microservices with GraalVM

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.