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:
- The Java Compiler
- The Core API
- The Java Memory Model
- High-Performance VM
- Intelligent IDEs
- Profiling Tools
- Backwards Compatibility
- Maturity With Innovation
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.
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.
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.
Love Geert’s work? Read the rest of his insights below!