March is right around the corner, which means we’re nearing another Java release that takes place every six-months…like clockwork! The arrival of Java 20 marks the 11th release since moving to a six month release model in 2017. Each release continues to offer incremental modernization allowing you to adopt Java innovation more easily and rapidly.

To celebrate the arrival of Java 20, Oracle is proud to announce “DevLive: Level Up”, a new free hybrid event series covering innovation & technologies for developers, offering attendees the chance to participate in-person or online.

On March 21st, the Java Team at Oracle will hold a dedicated Java Developer Day edition where experts will cover topics such as enhancements in Java 20, tools & troubleshooting techniques to accelerate app dev, support for emerging frameworks, security enhancements in Java, JavaFX updates, participation in the OpenJDK project and Java community, and more.

Space is limited so please register now and join us!

Keynote

Java First. Java Always

Georges Saab - Senior Vice President of Development, Java Platform and Chair, OpenJDK Governing Board

Modern application development is unrecognizable without Java. For more than 25 years, Java has empowered developers to create the next generation of rich, scalable, and secure applications. In this keynote, explore updates from the Java 20 release and learn how Oracle’s ongoing Java technology leadership and community stewardship are creating a contemporary language and platform that helps developer productivity.

Breakout Sessions

New in JDK 20: Reviewing the Enhancements in the Latest JDK Release

Aurelio Garcia-Ribeyro - Senior Director of Product Management

In what is now a semi-annual tradition, we offer an overview of the JDK Enhancement Proposals (JEPs) delivered with the latest JDK release. Along with thousands of performance, stability, and security updates, JDK 20 offers advances in Project Amber, Project Loom, and Project Panama. In this session, learn all about the value JDK 20 offers developers.

Java Virtual Threads

Sergey Kuksenko - Principal Member of Technical Staff

Concurrent applications, those serving multiple independent application actions simultaneously, are the bread and butter of Java server-side programming. The thread has been Java’s primary unit of concurrency since its inception and is core to the entire Java platform. However, it can no longer efficiently represent a domain unit of concurrency. As a result, Java has seen a proliferation of libraries and frameworks that offer scalability while abandoning the thread as the unit of software concurrency—and, with it, the support of Java’s observability tooling. In this session, learn how Project Loom aims to reinstate the thread as an efficient unit of concurrency by adding a lightweight implementation of threads to the Java platform.

Z Garbage Collector: The Next Generation

Paul Su - Software Development Director

The Z Garbage Collector (ZGC)—a scalable, low-latency garbage collector providing sub-millisecond max pause times—continues to evolve. This session will review the design goals behind ZGC and provide a look into the impact of the upcoming support for multiple generations. It will also present general guidance on selecting a garbage collector given certain use case characteristics.

Java Language Futures, Spring 2023 Edition

Stuart Marks - Consulting Member of Technical Staff

Through Project Amber, the Java programming language is evolving faster than ever. In this session, participants will receive a summary of many of the Java language enhancements that have appeared in recent Java versions, including Java 20. You’ll also get a glimpse of the future as we look ahead to directions and features that are in development for future Java releases.

Troubleshooting Native Memory Issues in Java Applications

Poonam Parhar - Consulting Member of Technical Staff

Are you having trouble understanding native memory usage growth or leaks in your Java application? Learn about diagnosing and resolving native memory problems in Java applications. We’ll talk about different memory pools available in a Java Virtual Machine (JVM)-based Java application. You’ll learn how to identify a native OutOfMemoryError and confirm if you’re encountering a native memory leak. Importantly, we’ll take a closer look at the various diagnostic data and troubleshooting tools needed to understand and troubleshoot native memory problems

JavaFX 20 and Beyond

Kevin Rushforth - Consulting Member of Technical Staff

JavaFX continues to be developed and released with the same rapid cadence as the Java Development Kit, with a new release every six months. Explore what’s new in JavaFX 20 and beyond as we highlight the improvements to JavaFX over the past few releases. We show how developers can create and distribute applications leveraging the JavaFX platform and explain how developers can contribute to the OpenJFX Project to improve the platform even further. We’ll preview some of the ideas we’re working on to help make JavaFX more approachable for students and developers who are new to JavaFX.

Project Panama: Interconnecting the Java Virtual Machine and Native Code

Paul Sandoz - Software Architect

Project Panama improves and enriches the connections between the Java Virtual Machine (JVM) and non-Java APIs, including many interfaces commonly used by C programmers. This session will offer an overview and demo of features from Project Panama, including JDK Enhancement Proposal (JEP 434) from Java 20.

Evolving the Security of the Java Platform

Frances Ho - Software Development Director & Brad Wetmore - Principal Member of Technical Staff

Maintaining and improving the security of the Java platform is an essential and continuous process. This session will discuss recent improvements to Java’s security and cryptographic APIs and libraries. In addition, you’ll learn about the process and changes made to update releases via the Java Cryptographic Roadmap.

Managing Your Java Estate Just Got Easier with Java Management Service

Aurelio Garcia-Ribeyro - Senior Director of Product Management

Operating an organization’s Java estate is complex. Typically, there will be multiple versions of Java, deployed across dozens of environments, supporting many applications. The complexity of managing the estate is the product of these multiplied together.

Java Management Service from Oracle is a cloud service that can help address this complexity. Basic discovery services, available to everyone, provide critical insights into Java application behavior and compliance. Advanced features, available to Java SE Subscription customers and OCI customers, deliver centralized runtime management, performance, and cryptographic usage information. Users of Java Management Service can:

• Track Java runtimes and applications.
• Update or upgrade old Java installations.
• Monitor and gather additional insights on Java applications.

In this session, you’ll learn about the latest features of Java Management Service and how it can help you better manage your Java estate.

The OpenJDK Project: Change the Future of Java

Chad Arimura - Vice President, Java Developer Relations

Java, its libraries, and the HotSpot Java Virtual Machine (JVM) are all built through OpenJDK, an open-source project. Your participation in this project can help shape the future of Java. To make the journey easy to understand, Oracle has created the OpenJDK Developers’ Guide for aligning developers around terminology and processes for participating in the OpenJDK Project. Learn how you can contribute to the future of Java.

Moving the Java Community Forward

Sharat Chander - Senior Director of Product Management and Developer Engagement

For more than 25 years, Java has offered unique value to developers worldwide. It’s shaped the world we live in by offering new ways to address the ever-evolving technology landscape. That innovation is only possible because of you. The developer community plays an important role in ensuring Java stays vibrant. In this session, learn about the many programs available to the Java community, all contributing to the cause of moving Java forward.

Helidon: Microservices on Modern Java

Joe Di Pol - Development Manager, Helidon

This session covers the practical aspects of using Project Loom’s Virtual Threads (from OpenJDK) with Helidon Níma. Created by Oracle and currently in the Alpha stage, Helidon Níma is the first service framework designed for Virtual Threads. This session will explain what Project Loom brings to service development, compare it to Oracle’s reactive implementation, and show performance improvements that can be achieved. You’ll also get a short introduction into Helidon MicroProfile and understand how it benefits from Oracle’s switch to Virtual Threads.

GraalVM Native Image—Faster, Smarter, Leaner

Shaun Smith - Senior Director of Product Management

With support from all the leading microservice frameworks, compatible SDKs from all of the top cloud platforms, and ease of containerization, GraalVM Native Image is a great choice for cloud native application development. Join this session for an update on the latest GraalVM Native Image developments including JDK 20 support, Spring Boot 3 and Micronaut 4 integration, improved monitoring and debugging (perf, JFR, vmstat, and native debug), record breaking peak throughput, and more.

Building High Performance Microservices for Java with Micronaut and GraalVM

Burt Beckwith - Principal Member of Technical Staff

Micronaut is a full-stack framework for Java meant for building any type of application, with extensive support for microservices, serverless, and containerized environments such as Kubernetes. From the beginning, Micronaut has had first-class support for GraalVM native image, which we’ll see in action, demonstrating the significant reductions in startup time and memory usage. We’ll also take a look at new support for developing portable multi-cloud applications and microservices and preview some of the new features in the upcoming Micronaut version 4, including support for features in recent JDK releases such as Records and Virtual Threads.

Hands-on Labs

Getting Started with Virtual Threads

David Delabassée - Director, Java Developer Relations

Project Loom introduces virtual threads—a new kind of lightweight threads—which are unarguably one of the most anticipated features coming to Java. Virtual threads are much lighter than platform threads. In fact, they’re so light that you don’t need to pool them anymore. Loom also adds Structured Concurrency to Java—a new concurrent programming model based on a more traditional, easier, blocking approach. Bring your own laptop so you can use Project Loom’s Structured Concurrency API to handle multiple asynchronous tasks using a simple synchronous-blocking model. You’ll experience how Project Loom will revolutionize concurrent code development in Java, including debugging. This hands-on lab is only available to in-person attendees.

Helidon: Bring On the Virtual Threads!

Joe Di Pol - Development Manager, Helidon

This lab will guide you through the implementation of a service using Helidon Níma APIs. First, we’ll focus on features and benefits provided by Java’s Project Loom, such as Virtual Threads and Structured Concurrency. Then, we’ll use Helidon starter to create a Helidon MicroProfile application to demonstrate how Virtual Threads are used and show you how to easily upgrade applications to the latest Alpha version of Helidon 4. At the conclusion of this lab, you’ll walk away with multiple high-performance techniques and options for writing services with Helidon that are designed and optimized for Loom. Bring your own laptop to begin your learning journey with Helidon. This hands-on lab is only available to in-person attendees.

Getting Started with GraalVM Native Image

Shaun Smith - Senior Director of Product Management

GraalVM Native Image makes it possible to ahead-of-time (AOT) compile Java bytecode applications into native machine executables that start almost instantaneously, provide peak performance with no warmup, and require less memory and less CPU. Because it’s perfect for containerized workloads and microservices, it’s been embraced by Micronaut, Spring Boot, Helidon, and Quarkus. In this lab, we’ll provide a short practical introduction to GraalVM Native Image AOT that covers what it is, what it can do, and how you can get started building native Linux, macOS, and Windows executables. Bring your own laptop and work either locally or on a hosted lab environment that runs in a browser. This hands-on lab is only available to in-person attendees.

~