Forem: IgorIOT

Bringing Java Closer to Education: A Community-Driven Initiative

IgorIOT — Wed, 22 Apr 2026 09:17:35 +0000

Story Horse?

Java has long been one of the most powerful, stable, and widely-used programming languages in the world. Yet when it comes to education, especially for beginners, schools, and coding clubs, it has often been overlooked in favor of languages perceived as simpler or more modern.

That’s changing now.

A new community initiative called the Foojay Java in Education Catalog is working to change perceptions and make high-quality Java learning resources much easier to find and use.

The idea for this project was born from my own desire to give Java the recognition it deserves in the educational space. I started the Java Education Catalog initiative with the goal of creating a central hub for high-quality Java learning resources. Fortunately, the Foojay team loved the vision and fully embraced the idea, turning it into a true community-driven project with great visibility and support from the Java ecosystem.

One Place for All Java Learning Resources

The initiative’s main goal is simple but powerful: bring together Java and education-related materials in one central, easy-to-access place.

Instead of scattered tutorials, videos, books, and tools across the internet, the catalog creates a curated hub where students, teachers, coding club mentors, and self-learners can discover excellent Java educational content.

You can explore the live catalog here:

https://education.foojay.social/

The project is fully open and community-driven. The GitHub repository that powers it is available at:

https://github.com/foojayio/java-education-catalog

Everyone is invited to contribute great resources they know or create.

Challenging Outdated Perceptions

At the same time, this initiative directly addresses some old myths about Java:

Java is no longer slow or overly verbose.
Modern Java is clean, concise, productive, and genuinely enjoyable to write.
It is an excellent language for learning programming fundamentals and object-oriented concepts properly.

The goal is to position Java as a strong, future-proof choice for beginners, not just for enterprise, but for teaching core programming skills that last a lifetime.

Going Beyond the Catalog: Real-World Impact

In parallel with building the catalog, there is active work to bring Java into physical computing and global coding clubs:

Code Clubs and CoderDojo: Efforts are underway to introduce Java as a viable learning path in Code Clubs and CoderDojo communities worldwide. The aim is to make structured, high-quality Java materials naturally available to mentors and young learners.
Raspberry Pi: In collaboration with the Pi4J team (the excellent Java library for Raspberry Pi), work is progressing to make the Java experience on the Raspberry Pi as smooth and beginner-friendly as Python. The vision is to lower the barriers so that running Java applications on physical hardware feels seamless.
Astro Pi: The famous Astro Pi program currently sends only Python code to the International Space Station. I’m actively advocating for the inclusion of Java in this program. The dream? Soon we’ll be able to say that Java has been sent to space, and who knows, maybe even Jakarta EE running on the ISS one day.

Why This Matters

Java’s combination of readability, strong typing, vast ecosystem, and long-term stability makes it incredibly valuable for education. By making these resources visible and accessible, we can help more young people, and their teachers, discover the real power and joy of Java from the very beginning of their coding journey.

This is not a top-down project. It belongs to the entire Java community. Whether you’re an educator, developer, content creator, or just someone who loves Java, your contributions are welcome and needed.

Get Involved

Visit the catalog: education.foojay.social
Check the GitHub repository and contribute resources: github.com/foojayio/java-education-catalog
Read the original announcement: Bringing Java Closer to Education

If you believe Java deserves a stronger presence in education, join the movement. Let’s show the next generation that Java is not just enterprise-ready, it’s future-ready, beginner-friendly, and exciting.

Together, we can grow Java where it matters most: at the beginning.

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!