Java Was My First Programming Language

Java was never supposed to be my passion. It was a required subject — one of those mandatory classes most students treat as a checkbox. But Java turned out to be the hardest and most important programming teacher I ever had. The strictness that frustrated me then is the discipline that makes me a better engineer now.

The First Encounter

I remember opening the Java textbook for the first time and seeing this:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

My first thought: why does printing "Hello World" require this much ceremony? In school, we were expected to just memorize the structure. But I couldn't — I needed to know what public, static, void, main, and String[] args actually meant.

That question kept me up for days. Not out of frustration, but genuine fascination. Why did someone design it this way?

OOP: Confusing, Then Liberating

Object-Oriented Programming felt completely alien at first. The idea of a "blueprint" (class) that you instantiate into an "object" made no sense until I connected it to the real world.

The breakthrough: I thought about my bicycle. The Bicycle class was the concept — it has wheels, a frame, pedals, brakes. My actual bicycle was an instance of that class. That mental model unlocked everything.

class Bicycle {
    int speed;
    String color;

    Bicycle(int speed, String color) {
        this.speed = speed;
        this.color = color;
    }

    void ride() {
        System.out.println("Riding at " + speed + " km/h");
    }
}

Bicycle myBike = new Bicycle(25, "black");
myBike.ride();

Once I understood this, inheritance made sense. A MountainBike extends Bicycle. Polymorphism made sense. A function that accepts a Bicycle works for any subtype. The whole OOP edifice clicked into place from one concrete analogy.

The First Working Program

I built a simple student grade calculator — reading marks, computing averages, displaying results. When it ran for the first time and printed the right output, I felt something shift. I had told a machine what to do, and it did it exactly.

That feeling — the first working program — is something every developer knows. It's why we keep building. I first felt it in Java.

How Java Made Me a Better Programmer

Java is strict. It forces type declarations. It demands explicit exception handling. It throws compile-time errors before you can even run the code. At the time, this felt like punishment. Looking back, it was training.

• Type safety — thinking in types made me careful about data. I started asking: what is this variable actually holding?
• Exception handling — try/catch blocks taught me that programs fail and you need to handle failure gracefully, not ignore it.
• Structure — Java forces organization into classes. This discipline becomes instinct rather than effort.
• Compile errors — catching bugs before runtime is a habit. Java instilled this early and permanently.

"Java was strict the way a good coach is strict — not to punish you, but to build the discipline that makes everything easier later."

Java → Python: The Transition

When I moved to Python for AI/ML work, the transition was smooth because of Java's foundation. Python's dynamic typing and brevity felt freeing rather than dangerous because I understood what was happening underneath. I knew what types were even when Python didn't enforce them.

When I write Python now, I think in Java's terms at some level — I think about data structures, object relationships, and failure modes, even if Python doesn't force me to. That discipline is what Java installed.

The engineers who struggle most with Python are those who learned Python first and never had to think about types. They write code that works on the happy path and breaks badly on edge cases. Java prevents that from being your default.

What I'd Tell Someone Starting with Java Today

Don't skip the verbosity. When you're tempted to memorize the boilerplate and move on, resist. Ask why each line exists. Understand public, static, and void individually before accepting them as ritual.

Java's slowness at the beginning is the point. It's teaching you to think before you type. That habit — thinking deliberately before acting — will serve you in every language you ever learn after.