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

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


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 @ZeroTurnaround.

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

Click to continue

  • DzafarSadik

    These articles are really well written. I would add few things from myself:

    a.) A well established declarative build systems that make building, CI and importing project to IDE a breeze.

    b.) Unit tests are really quick to implement and run in any JVM language

    c.) Superb libraries, many of them well documented and open source. Automatic GC makes it possible to use many external libraries without worrying about memory management: different allocation/deallocation strategies and fragmentation.

    d.) Fast compilation times & JIT that compiles only code that matters during runtime.

    e.) Not only profiling but also monitoring using tools like jconsole and jvisualvm

    f.) Hot code swapping in debug mode allows you to stay focused on coding without recompilation and application restarts. See also DCEVM that allows hot swapping of nearly everything: classes, fields, static fields, methods, …

    g.) Ability to debug local and remote jvm processes. So basically you are able to connect to application located 1000s miles away and see what is wrong.

    h.) Optimization called escape analysis allows JVM to perform stack allocations not only for primitive types but also complex objects of fixed length that don’t escape the scope. It has been enabled by default in java 1.7 and it reduces the number of garbage that goes to eden space (just increases size of application stack). So for example a key used to retrieve a value from a map is allocated on stack. That improves performance in two ways: lower garbage -> lower CPU required for collections & stack allocated objects are kept most often in CPU cache.

    i.) Great modularity that will improve with future releases.

    j.) Standard methods of packaging and deployment (jar, war, ear)

    k.) Easy to port on multiple platforms and architectures: just provide a proper JVM and for some applications native wrapper/bootstrap process.