Why I Am Choosing Java in 2025: Enduring Craftsmanship in a Fast-Moving World

Las week I revealed PermaTechHub—the marketplace I’m building for second-hand technology. I mentioned choosing Java and Spring Boot for the backend, a choice that might have raised some eyebrows. Now it’s time to explain why.

The Language That Quietly Endures

When you spend enough time in tech, you start to notice which tools stick around—even as the hype cycles spin faster and faster. My own story with Java goes back to 2005, when I first met it—at a time when it was already being called “obsolete” by some. Yet here we are, twenty years later, and Java is not only still around, but thriving in ways I never expected.

After years of chasing the next big thing in mobile, I realized I was craving something different: craftsmanship, stability, and systems that last. Java isn’t the language that gets the headlines, but it’s the one that keeps the world running—powering banks, logistics, and all the infrastructure that rarely makes the news.

It’s easy to dismiss Java as old or boring, especially when new languages promise to solve all the same problems with half the code. But there’s something profound about a technology that’s been battle-tested for decades and still powers mission-critical systems around the world. That kind of staying power doesn’t happen by accident.

Longevity Through Adaptation

What really stands out to me is Java’s commitment to longevity and adaptation. Backward compatibility isn’t just a feature—it’s a philosophy. The JVM’s “build once, run anywhere” promise still delivers, and the ecosystem is packed with open-source libraries and patterns refined over years. And while the core values have stayed the same, Java itself has changed with the times: new language features, modern frameworks, and a vibrant open-source community have kept it relevant and even exciting.

This is exactly the kind of evolution without abandonment that aligns with permacomputing values. Java doesn’t force you to rewrite your codebase every few years to stay current. Instead, it gives you the tools to build systems that can grow and adapt over time, without throwing away what already works.

A Culture of Craftsmanship

But it’s not just about the tech. The culture of software craftsmanship in the Java community—test-driven development, clean architecture, and a relentless focus on maintainability—aligns perfectly with the kind of engineer I want to become. I’m less interested in frameworks that promise instant results and more in systems that reward patience and clarity.

Sure, I looked at Python, Go, and even Elixir. They’re all great, but for this next chapter, I want a language that will slow me down in the right ways—encouraging careful design, robust testing, and a mindset of stewardship rather than churn.

Beyond the Hype: Java for Modern, Greenfield Projects

Let’s address the elephant in the room: isn’t Java outdated for new projects in 2025? This question reflects one of the most persistent myths in software engineering—that newer languages are inherently better for greenfield work, and that Java is only suitable for maintaining legacy systems.

The reality is far more nuanced. When I evaluated languages for PermaTechHub, I wasn’t choosing between “old” and “new”—I was choosing between different philosophies of software development. Python promises rapid prototyping and flexibility, but that flexibility comes at the cost of type safety and can lead to brittle codebases as projects scale. Go offers simplicity and performance, but its minimalism can feel constraining when you’re trying to model complex business domains. Elixir has a brilliant concurrency model, but the ecosystem—while passionate—is significantly smaller than what you get with the JVM.

Java, by contrast, offers something increasingly rare in modern development: the ability to start simple and scale to complexity without rewriting everything. The same language that lets you build a straightforward REST API also gives you the tools to handle millions of transactions, implement sophisticated domain models, and maintain strict data integrity. That’s not a limitation—it’s a superpower for projects that might grow beyond their initial scope.

The JVM Ecosystem: Not Just Surviving, Thriving

The other misconception is that Java’s ecosystem is somehow stagnant. Nothing could be further from the truth. Spring Boot 3, which I’m using for PermaTechHub, is a modern marvel—it provides sensible defaults and convention-over-configuration, but it doesn’t lock you into patterns that don’t make sense for your domain. Virtual threads (Project Loom) are changing how we think about concurrency. GraalVM offers native compilation for instant startup times. The tooling—from IntelliJ to Maven to JUnit—is mature, well-documented, and battle-tested in ways that newer ecosystems simply can’t match.

This matters more than you might think. When you’re building something complex—a marketplace with authentication, transactions, event-driven architecture, and moderation—you don’t want to be fighting your tools or discovering fundamental limitations halfway through. You want an ecosystem that’s already solved these problems, with patterns you can learn from and libraries you can trust.

And here’s the thing: the Java community has learned from decades of mistakes. Reactive programming, microservices patterns, event sourcing—all of these modern architectural approaches are not only possible in Java, they’re often pioneered or refined there. The language might not be trendy, but it’s at the forefront of how we build distributed systems that actually work in production.

Java and Permacomputing: An Unexpected Alignment

There’s another dimension to this choice that connects to my broader philosophy about computing beyond obsolescence. Java’s commitment to backward compatibility isn’t just a technical curiosity—it’s a form of stewardship that aligns perfectly with permacomputing values.

Think about it: code written for Java 8 still runs on Java 21. That’s nearly a decade of evolution without forced rewrites. In an industry obsessed with “move fast and break things,” Java represents something different: move deliberately and build things that last. The JVM’s philosophy is that your investment in learning, code, and infrastructure should compound over time, not deprecate with every major version.

This matters for projects like PermaTechHub, which is fundamentally about longevity and sustainability. If I’m building a platform that celebrates technology that lasts, shouldn’t my technical foundation embody the same principles? Choosing Java isn’t just about features or performance—it’s about aligning my technical choices with my values. It’s about practicing digital stewardship at every layer of the stack.

The Right Tool for the Right Journey

I’m not saying Java is the best choice for every project—far from it. If I were building a data science pipeline, Python’s ecosystem would be hard to beat. If I needed bare-metal performance for systems programming, Rust or Go would make more sense. If I were exploring cutting-edge functional programming patterns, Elixir or Haskell would be fascinating.

But for what I’m trying to do—build a complex, maintainable backend system while learning production-grade engineering practices—Java hits a sweet spot I didn’t find anywhere else. It gives me the structure to learn good habits, the ecosystem to avoid reinventing wheels, and the longevity to build something that could genuinely last.

Coming from six years of Swift development, I already know what a well-designed, strongly-typed language brings to the table—and Java’s approach feels just right. Static typing that encourages careful domain modeling. Explicit error handling that forces you to confront failure scenarios. Dependency injection and inversion of control as first-class patterns, not afterthoughts. These aren’t new concepts for me, but Java’s mature ecosystem and decades of refinement around these principles make them feel even more natural and powerful. It’s like coming home to familiar values, but with the weight of an entire industry behind them.

Looking Forward: Proving It in Practice

Words are cheap. Over the coming months, as I document the journey of building PermaTechHub, you’ll see whether these principles hold up in practice. Can I actually build a modern, well-architected system with Java? Can I maintain velocity while adapting familiar patterns to a new ecosystem and scale? Can I prove that “boring technology” is actually the most exciting choice for someone who cares about craft?

I think the answer is yes—but I’m ready to be wrong, to adjust course, and to document both the successes and the failures. That’s what this sabbatical is for: honest experimentation, real learning, and building something substantial enough that the lessons matter.