TL;DR: A documentary reminded me that Java was the first language that made programming feel like magic — and twenty-five years later, I finally sat down to say thank you.

Generated AI image by Google Gemini Nano Banana

Introduction

A few of my old Java engineering community contacts shared the same link this week: The Java Story, the official documentary tracing thirty-plus years of the language from a secret set-top-box project called “Oak” to the backbone of enterprise computing as we know it today. I didn’t expect it to hit me the way it did. I watched it the way you watch an old family video — a lump in the throat you weren’t prepared for, at footage of people you never met but somehow still feel like you grew up alongside.

Because I was there too, in my own small way. Not in the room at Sun Microsystems, obviously. But in a university computer lab, almost a quarter of a century ago, when Java had just landed in the curriculum and none of us really understood what we were holding. I remember the hum of the CRT monitors, the smell of instant coffee, the quiet thrill of a program finally compiling after an hour of chasing a missing semicolon. That memory has stayed with me longer than most things from that era of my life have any right to.

This post isn’t a tutorial. There’s no code to run, no gotchas to debug. It’s a love letter — to the language that made computer science feel like wonder before it ever became my career, and to the pioneers who are still, three decades on, quietly carrying it forward.

The Language That Made CS Fun

I still remember the exact moment public static void main(String[] args) finally made sense to me — that small, private “oh” of understanding that every engineer chases for the rest of their career and rarely feels as purely as they did the first time. It wasn’t the syntax that hooked me. It was the promise underneath it. Write once, run anywhere. As a student, that idea felt almost rebellious: one program, no matter whose machine you ran it on. Against the fragmented, platform-locked world we’d been taught to expect, Java felt like the future had quietly walked into our lecture hall and sat down beside us.

The documentary does a good job capturing exactly that feeling, straight from the people who built it. Watching James Gosling talk about the language’s origins, or hearing Joshua Bloch explain the thinking behind the Collections Framework, or James Duncan Davidson recount building Tomcat — it took me right back to that lab. These weren’t abstract historical figures to me. They were the reason my textbooks made sense.

What struck me watching it now, as someone who’s spent twenty-plus years in software engineering, is how much of what I do daily still traces back to decisions made in that era. Every time I’ve reasoned about garbage collection, thread safety, or platform independence, I’ve been standing on scaffolding those early engineers built when the industry didn’t yet believe it needed it.

The Road Not (Fully) Taken — Until Now

Here’s the part I’ll be honest about: I didn’t stay purely on the Java path. My career took me through New Zealand freelance work, pre-enterprise Java, .NET apps for small companies, and eventually a genuinely polyglot stretch projects in Australia — Node.js, React, Ruby, Python, TypeScript, Go. Java became one instrument in a much bigger orchestra rather than the only one I played, and for a long time I made peace with that as simply how my story went.

Watching the documentary, though, that peace turned into something more restless — a longing I hadn’t let myself feel in years. There’s a version of this career where I stayed inside the JVM ecosystem the whole way through, rode the “dark ages” of the mid-2010s, and watched Java 8 and lambdas breathe new life into the language from the inside. I’ll never get that exact version of my career back. But sitting with the film, I realised I don’t actually want to mourn that road — I want to walk back onto it, just further down the path than where I left it.

Because here’s the thing the documentary made me see clearly: the person who first fell in love with Java in that university lab had only academic capital to offer it — enthusiasm, curiosity, and a syllabus. The person writing this post has twenty-plus years of career capital instead: real production systems, real incident reviews, real conversations with the people who actually use what gets built. Going back to writing Java now isn’t nostalgia for its own sake. It’s an invitation to build with the language again, but this time with the weight of everything I’ve learned about how software actually gets built and consumed by the people at the other end of it.

A Tribute to the Pioneers

The documentary’s real gift is putting faces and voices to decisions I’ve only ever encountered as design patterns and JEPs. Mark Reinhold and Brian Goetz, still actively steering the language’s evolution at Oracle. Rod Johnson and Gavin King, whose work on Spring and Hibernate quietly reshaped how an entire generation of us structure enterprise applications — architecture I still lean on conceptually today, wherever I’m coding. Kim Polese, Java’s first product manager, whose early bets on the language shaped its market trajectory before most of us had even heard of it.

What I find remarkable, watching it as someone now well into a senior engineering career, is that this isn’t a story about a language that had one good decade and coasted. It’s a story about a community that had every reason to let Java quietly fade during the difficult years — and chose instead to rebuild it, generation after generation, and hand it forward. That’s a harder thing to sustain than a clever initial design. It takes stewardship.

So this is my small, quarter-century-late thank-you note. To the pioneers who made a computer science curriculum feel like an adventure rather than a chore: I hope you have many more years of the success you’ve clearly earned, and I hope the next generation of engineers gets even a fraction of the wonder I felt in that first lab session.

Conclusion

I sat with this documentary expecting a nice hour of nostalgia. What I didn’t expect was to close my laptop afterward and genuinely want to open an IDE and start writing Java again — not as an academic exercise, but as someone who now has two decades of scar tissue and hard-won judgement to bring back to a language I first met with nothing but wide eyes and a syllabus. That’s the quiet gift of watching your origin story told well: it doesn’t just make you remember who you were. It makes you want to become that person again, on purpose, with everything you’ve since learned.

So this isn’t a farewell letter after all. It’s closer to a homecoming.

If you were there too:

1. Watch the documentary if you haven’t (see Youtube thumbnail) — it’s worth the hour and change, and worth having tissues nearby.
2. Go find your old university Java assignments if you still have them. Mine are cringeworthy and I love them.
3. If Java shaped you the way it shaped me, consider this your sign to go build something in it again — not for the syllabus this time, but for everything you’ve learned since.

Here’s to the pioneers, and to every engineer who’s still, in some quiet way, finding their way home to the platform that first taught them to fall in love with building things.

Till next time, Happy Coding! Here’s to being a student for life!