Keeping Your Java Hot by Solving the JVM Warmup Problem

Hello Everyone,
This is our first event of the year 🥳. This is an event not to be missed so let's start the year with a bang 💃🕺

What is this session about?
Keeping Your Java Hot by Solving the JVM Warmup Problem
Java bytecodes and class files deliver on the original vision of “write once, run anywhere”. Using a Just-in-Time (JIT) compiler allows JVM-based applications to compile only the code that’s being used frequently and optimise it precisely for how it is being used. Using techniques like speculative optimisation can often deliver better performance than static, Ahead-of-Time (AOT) compiled code.
However, this flexibility and performance comes at a cost. Each time the JVM starts an application, it must perform the same analysis to find hot spots of code and compile them. This is referred to as the application warmup time.
In this session, we’ll look at several approaches to how this problem can be alleviated or even eliminated. Specifically:
· Static compilation of Java code ahead-of time (AOT). Specifically, the Graal native image approach
· Generating a JIT compiler profile of a running, warmed-up application that can be reused when the same application is restarted, eliminating the need for much of the JIT compilation.
· Decoupling the JIT compiler from the JVM for a Cloud environment. Providing a centralised JIT-as-a-Service allows caching of compiled code and offloading the compilation work when new code must be compiled.
· Creating a checkpoint of a running application. This includes all application state (heap, stack, etc.) in addition to the JIT-compiled code. Project CRaC will be used as an example.
At the end of the session, you’ll be all set to keep your Java hot!

The Art of Java Language Pattern Matching
The goal of project Amber within OpenJDK is to explore the inclusion of smaller, productivity-oriented Java language features. One part of this that has delivered new functionality in recent versions is pattern matching.
Pattern matching combines application code logic to test if an expression has a specific type or structure and extract components of its state for processing.
Pattern matching is now well embedded in the Java language using the following features, defined by JDK Enhancement Proposals (JEPs)
· Pattern matching for instanceof (JEP 305, 375, 394, 433)
· Pattern matching for switch (JEP 406, 420, 427, 441)
· Record patterns (JEP 405, 432, 440)
· Unnamed patterns and variables (JEP 443)
In this session, we’ll look at the details of these new language features and a more general look at pattern matching. We’ll also explore future features in this area such as array patterns, which may be included in a subsequent Java release.
By the end of the session, you’ll be ready to use these powerful new features.

Who is it aimed at?
Software Developers

Sponsor

Accso partnerships has offered us their beautiful offices to host this event. We are grateful to them for accepting our invitation 👏👏

About Accso
At Accso, your challenge is our challenge. We are an innovative and fast-growing IT service provider that focuses on IT consulting and the development of bespoke business-critical software solutions that support our customers’ core competencies.

We make your most challenging projects successful
That’s our vision. Accso is the go-to specialist for complex, individual IT solutions. This has been our focus since we founded the company, and we strive to continually improve and develop our expertise in this field

Socializing
After the event there will be eats pizza, drinks and beer as we socialize with each other 🍕🍷🍻. This is not an event to be missed, see you there 🕺💃

Address
Suite 302, 3rd floor, Clock Tower building, V&A Waterfront

AGENDA (CPT - SAST - GMT+2)

5:45pm Doors Open
6:00pm CTJC Introduction & Announcements
6:05pm A word from our event sponsor - Accso
6:10pm Presentation by Simon Ritter
8:10pm Q&A
8:30pm Post-talk social networking