DEV Community: IgorIOT

Pi Lightsaber Lab

IgorIOT — Sun, 10 May 2026 21:27:41 +0000

What’s the crack jack?

Build your own Lightsaber with Raspberry Pi and Java. May the Force (and GPIO) be with you!

A fun Star Wars-inspired project using a bright LED and a transparent straw to simulate a real lightsaber. It also features a blaster shot mode. Fully controlled with Java on a Raspberry Pi.

This blog is an example of how a single simple LED and a bit of creativity can be used to build fun and interesting projects. Beyond the visual effects, these experiments are a great way to introduce basic programming, electronics, and even physics concepts in a playful and engaging way. Projects like this are perfect for educational activities with children, helping them learn through hands-on experience while exploring light, circuits, coding, and creativity at the same time. Happy Start Wars week.

A long time ago, in a workshop not so far away, a simple LED became the beginning of an intergalactic experiment. With a Raspberry Pi, a few lines of Java code, and a bit of imagination, ordinary electronic components can be transformed into glowing sci-fi creations inspired by the worlds of space adventures and futuristic technology. Welcome to Pi Lightsaber Lab, a place where coding, electronics, creativity, and learning come together to bring light into the galaxy.

Materials:

Raspberry Pi (any model)
Bright LED (preferably strong green or red)
Large transparent straw (milkshake size or acrylic tube for light diffusion)
220Ω or 330Ω resistor
Jumper wires and breadboard (optional)
Black tape (optional)

LEDs

3mm and 5mm LEDs are among the most common types used in electronics projects. The numbers refer to the diameter of the LED casing. A 3mm LED is smaller and works well in compact projects or when space is limited, while a 5mm LED is larger, brighter, and easier to notice from a distance. Because of their size and higher light output, 5mm LEDs are often preferred for visual effects, indicators, and beginner-friendly Arduino experiments. Both types work similarly electrically and can be controlled in the same way using Arduino digital or PWM pins. For this example, I used a 5mm LED.

Frosted vs clear LEDs

LEDs are available in both frosted (diffused) and clear versions, and each type produces a different lighting effect. Clear LEDs focus the light in a narrow and intense beam, making them brighter in a specific direction. Frosted LEDs, on the other hand, spread the light more evenly, creating a softer and more uniform glow. For projects such as light blades, ambient effects, or decorative lighting, frosted LEDs are often preferred because they help distribute the light smoothly through transparent materials like acrylic tubes or plastic straws.

In the image above, the top LED is a frosted LED, while the bottom one is a clear LED. The difference between them becomes more noticeable when using the green color, as the frosted LED spreads the light more evenly and creates a softer glow. With the red color, the distinction is less visible because red light naturally diffuses differently and appears softer even in clear LEDs.

Hardware Assembly:

Connect the LED: Long leg (+) to a GPIO pin (e.g., GPIO 17), short leg (-) to GND through the resistor.
Insert the LED into the bottom of the transparent straw. The straw works great as a light diffuser, creating a nice "blade" effect.
Wrap the base with black tape to simulate the hilt.

Project Modes:

Lightsaber Mode: Steady glow with subtle flicker.
Blaster Mode: Rapid bright flashes simulating starship laser fire.

Lightsaber

I zoomed in on the photo to enhance the lighting effect, which creates a visual appearance similar to Kylo Ren’s lightsaber from Star Wars. The intense glow and the light diffusion around the blade help produce a more cinematic and dramatic sci-fi look.

Blaster

Java Code with Pi4J

import com.pi4j.Pi4J;
import com.pi4j.io.gpio.digital.DigitalOutput;
import com.pi4j.io.gpio.digital.DigitalState;
import java.util.concurrent.TimeUnit;

public class PiLightsaber {

    public static void main(String[] args) throws Exception {
        var pi4j = Pi4J.newAutoContext();

        // GPIO 17 (BCM)
        var ledConfig = DigitalOutput.newConfigBuilder(pi4j)
                .id("lightsaber-led")
                .name("Lightsaber LED")
                .address(17)
                .shutdown(DigitalState.LOW)
                .initial(DigitalState.LOW)
                .provider("pigpio-digital-output");

        try (var led = pi4j.create(ledConfig)) {
            System.out.println(" Pi Lightsaber Lab Activated! May the Force be with you.");

            while (true) {
                lightsaberMode(led);

                // Random chance to fire blaster shots
                if (Math.random() > 0.65) {
                    blasterShot(led);
                }

                TimeUnit.MILLISECONDS.sleep(80);
            }
        }
    }

    private static void lightsaberMode(DigitalOutput led) throws InterruptedException {
        led.high();
        TimeUnit.MILLISECONDS.sleep(40 + (int)(Math.random() * 40)); // subtle flicker
        led.low();
        TimeUnit.MILLISECONDS.sleep(8);
    }

    private static void blasterShot(DigitalOutput led) throws InterruptedException {
        System.out.println(" Pew! Pew! Blaster shot fired!");
        for (int i = 0; i < 7; i++) {
            led.high();
            TimeUnit.MILLISECONDS.sleep(35);
            led.low();
            TimeUnit.MILLISECONDS.sleep(25);
        }
    }
}

May your code shine as bright as a lightsaber, and may your creativity travel farther than the stars. Every great maker's journey begins with a single spark, sometimes just one LED, a few lines of code, and the curiosity to build something amazing. Keep experimenting, keep learning, and remember: the force of innovation is always with those who dare to create.

The original idea for this project was not mine. A long time ago, I saw a similar concept on Twitter, and it stayed in my mind as a fun and creative way to combine electronics, light effects, and education. This project is my own interpretation and experiment inspired by that idea. Full credit and inspiration go to Brown Dog Gadgets and their amazing educational maker projects.

What is a Raspberry Pi? A Complete Beginner’s Guide

IgorIOT — Fri, 24 Apr 2026 14:25:46 +0000

How’s the craic?

If you’ve ever heard the term Raspberry Pi and wondered what it actually is, you’re not alone.

Despite the playful name, the Raspberry Pi is a serious piece of technology that has changed how people learn programming, build hardware projects, and explore computing.

I remember the first time I heard the term Raspberry Pi.

I thought it was some weird AI gadget or maybe a tiny Arduino clone and turns out… it’s none of those.

In this guide, you’ll learn what a Raspberry Pi is, how it works, and what you can do with it, even if you’re a complete beginner.

🧠 What is a Raspberry Pi?

A Raspberry Pi is a small, affordable, single-board computer designed to help people learn programming and build digital projects.

It is roughly the size of a credit card but works like a full computer.

You can:

Connect it to a monitor and keyboard
Install an operating system (usually Linux-based)
Run software like a normal PC

👉 In simple terms:

A Raspberry Pi is a tiny computer you can program, modify, and use for electronics projects.

💥 The moment it clicked for me

The first time I powered one on, I expected something limited.
Instead, I got:

a full desktop environment
a terminal
Wi-Fi connectivity
and the ability to SSH into it like a server

And suddenly I realized:

“This isn’t just hardware. This is a playground for engineers.”

⚙️ How Does a Raspberry Pi Work?

A Raspberry Pi includes all the basic components of a computer:

CPU (processor)
RAM (memory)
USB ports
HDMI output
Wi-Fi / Bluetooth (on most models)
Storage via microSD card

Instead of a traditional hard drive, the Raspberry Pi runs its operating system from a microSD card.

Most users install:

Raspberry Pi OS (official system)
Or other Linux distributions

🔌 What is GPIO on Raspberry Pi?

One of the most powerful features of the Raspberry Pi is its GPIO pins (General Purpose Input/Output).

These pins allow you to connect:

LEDs
Sensors
Motors
Buttons

👉 This is what makes Raspberry Pi popular for IoT and electronics projects.

Unlike a normal computer, you can directly interact with physical hardware.

🚀 What Can You Do with a Raspberry Pi?

This is where things get exciting.

A Raspberry Pi can be used for hundreds of projects. Here are the most popular ones:

🏠 Smart Home Projects
📺 Media Center
🌡️ IoT and Sensors
📷 Security Systems
💡 Learning Platform

🧪 Popular Raspberry Pi Models

There are several versions of Raspberry Pi, including:

Raspberry Pi 4 – widely used and powerful
Raspberry Pi 5 – latest generation with better performance
Raspberry Pi Zero – ultra-small and low cost

Each model is suited for different levels of projects.

🧑‍💻 Who Should Use Raspberry Pi?

Raspberry Pi is perfect for:

Beginners learning programming
Students exploring computer science
Engineers building IoT systems
Hobbyists creating DIY electronics projects
Developers experimenting with backend + hardware integration

⚡ Why Raspberry Pi is So Popular

Raspberry Pi has become extremely popular because:

It is very affordable (often under $100)
It has a huge global community
It supports many programming languages
It combines software + hardware learning
It is perfect for real-world experimentation

🔥 First Project You Should Try

If you're starting out, here are simple beginner projects:

Blink an LED using GPIO pins
Build a simple web server
Create a temperature sensor system
Run a basic chatbot or script

These projects help you understand both software and hardware fundamentals.

🏛️ Raspberry Pi Foundation (and what it actually does)

Another common confusion is thinking that the Raspberry Pi Foundation builds only the Raspberry Pi hardware itself. While they are the creators of the Raspberry Pi, their mission goes far beyond manufacturing devices.

The Raspberry Pi Foundation is a UK-based educational charity focused on improving access to computer science education worldwide. Their goal is to help people learn programming, digital skills, and computational thinking — especially students and beginners.

👉 In other words:

The Foundation = education + open-source learning mission
Raspberry Pi = one of the tools they created to support that mission

So while they are closely related, the Foundation is not “just a hardware company” — it is primarily an education-driven organization.

Raspberry Jam community

Raspberry Pi jams are social events held all over the world where people who are interested in Raspberry Pi come together to share their knowledge, learn new things, and meet other Pi enthusiasts. These events are generally attended by teachers, students, enthusiasts, developers, and hobbyists, and are organized either in person or by different organizations. However, I believe the initiative has become somewhat less active or has slowed down in recent years, with fewer events and less visibility compared to its earlier momentum.

Supporting and growing the Raspberry Jam community

A very funny incident that happened to me.
On the day I went to get my second COVID vaccine here in Dublin, the nurse noticed I was wearing a Raspberry Jam t-shirt. She didn’t really understand the reference and said, “Nice shirt—so is that your favorite jam?”

⚙️ Microcomputer vs Microcontroller (and why Raspberry Pi is NOT an Arduino)

One of the most common misconceptions is comparing Raspberry Pi to Arduino.

They are actually very different things.

A Raspberry Pi is a microcomputer, meaning it is essentially a full Linux-based computer. It has a CPU, RAM, storage (via microSD), and can run an operating system, multitask, and execute complex software like databases, web servers, and backend applications.

An Arduino, on the other hand, is a microcontroller. It is designed for very specific, low-level tasks like reading sensors, controlling motors, or blinking LEDs. It does not run an operating system and executes a single program in a loop.

👉 Simple way to think about it:

Raspberry Pi = a small PC
Arduino = a programmable electronic chip for hardware control

This difference is important because Raspberry Pi sits between traditional software engineering and hardware, while Arduino is focused purely on embedded electronics.

👉 In practice, Raspberry Pi is often used for high-level logic, while microcontrollers like Arduino handle real-time hardware control.

Raspberry Pi Pico (the microcontroller side of the ecosystem)

Interestingly, the Raspberry Pi ecosystem also includes a completely different type of device: the Raspberry Pi Pico.

Unlike the standard Raspberry Pi, the Pico is a microcontroller, not a microcomputer.

It is based on the RP2040 chip and is designed for:

low-level hardware control
real-time embedded systems
ultra low-power applications

👉 Key difference:

Raspberry Pi (classic models) = microcomputer (runs Linux, multitasking)
Raspberry Pi Pico = microcontroller (runs a single embedded program)

This means the Pico is actually much closer to an Arduino or ESP32 than it is to a traditional Raspberry Pi.

So within the same ecosystem, you have:

Raspberry Pi → full computer for software + systems
Raspberry Pi Pico → microcontroller for embedded hardware projects

💸 A quick reality check: prices and controversies

One important thing to mention is that Raspberry Pi is no longer as cheap as it used to be. In recent years, global memory (RAM) shortages and supply chain pressures have significantly increased component costs. As a result, many Raspberry Pi models have become noticeably more expensive than their original launch prices.

👉 This means that while Raspberry Pi is still relatively affordable compared to traditional computers, it is no longer the ultra-low-cost device it once was. For some use cases, especially hobby projects, this price increase has pushed people to also consider alternatives like used mini PCs or other SBCs (single-board computers).

Still, despite the price changes, Raspberry Pi remains extremely popular due to its ecosystem, community support, and versatility.

During the COVID-19 pandemic, the project faced controversy due to a global shortage of silicon and electronic components, which significantly limited production and led to a prioritization of corporate and industrial clients over the hobbyist and educational community that had historically supported its growth. This decision sparked criticism, as many saw it as a shift away from the original mission of accessibility and the democratization of technology.

The Raspberry Pi's 15-year reign is quietly ending—here's why

🧠 Final Thoughts

Raspberry Pi is more than just a small computer.

It is a powerful learning tool that bridges the gap between software development and hardware engineering.

Whether you are a beginner or an experienced developer, Raspberry Pi gives you the freedom to experiment, build, and innovate.

The Raspberry Pi isn’t impressive because of its specs. It’s impressive because it removes barriers. It says: “Here’s a full computer. Now go break things and learn.” And honestly? That’s how the best engineers are made.

Links

https://opensource.com/resources/raspberry-pi

https://picockpit.com/raspberry-pi/what-is-a-raspberry-pi-and-what-can-i-do-with-it/

https://www.nextpcb.com/blog/what-is-raspberry-pi-models-features-and-uses

https://all3dp.com/2/what-is-a-raspberry-pi/

https://www.zdnet.com/article/what-is-the-raspberry-pi-4-everything-you-need-to-know-about-the-tiny-low-cost-computer/

https://nordvpn.com/blog/what-is-raspberry-pi/?srsltid=AfmBOoo3sr_06KYMWBUw2QZlvWUqCZ0ErgqPZgmqqS5XlIvRYVb_FBJt

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!