Java’s open ecosystem—specifications, source code, JSRs, JEPs, mailing lists, MicroProfile, and Jakarta EE—made it an ideal training ground for LLMs. These models learned more than syntax: they absorbed Java’s patterns, idioms, and design philosophy. In this live-coding session, we’ll explore how to put that knowledge to work with short prompts and rapid iterations. Topics include: Engineering prompts that follow Java conventions and best practices Using agents for autonomous code generation and refactoring Maintaining architectural consistency with Spec-Driven Development Improving code incrementally with agents Sharing best practices through instructions, rules, and steering files Developing a “Prompt Specific Language” (PSL) for consistent code generation We’ll also generate idiomatic Java 25 code that is both machine-readable and human-friendly. Presented by Adam Bien at JavaOne 2026 (CA, March 2026). All https://www.youtube.com/playlist?list=PLX8CzqL3ArzUMVSzm-z_-if8BIB55EGl4 talks. Adam's JavaOne 2025https://youtu.be/J1YH_GsS-e0?si=jGY3AqM5dz9yVzbQ Tags: #Java #AI #JavaOne LRN1064 18 AUDI

Just-in-time (JIT) compilation within the JVM is essential to Java's performance and plays a central role in ongoing OpenJDK projects such as Valhalla, Leyden, and Panama. JIT compilation is…

Not all Rust users use it for systems programming. Big usage I see is for backend development. If you're doing systems programming, it is simply don't import std::mem::GC, or pass the --disable-gc flag. Those who want convenience or want to replace Arc can use std::mem::GC. Looking at Java's GC performance today, it's certainly possible to have a super high performance GC

What happens when we try to draw a single pixel in Java? The rendering triggers a sophisticated and multi-layered process. It begins within the high-level frameworks of Java's Abstract Window Toolkit

Just-in-time (JIT) compilation within the JVM is essential to Java's performance and plays a central role in ongoing OpenJDK projects such as Valhalla, Leyden, and Panama. JIT compilation is constantly evolving to support the evolution of the Java language, its main application areas, deployment models, and underlying hardware. This talk provides an overview of recent performance improvements delivered by the JVM's JIT compilers, both as part of and in addition to OpenJDK projects, and highlights some of the most significant ongoing developments in this area.

PURWOREJO, Indonesia — As a young man, Parman hunted songbirds here in the Menoreh Hills, a landscape of karst valleys near the Indonesian city of Yogyakarta. The area is now a UNESCO Biosphere Reserv...

_Introducing composable, module system native and agent friendly command line tools for modern Java development_ By Danny Thomas, JVM Ecosystem Team Recent work on the Java language to pave the on-ramp has made it easier than ever to start a Java program and evolve it using the full language and platform. At the end of that on-ramp lies Java’s mature build and dependency management ecosystem, capable of carrying software to enormous scale and complexity. That ecosystem reached its maturity by developing strong models for projects, dependencies, and builds. When the Java Module System arrived, those models were already serving developers exceptionally well. The module descriptor consequently became just another description of the project to keep in agreement. We’re excited to announce a preview of ja and its family of composable tools, that build on the capabilities of the Java Module System to provide a modern command line development experience for Java. We take the module descriptor and make it a complete description of a project, with dependency versions sitting naturally beside its requires directives and module metadata provided through documentation tags: /** * @mainClass com.example.application.Main */ module com.example.application { requires com.example.framework; // @1.2.3 } Combined with command line ergonomics you’re used to in other languages, creating and consuming Java modules has never been easier. ### Composable Tools Java developers have long been exceptionally well served by graphical tools. An IDE formats source, navigates between declarations and usages, presents API documentation, and maintains a compiled view of the project. That experience has been so complete that Java has had less need to expose the same capabilities through small, composable command line tools. Those gaps become quickly apparent when coding agents work with the Java language, with agents frequently struggling to locate dependencies, documentation and sources. ja only provides command line ergonomics and tool orchestration, each feature is underpinned by a standalone tool. You don’t need to adopt ja to get the benefit of these tools, you can compose them in any way you choose: * jig performs module version resolution, compilation and assembly, outputting standard module system arguments for use with other tools. It is also the bridge to and from Maven repositories providing a standalone module proxy and publishing commands * jfmt formats source using the Code Conventions for the Java Programming Language, adapted for the modern Java language. Avoids the very common whitespace, indentation, import ordering and qualified class references introduced in agent written code * jist provides source aware symbol search, providing a grep style interface for understanding class files and their associated sources. Gives coding agents access to symbols and sources without indexing, LSPs or MCPs while interoperating with other build tools via an argument file contract * jdocserver serves locally browsable API documentation These projects use the tool discovery and execution capabilities of the platform, and are intended to be installed in your JDK along with the standard tools. They all implement Tool or ToolProvider, allowing them to be run in process. This is also the tool discovery and execution model for ja. There we use OptionChecker and optional custom metadata to discover which module system options are supported so it can resolve the arguments on behalf of the tool. This provides a seamless transition from your source path modules to the standard JDK tooling such as jdeps, jlink and jshell. ### Maven as a foundation In a recent survey of the 1,000 most popular artifacts on Maven Central, just 232 had explicit module definitions and another 248 declared automatic module names. The remaining 520 expressed no Java module name opinion. The module system also makes no distinction between namespace and module name, so module-first tooling requires a solution to module naming and location in existing repositories. Fortunately, Maven Central already gives published artifacts a verified namespace. Publishers prove control of reverse domain group IDs, reflecting Sonatype’s long standing case for namespaces in public repositories. We use these conventions to establish a canonical Maven module coordinate, paring a verifiable DNS namespace with the complete module name, for example pkg:maven/com.netflix/com.netflix.tools.ja. For existing modules, authors choose to publish a single Maven relocation pom at the canonical coordinate, to allow for discovery of the original coordinate. When neither are available, candidates are walked from the root of the namespace using common Maven artifact conventions inferring coordinates from module names. We also bundle a short list of aliases for the most popular modules that don’t use a reverse DNS module name, but we suggest authors should always namespace their modules. The module proxy in jig presents resolved modules using the filename based conventions for module naming, making even automatic modules without stable names safe when used with these tools. These conventions and location strategies allow the majority of existing artifacts to be discovered using only the module name and version. ### Integrity by default ALL-UNNAMED has become unfortunately common in Java access options, because of the heavy use of the class path. It hides the source of the technical debt that applications are incurring by allowing such access and becomes increasingly consequential as Java moves toward Integrity by Default. For example, Preparing to Make Final Mean Final asks applications to explicitly authorize the modules allowed to mutate final fields. We allow runtime access requirements to bedeclared as module metadata and carried with the module descriptor throughout the module’s lifecycle. For example a library may record the access it requires: /** * @enableFinalFieldMutation com.example.framework */ module com.example.framework { } However, the consuming application remains in control and must explicitly authorize the framework, for it to be available at runtime: /** * @mainClass com.example.application.Main * @enableFinalFieldMutation com.example.framework */ module com.example.application { requires com.example.framework; // @1.2.3 } The command line interface for ja allows the dependency and authorization to be added together: ja require com.example.framework@1.2.3 \ --enable-final-field-mutation com.example.framework Without that authorization, dependency resolution fails with an unsatisfied access requirement. Native access follows the same model through @enableNativeAccess and qualified exports and opens are also supported. Module integrity is ensured by persistent hashes of resolved binary dependencies in a module-info.hash file, sequent resolution verifies those hashes and rejects an artifact that has changed. We also take a step further than the recent improvements to annotation processor security by treating annotation processing as an explicit code generation step. The resulting sources are alongside regular module source, making them visible in code review and allowing a module to be assembled without executing generator code. ### Make modules your default We think every Java project should be modular, regardless of the build tool you’re using. If you’re a library author producing automatic modules, we’d encourage you to avoid split packages and produce explicit modules. You can get started with our tools today with our installation guide. * * * Leave the Class Path in the Rearview Mirror was originally published in Netflix TechBlog on Medium, where people are continuing the conversation by highlighting and responding to this story.

Java’s age has long been both its strength and its drawback. In 2026, that age is less about technical debt