DEV Community: IgorIOT

Stop Saying Java is Slow

IgorIOT — Thu, 05 Mar 2026 16:59:33 +0000

How goes the battle?

Java 25 Performance: Faster Starts, Smarter Memory, Better GC

Java 25 isn’t just another incremental release. It brings meaningful performance improvements that directly impact how fast your applications start, how much memory they consume, and how efficiently they manage garbage collection.

Let’s break down what changed, and why it matters.

🚀 Faster Startup with the New AOT Cache

One of the most exciting additions in Java 25 is the new Ahead-of-Time (AOT) cache.

Traditionally, when a Java application starts, the Just-In-Time (JIT) compiler kicks in and begins optimizing code as it runs. While this leads to excellent long-term performance, it adds overhead during startup.

Java 25 changes that.

With the AOT cache (introduced through JEPs 483 and 514), you can perform a “training run” of your application. During this run, the JVM observes which classes and methods are actually used. It then generates an optimized cache specifically for that execution profile.

Later, when the application starts in production, the JVM loads this prebuilt cache directly into memory. The result? Much less JIT work at startup, and dramatically faster boot times.
In large applications with many classes, startup times can improve by up to 50%.
And it gets better.
JEP 515 enhances the AOT cache by incorporating profiling data collected by the JIT itself. That means the cache isn’t just precompiled, it’s optimized based on real runtime behavior. Smarter data, better performance.

JEP 483

JEP 514

JEP 515

🧠 Smaller Object Headers, Lower Memory Usage

Java 25 also takes aim at memory efficiency with Compact Object Headers (JEP 519).

Every object in Java carries a header containing metadata used by the JVM. While small individually, these headers add up quickly in systems managing millions of objects.
Java 25 optimizes and reduces the size of these headers, decreasing overall memory footprint.

Why does this matter?

Applications consume less memory
The Garbage Collector has less work to do
Performance improves under memory pressure

In extensive production testing across hundreds of services, memory usage dropped by up to 20% in some workloads. Processing time improved by up to 10%, and GC cycles were up to 15% less frequent.

That’s not theoretical, that’s production-grade validation.

JEP 450

JEP 519

♻️ Garbage Collection Keeps Evolving

Java has always offered multiple garbage collectors for different workloads. In Java 25, all major collectors receive meaningful upgrades.

Shenandoah Goes Generational

Shenandoah is known for low-latency performance, minimizing pause times by performing most of its work concurrently with the application.

With JEP 521, Shenandoah now supports a generational mode. Generational GC typically performs better because most objects die young — and now Shenandoah can take advantage of that reality.

ZGC Embraces Generational Design

ZGC also moves forward with a generational implementation (JEP 474). In fact, the non-generational mode has been deprecated. Since generational approaches generally provide better performance characteristics, future innovation will focus there.

G1 Gets Smarter About JNI

G1, still the default GC in Java 25, also improves through JEP 423. The focus here is reducing pause times during operations involving JNI (Java Native Interface).

For applications interacting with native code, this means smoother performance and fewer unexpected delays.

JEP 423

JEP 474

JEP 521

The Big Picture

Java 25 isn’t flashy, it’s practical.

Faster startup with AOT caching
Lower memory usage with compact object headers
Smarter, more efficient garbage collection

These aren’t cosmetic changes. They directly impact cloud deployments, containerized applications, microservices, and large enterprise systems.

Modern Java keeps evolving, and it’s becoming faster, leaner, and more production-optimized with every release.

Picture 01: Duke speedster inspired

Java 25 represents a major leap forward in making the JVM more efficient and developer-friendly than ever before. With the new AOT caching system dramatically slashing startup times (up to 50% in many cases), Compact Object Headers shrinking memory usage by up to 20%, and meaningful refinements to G1, ZGC, and Shenandoah, the platform is now faster to launch, lighter on resources, and more responsive under load, all while maintaining the reliability and scalability Java is known for. Whether you’re building cloud-native microservices, real-time applications, or large-scale enterprise systems, these improvements mean less waiting, lower costs, and smoother performance right out of the gate. Java 25 isn’t just an incremental update, it’s a clear signal that the language continues to evolve to meet modern demands. Time to upgrade and experience the difference yourself!

Links

https://inside.java/2025/10/20/jdk-25-performance-improvements/

https://gillius.org/blog/2025/10/java-25-framework-startup.html

Stop Saying Java Is Verbose

IgorIOT — Sun, 15 Feb 2026 21:23:06 +0000

How’s it going there?

Whether you’re a student learning your first “Hello, World” or an experienced developer writing quick prototypes, Java 25 streamlines the experience. For decades, this was a barrier. Beginners had to learn about classes, static methods, arrays, String, System.out, packages, imports, the main keyword's meaning, and public access modifiers before they could even print text.

But it is not Java 25 that brings it all; it's been a while since a lot of stuff has been happening. Let's see some of the evolution.

In almost all of those JEP summaries, you can see this:

“Evolve the Java language so that students can write their first programs without needing to understand language features designed for large programs.”

Java 21 – Unnamed Classes and Instance Main Methods (JEP 445)

https://openjdk.org/jeps/445

Unnamed classes: Programs could omit the class declaration entirely; the compiler would wrap top-level methods into an unnamed class.

Instance main methods introduced: You no longer need public static void main(String[] args). Instead, you can declare void main() or void main(String[] args) as an instance method inside a class.

Java 22 – Implicitly Declared Classes and Instance Main Methods (JEP 463)

https://openjdk.org/jeps/463

The “unnamed classes” concept was replaced in Java 22 with a more streamlined and intuitive model: implicitly declared classes, or implicit classes. Instead of requiring a special classification, the compiler now treats any top-level code without an explicit class declaration as belonging to a standard class automatically generated by the compiler. This class is given a host-determined name (the name of your .java file), is final, belongs to the unnamed package, extends Object, and cannot implement interfaces—yet functions like a regular class in behavior.

Java 23 – Implicitly Declared Classes and Instance Main Methods (JEP 477)

https://openjdk.org/jeps/477

No need to reference System.out and wonder what it means. They introduced a new IO class with print/read features (print, println, readln), and the amazing part is that these methods are auto-imported, so you can directly write println("Hello, World!");. In addition, all public classes in java.base are now auto-imported, making types like List, File, or BigDecimal usable with zero ceremony.

Java 24 – Simple Source Files and Instance Main Methods (JEP 495)

https://openjdk.org/jeps/495

It looks like nothing has been changed in the code feature here, but they decided to unify the feature under the name simple source files instead of implicit classes.

Java 25 – Compact Source Files and Instance Main Methods (JEP 512)

https://openjdk.org/jeps/512

The static methods originally provided in java.io.IO (println, …) have been moved to java.lang.IO (and since everything in java.lang is imported by default, they are now more accessible).
These operations are now based on System.out/System.in rather than the Console API. However, the static methods of the IO class are no longer implicitly imported into compact source files. This means that method calls must explicitly reference the class.

Compact source files automatically access all public classes and interfaces from java.base module (i.e., import module java.base;).

Java 25 – Flexible Constructor Bodies (JEP 513)

https://openjdk.org/jeps/513

One important part of this flow is constructor chaining. If a class has a parent class, Java ensures that the parent constructor runs before the child constructor logic. This guarantees that the object is built step by step, starting from the top of the inheritance hierarchy.

This improves this situation because it allows certain statements to appear before #super() or #this() calls, making constructors more expressive and readable.

This is not an exhaustive list, and I really suggest you go there and try out some examples of each one to really get a good understanding of those benefits.

VSCode Plugin

Did you know that you can run a simple Hello World in one line of code without knowing anything?

There's a nice VSCode plugin that also introduces Interactive Java Notebooks (IJNB), which allow you to create notebooks that combine formatted text (Markdown), executable Java code, and execution results in any order.

Let's do a simple test;

You just need to install VSCode and install the plugin; that is it. If you don’t have Java on your machine, the plugin will ask you to auto-install it for you. Of course, choose Java 25.
Open a new notebook, and that’s it: a Java Hello World in one line.

Sample Code 1: Hello World in One Line

Launching Simple Source-Code Programs

Another nice point here. This can be a great way to learn how to use Java or explore new features within the Java API, without having to go through the cruft of compiling and then executing code. A simple Java as a JavaScript.

Sample Code 2: Hello World from Terminal

To really understand what’s happening under the hood here, I suggest using the javap tool to disassemble the file.

Sample Code 3: Javap Disassemble the File Result

The output shows that the Java compiler automatically generated a FileName class with the default constructor. This behavior shows that while the syntax has been simplified, the underlying Java class structure is still preserved. In short, the Java compiler writes the class for us with the class name named after the source file name.

Video: Dan Vega Talking About Java Is Verbose Back in 2024

Call to Action

Go there and try to explore those things. Let me know what your thoughts are. Any JEP or anything else that I forgot to add in this list? I would love to hear from you.

From now on, if you see anyone saying that Java is verbose, you can simply send this blog post link.

Conclusion

The Java evolution shows a clear vision: making Java simpler for small programs, powerful for big ones.

Java 25 marks a turning point. With compact source files and instance main methods, Java finally aligns with beginner expectations while preserving its scalability for enterprise use, a game-changing feature that dramatically reduces boilerplate code for simple programs. With those updates, Java finally offers a beginner-friendly way to write code without the overhead of explicit classes, public static void main, or import statements—making the language more accessible than ever.

Remember, you can have an if-else in one line; you can use the "Ternary Operator", but this might translate into more difficult code to read and understand. So a lower number of lines does not necessarily mean better code. Sometimes being verbose is a good thing.

There is much more to explore regarding Java in a single file, Java as scripts in terminal, and Java in a notebook.

Links

All Java 25 info

I really recommend this 2022 blog from Brian Goetz that might be the beginning of the JEP 512 initiative

The Unnamed Classes Documentation

JavaP and More

Did you know about “JEP 519: Compact Object Headers” that comes with the idea to reduce the object header size? Does this mean that we can say that Java is not slow anymore? Stay tuned here for the next blog “Stop Saying Java Is Slow.”

Welcome to IgorIOT (a.k.a. I Go Riot)

IgorIOT — Mon, 09 Feb 2026 00:19:33 +0000

Hey everyone!

I’ve decided it’s time to start a new chapter. I’m officially relaunching my blog under a new name: IgorIOT; Yes, that’s “Igor I-O-T”, but also my playful way of saying “I Go Riot”.

Why the change?

My old blog igfasouza.com/blog has been a place where I’ve explored everything from development to data engineering. Over the last couple of years, most of my public content, especially on social media, has focused on Apache Kafka and streaming platforms.

This new blog will focus primarily on Java and Raspberry Pi, exploring how modern Java can be used in hands-on projects, learning environments, and real-world experiments with affordable hardware.

As part of this change, I’ve also created a separate space dedicated exclusively to Apache Kafka, where I’ll continue publishing in-depth posts and sharing practical insights. That Kafka-focused space will be accompanied by its own newsletter, so readers interested in event-driven architectures and streaming platforms can follow that content independently.

What is IgorIOT?

IgorIOT is more than a name; It’s a blend of who I am as a developer and what excites me outside of work.
While “IoT” is in the name (and yes, it also sounds like “I Go Riot”), this blog is not limited to just Internet of Things content. It’s a space where I explore the crossover between my professional experience and personal passions.

In addition to technical content, this blog will also be a place where I share updates and ideas related to my initiative around Java in Education. The goal is to explore how Java can be made more accessible and engaging for students, educators, and coding communities, using modern tools and hands-on approaches. I’ll use this space to document progress, discuss challenges, and highlight community-driven efforts to bring Java closer to learning environments.

With that, my igfasouza blog will be taken offline soon. However, none of the content will be lost. I’ll be saving and maintaining all posts and materials in a GitHub repository. This way, the content will remain accessible, preserved, and open for anyone who wants to explore or reuse it in the future. I’ll share the GitHub link once everything is organized. I’m not sure yet if I’ll go all the way and set up a Hugo site on GitHub for the old blog, but at least the content will be preserved in some form.

Thanks to everyone who has followed and supported the blog over the years!