DEV Community: IgorIOT

Beyond Blink: Understanding PWM with Raspberry Pi and Java

IgorIOT — Thu, 11 Jun 2026 10:06:14 +0000

Alright boss?

In the previous article, we learned how to turn an LED on and off using a Raspberry Pi GPIO pin. We wrote our first Pi4J application, explored digital outputs, and made an LED blink.

But what if we want something in between?

Can an LED be half on?

Can we create smooth fading effects?

Can we control motor speed, fan speed, or even generate analog-like voltages using only digital GPIO pins?

The answer is PWM.

What Is PWM?

PWM stands for Pulse Width Modulation.

Despite the intimidating name, the idea is surprisingly simple:

Instead of changing the voltage, we rapidly switch the GPIO pin between ON and OFF.

If we do this fast enough, the LED appears dimmer or brighter depending on how long it stays ON during each cycle.

The GPIO Problem

A GPIO pin is digital.

It only knows two states:

LOW = 0V
HIGH = 3.3V

There is no built-in way to output:

1.65V
2.1V
0.8V

At least not directly.

So how do we create different brightness levels?

The PWM Trick

Imagine a GPIO pin switching on and off repeatedly.

100% Duty Cycle
████████████████

The signal is always ON.

The LED is fully bright.

50% Duty Cycle
████_████_

The signal spends half of its time ON and half OFF.

The LED appears approximately half as bright.

25% Duty Cycle
██___██___

The LED appears much dimmer.

Duty Cycle

The most important PWM concept is the duty cycle.

It represents the percentage of time the signal remains ON during a complete cycle.

Examples:

Table 01: Duty Cycle

Mathematically:

Duty Cycle = ON Time / Total Period × 100%

Frequency Matters

PWM is defined by two parameters:

Duty Cycle
Frequency

Frequency tells us how many complete cycles occur every second.

For example:

100 Hz

means:

100 cycles per second

If the frequency is too low, visible flickering may occur.

If the frequency is high enough, the LED appears continuously illuminated.

A typical LED application often uses frequencies ranging from a few hundred Hertz to several kilohertz.

Frequency vs Resolution

There is often a trade-off between PWM frequency and PWM resolution.

In many systems:

Higher Frequency
↓
Lower Resolution
or
Higher Resolution
↓
Lower Maximum Frequency

This happens because the hardware has a limited amount of time to represent each PWM cycle.

As frequency increases, fewer timing steps are available.

Understanding this trade-off becomes important in more advanced projects.

Hardware PWM vs Software PWM

Not all PWM signals are generated the same way.

Software PWM

CPU
 ↓
GPIO

The CPU continuously generates the pulses.

Advantages

Works on many GPIO pins
Easy to configure
Flexible for simple projects

Disadvantages

Consumes CPU resources
Less precise timing
Accuracy may decrease at higher frequencies or under heavy system load

Hardware PWM

PWM Controller
       ↓
     GPIO

Dedicated hardware generates the signal.

Advantages

Extremely accurate timing
Minimal CPU usage
Stable frequencies and duty cycles
Ideal for LEDs, motors, audio generation, and other timing-sensitive applications

Disadvantages

Available only on specific GPIO pins
Limited number of hardware PWM channels

Key Difference

The biggest difference is where the PWM signal is generated:

Table 02: Software VS Hardware PWM

For most LED projects, both approaches work well. However, when accuracy, efficiency, or higher frequencies matter, Hardware PWM is usually the preferred choice.

Building the Circuit

The circuit is identical to the one used in the Blink article.

GPIO18
   |
 Resistor
   |
  LED
   |
  GND

GPIO18 is a popular choice because it supports hardware PWM on Raspberry Pi.

PWM with Pi4J

Software PWM

Software PWM works on virtually any GPIO configured as an output.

import com.pi4j.Pi4J;
import com.pi4j.context.Context;
import com.pi4j.io.pwm.Pwm;
import com.pi4j.io.pwm.PwmType;

public class SoftwarePwmExample {

   public static void main(String[] args) throws Exception {

       Context pi4j = Pi4J.newAutoContext();

       var pwmConfig = Pwm.newConfigBuilder(pi4j)
               .id("soft-pwm")
               .name("Software PWM LED")
               .address(18)          // BCM GPIO18
               .pwmType(PwmType.SOFTWARE)
               .provider("pigpio-pwm")
               .initial(0)
               .shutdown(0)
               .build();

       Pwm pwm = pi4j.create(pwmConfig);

       for (int duty = 0; duty <= 100; duty++) {
           pwm.on(duty, 1000);
           Thread.sleep(20);
       }

       pwm.off();
       pi4j.shutdown();
   }
}

What Happens Behind the Scenes?

Java Application
      ↓
      CPU generates PWM pulses
      ↓
     GPIO18

In Software PWM, the CPU is responsible for continuously toggling the GPIO pin on and off according to the configured duty cycle and frequency.

Hardware PWM

Hardware PWM uses the Raspberry Pi's dedicated PWM controller.

import com.pi4j.Pi4J;
import com.pi4j.context.Context;
import com.pi4j.io.pwm.Pwm;
import com.pi4j.io.pwm.PwmType;

public class HardwarePwmExample {

   public static void main(String[] args) throws Exception {

       Context pi4j = Pi4J.newAutoContext();

       var pwmConfig = Pwm.newConfigBuilder(pi4j)
               .id("hw-pwm")
               .name("Hardware PWM LED")
               .address(18)
               .pwmType(PwmType.HARDWARE)
               .provider("pigpio-pwm")
               .initial(0)
               .shutdown(0)
               .build();

       Pwm pwm = pi4j.create(pwmConfig);

       pwm.on(50, 1000);

       Thread.sleep(5000);

       pwm.off();
       pi4j.shutdown();
   }
}

What Happens Behind the Scenes?

Java Application
      ↓
 PWM Hardware Controller
      ↓
     GPIO18

In Hardware PWM, the Raspberry Pi's PWM peripheral generates the signal independently of the CPU.

Once configured, the hardware continues producing precise PWM pulses even if the CPU is busy performing other tasks.

First PWM Example

Let's set the LED to 50% brightness.

pwm.on(50, 1000);

This means:

50% Duty Cycle
1000 Hz Frequency

The LED now appears partially illuminated.

Creating a Fade Effect

One of the most satisfying PWM demonstrations is a smooth fade.

for (int duty = 0; duty <= 100; duty++) {
    pwm.on(duty, 1000);
    Thread.sleep(20);
}

for (int duty = 100; duty >= 0; duty--) {
    pwm.on(duty, 1000);
    Thread.sleep(20);
}

The LED gradually brightens and then fades away.

This effect is often called a breathing LED.

PWM Doesn't Control Brightness. It Controls Energy.

This is a subtle but important distinction.

PWM doesn't directly tell an LED to become dimmer.

Instead, it controls how much energy is delivered to the load over time.

For an LED, that energy becomes perceived brightness.

For a DC motor, it becomes speed.

For a heating element, it becomes temperature.

The same PWM technique is used in all three cases.

Only the result changes.

Every Dimmed LED Is Actually Blinking

This surprises many beginners.

A dim LED is not receiving "half voltage."

It is actually turning completely ON and completely OFF hundreds or thousands of times per second.

When you see a LED at 50% brightness, what is really happening is:

ON
OFF
ON
OFF
ON
OFF

Very fast.
So a more accurate statement would be:

Every dimmed LED is actually blinking. It's just blinking too fast for us to notice.

The LED Is Never Half On

This is one of the most common misconceptions.

The apparent brightness comes from how our eyes perceive the rapid switching.

Persistence of Vision

Human vision is not instantaneous.

Our eyes and brains effectively average fast changes in light.

If the LED switches thousands of times per second, we no longer perceive individual flashes.

Instead, we see a stable brightness level.

This phenomenon is called persistence of vision, and it is one of the reasons PWM works so well for LEDs.

PWM Is a Useful Lie

One of the most interesting ways to think about PWM is as a "useful lie."

The Raspberry Pi never outputs intermediate voltages through PWM.
It only outputs:

0V
or
3.3V

Yet both humans and electronic circuits often behave as if intermediate voltages existed.

PWM tricks our eyes.

PWM tricks filters.

PWM tricks motors.

And that makes it incredibly useful.

Understanding Raspberry Pi GPIO Limitations

When working with PWM on a Raspberry Pi, it's important to remember that GPIO pins were never designed to be power outputs.

They are designed to be control signals.

This distinction explains many of the limitations developers encounter when starting with electronics.

GPIO Pins Are Not Power Supplies

A Raspberry Pi GPIO pin can output:

LOW = 0V

HIGH = 3.3V

However, that does not mean you can power arbitrary devices directly from a GPIO pin.

GPIO pins are intended to provide signals, not significant amounts of current.

Typical use cases include:

LEDs (with resistors)
Logic inputs
Sensors
Transistors
Driver circuits

Not:

Motors
High-power LEDs
Relays
Speakers
Servos

These devices usually require external power and dedicated drivers.

GPIO Pins Operate at 3.3V

Unlike some microcontroller boards, Raspberry Pi GPIOs are not 5V tolerant.

Applying 5V directly to a GPIO pin can permanently damage the processor.

Always verify:

Input Voltage ≤ 3.3V

when connecting external electronics.

Current Limitations

A GPIO pin can source or sink only a limited amount of current.

A common rule of thumb is:

≈16mA per GPIO

≈50mA total across all GPIOs

Always check the latest Raspberry Pi documentation for the exact specifications of your model.

This is why LEDs should always use a resistor.

For example:

GPIO
 |
220Ω
 |
LED
 |
GND

The resistor protects both the LED and the GPIO pin.

PWM Limitations on Raspberry Pi

PWM is powerful, but it has limitations.

Understanding them helps explain why some projects work perfectly while others require additional hardware.

PWM Is Still Digital

This is the most important limitation.

PWM is not true analog output.

Even at 50% duty cycle, the signal remains:

0V
or
3.3V

only.

PWM merely changes the timing.

Some devices are perfectly happy with this.

Others require actual analog voltages.

Not Every GPIO Supports Hardware PWM

One of the most common surprises for beginners.

Many GPIO pins can be used for:

Digital Input
Digital Output

but only a subset support hardware PWM.

For example, GPIO18 is commonly used because it supports hardware PWM functionality.

This means:

GPIO18 ✓
Random GPIO ? Maybe not

Depending on the PWM provider and Raspberry Pi model, available PWM pins may vary.

https://pinout.xyz/pinout/pwm

Limited Hardware PWM Channels

The Raspberry Pi contains a small number of hardware PWM generators.

Conceptually:

PWM Generator #1
PWM Generator #2

Multiple GPIOs may share these generators.

As a result, changing one PWM configuration can sometimes affect another pin using the same channel.

This limitation becomes important in projects involving:

Multiple motors
RGB LED strips
Audio generation
Robotics

PWM Cannot Source Significant Power

A common misconception:

PWM = More Power

Not really.

PWM changes average power delivered to a load.

The GPIO pin itself still has the same current limitations.

For example:

GPIO PWM
   |
Motor

is generally a bad idea.
Instead:

GPIO PWM
   |
Transistor / MOSFET
   |
Motor Power Supply

This allows PWM to control the motor while external circuitry handles the actual power.

Why PWM Is So Efficient

Before PWM became popular, many systems controlled power by wasting energy as heat.

Imagine trying to dim an LED using a variable resistor.

Power
↓
Resistor
↓
Heat

A portion of the energy is simply lost.

PWM works differently.

Power
↓
Load

The signal is either fully ON or fully OFF.

Very little energy is wasted.

This is one of the reasons PWM is found in:

Electric vehicles
Drones
Industrial automation
LED lighting systems
Computer cooling fans
Switching power supplies

Efficiency is one of PWM's greatest strengths.

PWM Is Everywhere

PWM is far more important than controlling LEDs.

The same technique is used in:

Computer cooling fans
DC motor speed control
Servo motors
LED lighting systems
Audio synthesis
Switching power supplies
Industrial automation equipment

Once you understand PWM, you begin seeing it everywhere.

Experiment Time

Try connecting a multimeter to the filtered output.

Set the duty cycle to:

0%
25%
50%
75%
100%

Measure the voltage at each step.

You should observe values close to:

0.0V
0.8V
1.65V
2.5V
3.3V

This simple experiment demonstrates one of the most powerful ideas in electronics:

A digital signal can behave like an analog one.

The Smartphone Camera Experiment

Want to prove that the LED is actually blinking?

Point your smartphone camera at it.

Depending on the PWM frequency, you may see:

Flickering
Rolling bands
Horizontal stripes

The camera sensor often captures the rapid switching that our eyes cannot detect.

It's a simple experiment, but it makes PWM feel much more real.

A Fun Experiment

Try running exactly the same fade effect using both Software PWM and Hardware PWM.

for (int duty = 0; duty <= 100; duty++) {
   pwm.on(duty, 1000);
   Thread.sleep(20);
}

First, configure the PWM instance as:

.pwmType(PwmType.SOFTWARE)

Then run the same code again using:

.pwmType(PwmType.HARDWARE)

At first glance, the LED will appear to behave exactly the same. Both versions will smoothly fade from dark to bright.

So what's the difference?

The answer is hidden behind the scenes.

The magic happens behind the scenes. In Software PWM, Java and the CPU generate every pulse. In Hardware PWM, a dedicated Raspberry Pi peripheral takes over the job and continues generating the signal even while your application is busy doing something else.

This distinction may not be visible when fading a single LED, but it becomes important in more demanding applications such as motor control, audio generation, robotics, or any project that requires precise timing.

A useful way to think about it is:

Software PWM

Java
↓
CPU
↓
GPIO

versus

Hardware PWM

Java
↓
PWM Controller
↓
GPIO

In the first case, the CPU is actively creating every pulse. In the second, the CPU simply configures the PWM controller and lets the hardware handle the rest.

For a simple LED project, both approaches work great. But understanding this difference is an important step toward understanding how embedded systems manage timing, performance, and hardware resources.

Final Thoughts

Blink taught us how to control a GPIO pin.

PWM teaches us how to control perception.

By rapidly switching a digital signal on and off, we can create smooth brightness transitions, control motors, regulate power, and even generate analog-like voltages.

What started as a blinking LED turns out to be one of the most important techniques in modern electronics.

And this is only the beginning.

Links

https://osteele.github.io/pwm-explorer/
https://en.wikipedia.org/wiki/Pulse-width_modulation

LED Blink: Hello World

IgorIOT — Tue, 09 Jun 2026 11:03:00 +0000

How’s the lad?

Introduction

For decades, software developers have started their journey in a new programming language by writing a simple "Hello, World!" application. In the world of electronics and physical computing, the equivalent tradition is even more visual: making an LED blink.

While it may seem like a simple exercise, blinking an LED introduces some of the most fundamental concepts in embedded development. It demonstrates how software can interact with the physical world by controlling electronic components through the Raspberry Pi's GPIO (General Purpose Input/Output) pins.

For Java developers, this is where Pi4J shines. Pi4J provides a modern and intuitive API that allows Java applications to communicate directly with Raspberry Pi hardware, making it possible to build IoT, automation, robotics, and monitoring projects without leaving the Java ecosystem.

In this tutorial, we'll build our first Pi4J application and use it to control an LED connected to a Raspberry Pi. Along the way, you'll learn the basics of GPIO programming, understand how digital outputs work, and see how straightforward hardware control can be when using Java.

By the end of this guide, you will be able to:

Understand the role of GPIO pins on a Raspberry Pi
Control hardware components from a Java application
Create and configure a Pi4J project
Turn a GPIO pin on and off programmatically
Build your first physical computing project using Java and Pi4J

What You'll Need

Before we start writing code, let's gather the components required for this project.

Hardware

Raspberry Pi
LED
220Ω or 330Ω resistor
Breadboard
Jumper wires

Software

Java Development Kit (JDK)
Maven or Gradle
Pi4J properly configured on your Raspberry Pi

The circuit used in this tutorial is intentionally simple, making it perfect for learning the fundamentals of GPIO programming.

Before writing any code, it's helpful to understand the concept that makes Raspberry Pi hardware control possible: GPIO.

What Is GPIO?

GPIO stands for General Purpose Input/Output.

These programmable pins allow software running on the Raspberry Pi to interact with external hardware components such as:

LEDs
Buttons
Sensors
Relays
Motors

Each GPIO pin can be configured for different purposes depending on the application.

Input vs Output

GPIO pins generally operate in one of two modes:

Input

An input pin reads signals coming from external devices.

Examples:

Detecting a button press
Reading a sensor value
Monitoring a switch state

Output

An output pin sends signals to external devices.

Examples:

Turning on an LED
Activating a relay
Driving a buzzer

In this tutorial, GPIO 17 will be configured as an output pin.

HIGH and LOW States

A digital GPIO output has two possible states:

Table 01: High and Low states

By switching between HIGH and LOW, we can control the LED directly from our Java application.

Creating a Blink Effect

Blinking an LED is simply a matter of repeatedly:

Setting the GPIO pin HIGH
Waiting for a short period
Setting the GPIO pin LOW
Waiting again
Repeating the process

When the application calls led.high(), Pi4J communicates with the underlying Raspberry Pi GPIO subsystem and sets the selected pin to 3.3V. Calling led.low() returns the pin to 0V, turning the LED off.

This simple pattern forms the foundation for many more advanced hardware projects.

GPIO Numbering Explained

One of the most common sources of confusion for beginners is the different numbering schemes used when referring to Raspberry Pi pins. Before connecting any hardware, it's important to understand the distinction between a pin's physical location and its GPIO identifier.

Physical Pins vs GPIO Numbers

The Raspberry Pi header contains 40 physical pins arranged in two rows. These pins are numbered sequentially from 1 to 40 based on their physical position on the board.

However, not all of these pins are GPIO pins. Some provide power (3.3V or 5V), while others provide ground (GND).

GPIO pins are identified using BCM (Broadcom) GPIO numbers, which refer to the numbering used internally by the Raspberry Pi's processor.

For example:

Table 02: Physical pin

In this tutorial, we connect our LED to Physical Pin 11, which corresponds to GPIO 17.

Why This Matters

When reading tutorials or examples online, you may encounter references such as:

create(17)

This does not refer to Physical Pin 17 on the header.

Instead, it refers to GPIO 17 (BCM numbering), which is physically located on Pin 11.

Mixing up these numbering schemes is one of the most common causes of wiring mistakes and can lead to circuits that simply do not work as expected.

A Practical Example

For this project:

The LED is connected to GPIO 17
GPIO 17 is located on Physical Pin 11
The LED's cathode is connected to a GND pin

A common beginner mistake is to connect the LED to Physical Pin 17 because the code references GPIO 17. Physical Pin 17 is actually a 3.3V power pin, not GPIO 17.

BCM Numbering in Pi4J

Pi4J uses the Raspberry Pi's GPIO identifiers rather than the physical header positions. When creating a digital output like this:

var led = pi4j.dout().create(17);

Pi4J configures GPIO 17, not Physical Pin 17.

For this reason, it is highly recommended to keep a Raspberry Pi GPIO pinout diagram nearby while building projects. Once you become familiar with the relationship between physical pins and BCM GPIO numbers, wiring circuits becomes much easier and less error-prone.

Understanding the Circuit

Although our circuit contains only a few components, understanding their purpose is important before we begin programming.

GPIO Connection

In this example, we'll use GPIO 17 as a digital output.

The wiring is straightforward:

Connect GPIO 17 to the resistor.
Connect the resistor to the LED anode (+).
Connect the LED cathode (-) to a GND pin.

When GPIO 17 is set HIGH, the LED will turn on. When it is set LOW, the LED will turn off.

GPIO Safety Tip

Raspberry Pi GPIO pins operate at 3.3V and are not 5V tolerant. Applying more than 3.3V to a GPIO pin can permanently damage the board. Always double-check your wiring before powering the circuit.

Creating the Java Project

With the hardware connected, we're ready to create our first Pi4J application.

Project Structure

This example uses Maven, although Pi4J works equally well with Gradle.

A minimal project structure looks like this:

blink-led/
├── pom.xml
└── src/
    └── main/
        └── java/
            └── com/example/
                └── BlinkLed.java

Adding Pi4J Dependencies

Add the required Pi4J dependencies to your pom.xml:

<dependencies>
    <dependency>
        <groupId>com.pi4j</groupId>
        <artifactId>pi4j-core</artifactId>
        <version>YOUR_PI4J_VERSION</version>
    </dependency>

    <dependency>
        <groupId>com.pi4j</groupId>
        <artifactId>pi4j-plugin-raspberrypi</artifactId>
        <version>YOUR_PI4J_VERSION</version>
    </dependency>

    <dependency>
        <groupId>com.pi4j</groupId>
        <artifactId>pi4j-plugin-pigpio</artifactId>
        <version>YOUR_PI4J_VERSION</version>
    </dependency>
</dependencies>

Writing the Application

Create a new class named BlinkLed.java and add the following code:

public class BlinkLed {

    public static void main(String[] args) throws Exception {

        var pi4j = Pi4J.newAutoContext();

        var led = pi4j.dout().create(17);

        while (true) {
            led.high();
            Thread.sleep(500);

            led.low();
            Thread.sleep(500);
        }
    }
}

Understanding the Code

Creating the Pi4J Context

var pi4j = Pi4J.newAutoContext();

The context initializes Pi4J and loads the required providers for interacting with Raspberry Pi hardware.

Configuring the GPIO Pin

var led = pi4j.dout().create(17);

This creates a digital output attached to GPIO 17.

Turning the LED On

led.high();

Setting the pin HIGH outputs 3.3V and illuminates the LED.

Turning the LED Off

led.low();

Setting the pin LOW removes the voltage and turns the LED off.

Creating a Delay

Thread.sleep(500);

The application pauses for 500 milliseconds.

Repeating the Process

while (true)

The loop continuously alternates between HIGH and LOW states, creating the blinking effect.

Clean Shutdown (Pi4J Best Practice)

Properly shutting down the Pi4J context releases GPIO resources and ensures the application exits cleanly.

Runtime.getRuntime().addShutdownHook(
    new Thread(() -> pi4j.shutdown())
);

Running the Application

Compile the project using Maven:

mvn clean package

Then execute the generated JAR:

java -jar target/blink-led.jar

If everything is connected correctly, the LED should begin blinking at half-second intervals.

Troubleshooting

The LED Does Not Turn On

Check the following:

LED polarity is correct
GPIO 17 is being used
All jumper wires are firmly connected
The resistor is properly placed in the circuit

Permission Errors

If Pi4J cannot access the GPIO hardware:

Verify your Pi4J installation
Ensure the required providers are installed
Confirm the application is running with appropriate permissions

Dependency Issues

If Maven cannot resolve dependencies:

mvn dependency:tree

Verify that all Pi4J artifacts are available and successfully downloaded.

Stay tuned for upcoming Raspberry Pi and Pi4J projects.

You can find the project on GitHub: Pi4J LED Playground

Links

https://pinout.xyz/

Remember to use the hashtag #JavaOnRaspberryPi on Twitter to show the world Raspberry Pi with Java.

The Ultimate Guide to LEDs for Raspberry Pi: Types, Colors, Resistors and Fun Facts

IgorIOT — Sat, 06 Jun 2026 11:14:25 +0000

Story Horse?

LEDs are everywhere.

From the tiny status LEDs on a Raspberry Pi to massive displays in stadiums and modern smart lighting systems, LEDs have completely transformed the way we produce and use light.

If you’re building projects with Raspberry Pi, Java, Pi4J, Arduino, or electronics in general, understanding LEDs is one of the most important skills you can learn.

In this guide, we’ll explore how LEDs work, the different sizes and colors available, SMD LEDs, resistor calculations, brightness ratings, common beginner mistakes, and some fascinating facts about these amazing components.

What is an LED?

LED stands for Light Emitting Diode.

An LED is a semiconductor device that emits light when an electrical current flows through it.

Unlike traditional incandescent bulbs, which generate light by heating a filament, LEDs convert electrical energy into light much more efficiently.

Because of their efficiency, low power consumption, and long lifespan, LEDs are used in countless applications, including:

Raspberry Pi projects
Consumer electronics
Automotive lighting
Home lighting
Traffic signals
Industrial equipment
Digital displays

Picture 01: Led anatomy

For more details

How Does an LED Work?

An LED is a type of diode, meaning it only allows current to flow in one direction.

Every LED has two terminals:

Anode (+) – positive terminal
Cathode (-) – negative terminal

When connected correctly, current flows through the LED and light is produced.

If the LED is connected backwards, it will not light up.

For traditional through-hole LEDs:

The longer leg is usually the anode.
The shorter leg is usually the cathode.
The flat edge on the LED body typically indicates the cathode.

Video 01: How LED Works

Common LED Colors and Forward Voltage

Different LED colors require different forward voltages.

Table 01: Led colors

This is why resistor calculations may differ depending on the LED color you are using.

Picture 02: Led color

Common LED Sizes

The most popular LEDs used by hobbyists are through-hole LEDs.

3 mm LEDs

Small and compact.

Commonly used for:

Status indicators
Small electronic projects
Low-profile designs

5 mm LEDs

The most popular LED size.

Commonly used for:

Raspberry Pi projects
Breadboard circuits
Educational electronics kits

8 mm and 10 mm LEDs

Larger LEDs with greater visibility.

Commonly used for:

Decorative lighting
Signage
High-visibility indicators

The size refers to the diameter of the LED's lens and primarily affects its appearance, viewing angle, and perceived brightness rather than its electrical behavior. Smaller 3 mm LEDs are compact and ideal for indicator lights, while 5 mm LEDs are the most widely used due to their balance of size and visibility. Larger 10 mm LEDs offer increased visibility and are often chosen for projects where the LED needs to be seen from a greater distance. Regardless of size, LEDs should always be used with an appropriate current-limiting resistor, and their electrical specifications should be verified using the manufacturer's datasheet.

Picture 03: Led sizes

LEDs in a variety of shapes

Picture 04: Formats

What Does SMD Mean?

SMD stands for Surface Mount Device.

Unlike traditional LEDs that have wire leads passing through a circuit board, SMD LEDs are soldered directly onto the surface of a PCB.

Because they are smaller and easier to manufacture in large quantities, SMD LEDs are found in nearly every modern electronic device.

You can find SMD LEDs in:

Smartphones
TVs
Computer monitors
Raspberry Pi boards
LED strips
Smart lighting systems

Popular examples include:

3528
5050
2835
5730

The numbers usually represent the physical dimensions of the LED package.

For example:

5050 = 5.0 mm × 5.0 mm
3528 = 3.5 mm × 2.8 mm

Picture 05: SMD

LED Brightness: Lumens, Millicandela and Viewing Angle

One of the most confusing LED specifications for beginners is brightness.

Lumens (lm)

Lumens measure the total amount of visible light produced by a light source.

The higher the lumen rating, the more light the LED produces overall.

Millicandela (mcd)

Millicandela measures light intensity in a specific direction.

A high mcd value does not always mean the LED is brighter overall.

Sometimes it simply means the light is concentrated into a narrow beam.

Viewing Angle

The viewing angle describes how widely the light is distributed.

Table 02: Viewing Angle

A narrow-angle LED often appears brighter because the light is concentrated into a smaller area.

Clear vs Diffused LEDs

In addition to different sizes, LEDs are also available with different lens finishes, the most common being diffused and clear (transparent). Diffused LEDs have a frosted lens that scatters light in multiple directions, producing a softer and more uniform glow that is visible from a wider viewing angle. Clear LEDs, on the other hand, use a transparent lens that focuses the light more directly, often making them appear brighter when viewed head-on. Because of this focused beam, clear LEDs are commonly used when maximum brightness or visibility is desired, while diffused LEDs are often preferred for indicators and projects where an even distribution of light creates a more pleasing visual effect. The choice between the two is usually based on the desired appearance rather than electrical characteristics, as both types are connected and controlled in the same way.

Clear LEDs

Characteristics:

Transparent lens
Focused beam
Higher apparent brightness
Better for long-distance visibility

Diffused LEDs

Characteristics:

Frosted lens
Softer light output
Wider distribution
Better for indicators and decorative projects

For Raspberry Pi projects, diffused LEDs are often easier on the eyes.

RGB LEDs

RGB LEDs combine three colors in a single package:

Red
Green
Blue

By controlling the brightness of each color, thousands of color combinations can be created.

RGB LEDs are commonly used in:

Decorative lighting
Gaming setups
Smart home projects
Raspberry Pi projects

Examples include:

Standard RGB LEDs
WS2812B LEDs
NeoPixels
SK6812 LEDs

Picture 06: Led types

Why Do LEDs Need Resistors?

One of the most common beginner mistakes is connecting an LED directly to a power source.

Without a resistor, too much current can flow through the LED, causing permanent damage.

A resistor limits the current to a safe value.
The resistor value can be calculated using:

R = (Vsupply − Vled) ÷ I

Where:

Vsupply = power source voltage
Vled = LED forward voltage
I = desired current

For example:

Supply Voltage = 5V
Red LED Voltage = 2V
Current = 20mA

Result:

150 Ω resistor

In practice, hobbyists often use:

220 Ω
330 Ω

Both values work well for most Raspberry Pi LED projects.

Picture 07: Resistor

Video 02: LED Circuit Design

ledcalculator

Recommended Resistors for Raspberry Pi

Since Raspberry Pi GPIO pins operate at 3.3V, a 220 Ω resistor is often a safe and simple choice.

Table 03: Resistors

Always verify the specifications of your LED before connecting it.

LED Polarity Tricks

Not sure which side is positive or negative?

Here are some easy ways to identify the cathode:

The shorter leg is usually the cathode
The flat edge indicates the cathode
The larger internal metal piece is usually connected to the cathode

Always double-check before powering a circuit.

Why Do LEDs Come in Different Colors?

Many people assume the color comes from a colored plastic lens.

In reality, the color is determined by the semiconductor material used inside the LED.

Table 04: colors

This is why different LED colors require different forward
voltages.

Infrared and Ultraviolet LEDs

Not all LEDs produce visible light.

Infrared LEDs (IR)

Infrared LEDs emit light outside the visible spectrum.

Common applications:

TV remote controls
Security systems
Motion sensors
Communication devices

Ultraviolet LEDs (UV)

UV LEDs emit ultraviolet light.

Common applications:

Currency validation
Sterilization equipment
Resin curing
Scientific instruments

Connecting Multiple LEDs

When building larger projects, you may need multiple LEDs.

Series Connection

LEDs are connected one after another.

Advantages:

Same current flows through all LEDs
Efficient use of power

Disadvantages:

If one LED fails, the entire chain may stop working

Parallel Connection

LEDs are connected side by side.

Advantages:

Individual LEDs operate independently

Disadvantages:

Current balancing becomes important
Each branch may require its own resistor

For many projects, series connections are preferred when possible.

Picture 08: Series & Parallel

How Much Power Does an LED Consume?

LED power consumption depends on the type of LED.

Table 05: power consume

Modern LEDs are often much more efficient than older designs.

LEDs and Raspberry Pi GPIO Limits

When using LEDs with a Raspberry Pi, it is important to understand GPIO limitations.

GPIO pins:

Operate at 3.3V
Can only provide limited current
Should not drive large loads directly

For larger LED arrays, LED strips, or high-power LEDs, use:

Transistors
MOSFETs
Dedicated drivers

This protects both the Raspberry Pi and your LEDs.

Picture 09: Raspberry PI

Special Types of LEDs

Not all LEDs are simple indicator lights.

Flashing LEDs

These LEDs contain an internal circuit that automatically flashes the light.

Bi-Color LEDs

Contain two colors inside a single package.

Examples:

Red/Green
Red/Yellow

RGB LEDs

Contain three LEDs in one package and can create millions of colors.

Picture 10: RGB

Addressable LEDs

Each LED can be controlled individually.

Examples:

WS2812B
NeoPixel
SK6812

These are perfect for animations and visual effects.

High-Power LEDs

Standard LEDs typically consume around 20mA.

High-power LEDs can operate at:

1W
3W
5W
10W
50W or more

These LEDs often require:

Heat sinks
Constant-current drivers
Thermal management

Applications include:

Floodlights
Automotive lighting
Industrial illumination

The Evolution of LEDs

LED technology has evolved dramatically over the last few decades.

1962

The first practical red LED was developed.

1970s

Yellow and green LEDs became available.

1990s

Efficient blue LEDs were invented.

2000s

White LED lighting became commercially viable.

Today

Smart RGB LEDs, addressable LED strips, and highly efficient lighting systems dominate the market.

LED Applications You Use Every Day

You probably interact with LEDs hundreds of times per day.

LEDs can be found in:

TVs
Monitors
Smartphones
Cars
Traffic lights
Routers
Raspberry Pi boards
Keyboards
Smart watches
Home appliances

Modern life would look very different without LEDs.

LED Myth Busting

Myth: All LEDs Need 20mA

False.

Many modern LEDs operate perfectly at lower currents.

Myth: Bigger LEDs Are Always Brighter

False.

Brightness depends on efficiency, design, and viewing angle.

Myth: LEDs Never Burn Out

False.

LEDs gradually degrade over time and eventually lose brightness.

Fun LED Facts

LEDs Can Last Over 50,000 Hours

A quality LED can operate continuously for years before failing.

Blue LEDs Changed the World

The invention of efficient blue LEDs made modern white LED lighting possible.

This breakthrough earned the inventors the 2014 Nobel Prize in Physics.

Video 03: Why It Was Almost Impossible to Make the Blue LED

LEDs Are Extremely Efficient

Modern LEDs convert much more energy into light than traditional incandescent bulbs.

This results in:

Lower power consumption
Less heat generation
Longer lifespan

LEDs Can Also Detect Light

A little-known fact is that LEDs can act as primitive light sensors under certain conditions.

While not as effective as photodiodes, they can detect changes in light levels.

Common Beginner Mistakes

When starting with LEDs, avoid these common errors:

Connecting LEDs backwards
Forgetting the resistor
Using the wrong resistor value
Exceeding Raspberry Pi GPIO current limits
Miswiring RGB LEDs
Assuming all LEDs have the same voltage requirements

Picture 11: Mistakes

What’s Next?

To help you continue experimenting, all of the code from this tutorial is available as part of the Pi4J LED Playground project, a collection of LED-based examples designed to demonstrate different GPIO concepts and Pi4J features.

The project serves as a hands-on playground where you can explore progressively more advanced scenarios, including different blinking patterns, multiple LEDs, traffic light simulations, animations, and other creative ways of interacting with Raspberry Pi hardware.

Whether you're new to physical computing or looking to deepen your understanding of Pi4J, the playground provides a practical environment for learning through experimentation.

You can find the project on GitHub: Pi4J LED Playground

Feel free to clone the repository, modify the examples, and create your own LED effects. The best way to learn GPIO programming is by experimenting, and this project is designed to be a starting point for exactly that journey.

Stay tuned for the upcoming Pi4J LED Playground project series.

Links

https://en.wikipedia.org/wiki/Light-emitting_diode

https://en.wikipedia.org/wiki/LED_circuit

https://ledcalculator.net/

https://www.digikey.ie/en/resources/conversion-calculators/conversion-calculator-led-series-resistor

https://www.omnicalculator.com/physics/led

https://uk.rs-online.com/web/content/discovery/tools-and-calculators/led-resistor-calculator

Java on Raspberry Pi: Rediscovering Java Beyond the Enterprise

IgorIOT — Tue, 02 Jun 2026 15:41:00 +0000

When most people think about Java, they immediately picture enterprise applications, banking systems, massive backend services, or decades-old corporate software. While Java has earned its reputation in the enterprise world, that is only part of the story.

Today, Java can run on devices as small as a Raspberry Pi, opening the door to hardware projects, edge computing, home automation, education, and hands-on learning experiences.

Combining Java with Raspberry Pi creates a powerful platform for experimentation, learning, and building real-world solutions that go far beyond traditional enterprise development.

Raspberry Pi teaches us about hardware. Java allows us to apply professional software engineering practices to that hardware. Together, they create a powerful platform for learning, prototyping, and building real-world IoT and edge computing solutions.

Java Is More Than Enterprise Software

Java's enterprise success has sometimes created the misconception that it only belongs in large organizations.

In reality, modern Java offers:

Excellent support for Linux and ARM architectures.
High performance and low resource consumption.
Modern frameworks such as Spring Boot, Quarkus, and Micronaut.
Strong support for IoT and edge computing.
Access to hardware through mature libraries.
One of the largest developer ecosystems in the world.

The Raspberry Pi highlights a different side of Java—one focused on creativity, experimentation, and direct interaction with the physical world.

Instead of building another web application, you can build systems that sense, react, and interact with their environment.

Java at the Edge

One of the most exciting technology trends today is Edge Computing.

Traditionally, devices send data to cloud services where processing and decision-making occur. Edge computing shifts part of that processing closer to where the data is generated.

A Raspberry Pi running Java can:

Process sensor data locally.
Apply business rules before sending information to the cloud.
Reduce network traffic.
Lower latency.
Continue operating when connectivity is limited.

Imagine a Raspberry Pi connected to:

Temperature sensors
Cameras
Industrial equipment
Smart home devices
Environmental monitoring systems

Instead of continuously streaming raw data to the cloud, Java applications can analyze, filter, and react locally.

This approach makes systems faster, more efficient, and more resilient.

Reducing Cloud Costs

Cloud platforms provide incredible capabilities, but they are not free.

Many hobby projects, prototypes, educational environments, and even small business solutions do not require cloud infrastructure for every component.

A Raspberry Pi can host:

REST APIs
Local dashboards
MQTT brokers
Databases
Monitoring tools
Automation services

Running these workloads locally can reduce:

Hosting costs
Data transfer costs
Infrastructure complexity

For developers who want to experiment without constantly spinning up cloud resources, a Raspberry Pi becomes an affordable personal server.

A Backup When the Cloud Is Unavailable

Cloud outages are rare, but they happen.

Internet connectivity issues happen even more frequently.

A Raspberry Pi running Java can serve as:

A local cache
A backup processing node
An offline data collector
A temporary synchronization point

In hybrid architectures, edge devices can continue collecting and processing information while disconnected and synchronize once connectivity returns.

This provides a level of resilience that cloud-only solutions often cannot achieve.

Pi4J: Bringing Java to the Physical World

One of the key technologies that makes Java on Raspberry Pi so powerful is Pi4J.

Pi4J is an open-source library that provides a bridge between Java applications and Raspberry Pi hardware.

Without Pi4J, interacting with GPIO pins, sensors, LEDs, buttons, relays, and other hardware components would require significantly more low-level programming.

Pi4J allows Java developers to work with hardware using familiar Java APIs.

For example, a Java application can:

Turn LEDs on and off
Read button presses
Collect data from sensors
Control motors
Interact with displays
Communicate with external electronic devices

All while using standard Java programming practices.

Why Pi4J Matters

Pi4J is important because it removes one of the biggest barriers to hardware development: complexity.

Java developers can focus on solving problems and building applications rather than learning low-level hardware interfaces from scratch.

Pi4J brings several advantages:

Familiar Development Experience

Developers can continue using:

IntelliJ IDEA
Maven
Gradle
JUnit
Spring Boot
Modern Java features

while interacting with physical hardware.

Strong Abstraction Layer

Pi4J hides much of the complexity of GPIO access and hardware communication behind well-designed Java APIs.

Hardware Meets Software Engineering

Many hardware projects start as simple prototypes but eventually grow into larger systems.

Java's strengths in:

Architecture
Testing
Maintainability
Scalability

allow developers to build projects that can evolve from hobby experiments into production-grade solutions.

Understanding Pi4J: The Bridge Between Java and Raspberry Pi Hardware

At its core, Pi4J acts as a bridge between Java applications and the physical hardware available on a Raspberry Pi.

The Raspberry Pi exposes several hardware interfaces such as:

GPIO (General Purpose Input/Output)
I²C
SPI
PWM
UART/Serial

These interfaces are how sensors, LEDs, displays, motors, and other electronic components communicate with the board.

Accessing these interfaces directly from Java would require dealing with low-level Linux APIs, native libraries, memory management, and hardware-specific details. Pi4J abstracts this complexity and provides a modern object-oriented API that feels natural to Java developers.

How Pi4J Works

The architecture is surprisingly elegant.

┌────────────────────┐
│   Java Application │
└──────────┬─────────┘
           │
           ▼
┌────────────────────┐
│       Pi4J API     │
└──────────┬─────────┘
           │
           ▼
┌────────────────────┐
│ Pi4J Providers     │
│ (FFM, LinuxFS, etc)│
└──────────┬─────────┘
           │
           ▼
┌────────────────────┐
│ Linux Kernel / GPIO│
└──────────┬─────────┘
           │
           ▼
┌────────────────────┐
│ Physical Hardware  │
└────────────────────┘

When your Java code changes the state of a GPIO pin, Pi4J translates that request through one of its providers and ultimately interacts with the Linux subsystem controlling the Raspberry Pi hardware. Pi4J supports multiple providers and I/O types, including GPIO, I²C, SPI, PWM, and Serial communication.

The Pi4J Context

One of the key concepts in modern Pi4J is the Context.

Think of it as the runtime environment responsible for:

Managing hardware resources.
Loading providers.
Creating I/O instances.
Cleaning up resources during shutdown.

Most applications start by creating a context:

var pi4j = Pi4J.newAutoContext();

The framework automatically detects the available hardware and loads the appropriate providers.

Learning Through Real-World Projects

One of the biggest challenges when learning software development is making concepts feel tangible.

Many tutorials focus on console applications that print text to the screen.

While useful, they often fail to demonstrate how software interacts with the real world.

With Raspberry Pi and Java, developers can build projects such as:

Smart home systems
Weather stations
Greenhouse monitoring
Security systems
IoT gateways
Robotics controllers
Energy monitoring platforms

Seeing software produce a physical outcome creates a much stronger learning experience.

Java in Education

Java has long been one of the most important programming languages in education.

Many universities teach Java because it introduces students to:

Object-oriented programming
Software design principles
Data structures
Algorithms
Concurrent programming
Large-scale application development

Adding Raspberry Pi to the equation makes Java education even more engaging.

Students can learn programming concepts while simultaneously exploring:

Electronics
Sensors
Networking
Linux
IoT
Distributed systems

Instead of building abstract examples, students can create projects that interact with the physical world.

For educators, this creates opportunities for multidisciplinary learning that combines software engineering with engineering, science, and technology education.

A simple Java program that reads a sensor or controls an LED can often spark more curiosity than a traditional classroom exercise.

Your Personal Learning Lab

Not everyone has access to enterprise environments or expensive infrastructure.

A Raspberry Pi provides:

A real Linux environment
Low power consumption
Low hardware costs
24/7 availability

It can become a personal lab for learning:

Modern Java
Spring Boot
Quarkus
Docker
MQTT
Databases
Monitoring and observability
Edge computing
IoT architectures

All from a device that fits in your hand.

Java Can Be Fun

Perhaps the most overlooked aspect of Java is that it can be fun.

The language is often associated with serious business applications, but there is something uniquely rewarding about writing Java code and seeing a physical device respond.

A few lines of code can:

Turn on a light
Move a motor
Read environmental data
Trigger an alarm
Control a robot

Suddenly, Java is no longer just running in a server rack somewhere—it is interacting with the real world.

And that changes how many developers see the platform.

Conclusion

Java's enterprise roots are a strength, but they do not define its limits.

Running Java on a Raspberry Pi demonstrates how versatile the platform has become. It can power edge computing solutions, reduce cloud costs, provide resilience during outages, serve as an educational platform, and enable exciting hardware projects through libraries like Pi4J.

Most importantly, it reminds us that Java is not only about enterprise systems.

It is also about exploration, experimentation, learning, and building things that interact with the world around us.

Whether you are a student, educator, hobbyist, IoT enthusiast, or experienced software engineer, a Raspberry Pi can help you discover a side of Java that is practical, modern, and surprisingly fun.

Links

https://pimylifeup.com/raspberry-pi-java/

https://raspberrytips.com/java-coding-on-raspberry-pi/

What is a Raspberry Pi HAT?

IgorIOT — Sun, 31 May 2026 11:18:18 +0000

How’s the lad?

Thanks to their GPIO headers, most Pi computers can connect to devices called HATs, which stands for Hardware Attached on Top. HATs are incredible add-ons to the Raspberry Pi that increase its functionality in a huge number of ways.

In short, it’s an additional card that you plug into your Raspberry Pi to bring new features. Generally, it uses the GPIO ports to connect the two cards together. The Raspberry Pi recognizes the HAT thanks to an EEPROM module on the board that identifies the HAT model.
The Raspberry Pi is an awesome platform for learning and experimentation. We can learn to code, build robots, monitor the location of the International Space Station, and so much more. But to make the most of the Pi, it helps to have the right HAT. There are hundreds of extensions that you can find for your Raspberry and there are several manufacturers for these Hats.

What is the HAT Specification?

The HAT (Hardware Attached on Top) specification was introduced by the Raspberry Pi Foundation in 2014 alongside the Raspberry Pi Model B+. Its goal was to create a standard for expansion boards, ensuring that accessories from different manufacturers would work consistently across Raspberry Pi models.
Before the specification existed, expansion boards often required manual configuration and users had to determine which GPIO pins were being used. The HAT standard simplified this process and improved interoperability.

Picture 1: Raspberry Pi Hat

Compatibility and standard

HATs follow an official specification defined by the Raspberry Pi Foundation, which includes:

A fixed GPIO pin layout
An EEPROM chip for automatic identification

This allows many HATs to work in a true “plug and play” manner.

The EEPROM stores information such as:

Manufacturer name
Product name
Product version
GPIO configuration
Device Tree overlays

When the Raspberry Pi boots, it can read this information and automatically configure the hardware.

This enables a much more plug-and-play experience compared to generic GPIO add-ons.

Picture 2: Place the hat on the GPIO pins

Standardized Physical Design

The specification defines:

The location of the 40-pin GPIO connector
Board dimensions
Mounting hole positions
Mechanical clearances

This ensures that HATs fit correctly on compatible Raspberry Pi models.

Hat VS pHat

In the ecosystem of the Raspberry Pi, the difference between a HAT (Hardware Attached on Top) and a pHAT (“partial HAT”) mainly comes down to size and compliance with the official standard. A HAT is a full-sized expansion board that follows the specifications defined by the Raspberry Pi Foundation, including the use of an EEPROM chip for automatic identification and configuration, ensuring plug-and-play compatibility. In contrast, a pHAT is a smaller, more compact board that still connects to the GPIO pins but does not necessarily follow all the official requirements—especially the EEPROM feature. While HATs are typically more standardized and robust for complex applications, pHATs are often simpler, cheaper, and ideal for lightweight or space-constrained projects.

Picture 3: Hat formats

GPIO Usage Declaration

A HAT should clearly declare which GPIO pins it uses.

This helps:

Prevent hardware conflicts
Enable automatic configuration
Improve compatibility with other add-ons

Device Tree Integration

Modern Raspberry Pi systems use Device Tree overlays to describe attached hardware.

A compliant HAT can provide overlay information through its EEPROM, allowing the operating system to automatically load the correct drivers and configuration settings.

For the user, this often means:

Attach the HAT.
Boot the Raspberry Pi.
Start using the hardware.

Without manually editing configuration files.

Power requirements

Not all HATs use the same amount of power:

Some are powered directly by the Raspberry Pi
Others require an external power supply (e.g., motor drivers or large displays)

Software and drivers

Many HATs need specific libraries or drivers
Some are auto-detected, while others require manual setup and configuration

Difference between HATs and generic add-ons

Not every board that fits on top is a true HAT:

A real HAT follows the official standard
Other boards may be referred to as add-ons or expansion boards

Physical limitations

Stacking HATs can block access to ports or connectors
Some projects use stacking headers to allow multiple boards to be used together

Although multiple HATs can sometimes be stacked together using extended headers, conflicts may occur when two boards attempt to use the same GPIO pins, I²C addresses, SPI buses, or power resources. Always check the documentation before combining multiple expansion boards.

Interesting Fact

The EEPROM does not contain the software driver itself. Instead, it stores metadata and configuration information that tells the Raspberry Pi which Device Tree overlay should be loaded and how the GPIO resources should be configured.

Manufacturer list

This is not an exhaustive list.

4tronix
Adafruit
Pimoroni
SparkFun
The Pi Hut
Waveshare

Links

Raspberry Pi HAT+ Specification

Hats

eeptools

The 10 best Raspberry Pi HATs

pinout

Remember to use the hashtag #JavaOnRaspberryPi on Twitter to show the world Raspberry Pi with Java.

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!