Imagine a bacon-wrapped Ferrari. Still not better than our free technical reports.
See all our reports

10 Reasons Why Java Rocks More Than Ever: Part 10 – Maturity With Innovation

Air_yoda

Well, we’ve reached the end of the “10 Reasons Why Java Rocks More Than Ever” series. It’s been an interesting ride for me; even though I wrote down the ten reasons many months ago, each blog post made me discover interesting additional implications. Some that I never pondered on before and wasn’t really aware of until I sat down to write about it.

What are your thoughts on this series? Did I miss an important reason? Did I get something wrong? Is one of those reasons actually not great at all? Please reach out, even if it’s just to be the devil’s advocate. We’re planning to mold these blog posts into a report and contrasting views will make this into a much more interesting read. This is an ideal opportunity to be part of our unique RebelLabs reports and maybe even become a regular contributor!

For the last time, these are my top 10 favorite things about the Java platform:

Not Your Granny’s Platform

Maturity never sounds glorious nor exciting; why would it when it instinctively makes you think of outdated, slow and wrinkled? In my book though, maturity in a programming language means something entirely different. It means that I can rely on it without surprises, it means that I know exactly what I can expect, and … most importantly, it means that I can use it to build a product as a team without risking to step on each others’ feet.

The availability of intelligent IDEs, a backwards compatible platform, a massive core API, a vibrant open-source community, and a language that was designed for readability and encapsulation, makes Java perfect for teamwork. It allows code to survive individuals and to be passed on to new programmers or colleagues with few surprises. It allows individuals to contribute without making invisible far-reach changes. It allows people to build complex solutions that require a long time to be delivered and will probably be supported for an even longer time.

The last thing that you want when building a house, is for the ground to be unstable or for the foundations to collapse. Similarly for software, it’s important to build with proven technology if you’re creating a product that’s intended to last. Java has proven this maturity as it’s used for the largest enterprise and mission-critical projects on the planet.

Constantly Innovating

Even with this maturity, Java doesn’t rest on its laurels. For almost 20 years now, it’s been improving and adapting, all the while keeping stability and backwards compatibility in mind. Obviously this means that it improves slowly and very carefully, the point though is that it has done so relentlessly.

Today, we’re on the eve of the first stable release of Java 8, which introduces major new innovations to the Java platform. Unless you’ve been living under a rock, you’ve heard about Nashorn, compact profiles, lambdas, default methods, type annotations, and much more. These features dramatically reinvigorate the language and the platform, while making it possible for any existing project to gradually integrate these new capabilities alongside existing code. Java 8 is perfect example of combining maturity with innovation.

Wrapping Up

After ten detailed blog posts and several months of efforts, I feel that Java rocks even more than I thought when I set out this endeavour.

Summarized, it’s the most well-balanced compromise between writing productivity, reading intuitiveness, execution performance, project maintainability, technology evolution, application stability and runtime visibility.

You can reach me on Twitter at @gbevin and @RebelLabs.


Love Geert’s work? Read the rest of his insights below!

Click to continue