8 Reasons Why JAVA is Still Around in 2024

There are only two kinds of programming languages: the ones people complain about and the ones nobody uses.” — Bjarne Stroustrup.

When I learned Java, the OOP hype was at its height (late 90s), and Java was pretty much the only language actually implementing those concepts (I did learn C++ before, but come on).

I actually liked how Java evolved in the meantime. I did look into Python, but I never got the fever it seems to cause in people; then again, maybe I just didn’t get in deep enough. I’ve worked on really big Java projects, and they handled (reasonably) fine; I can’t imagine Python at that scale.

Then again, newer projects tend to go into the microservice direction — guess Python’s fine for that, but I wouldn’t know. I know Java is. When I learned Java, the OOP hype was at its peak in the late ’90s, and Java stood out as the language actually implementing those concepts (I did learn C++ before, but come on). I appreciated Java’s platform independence.

I prefer structure and consistency over simplicity is my main point for sticking with Java I guess. Throughout my career, I’ve had my fair share of encounters with less-than-ideal Java codebases, and there were times when I found myself getting a bit bored with Java.

THE ECOSYSTEM IS MATURE

Java has been around for more than 25 years. Having been a developer working within this ecosystem, it’s fascinating to reflect on how this ecosystem has matured over the years.

One of the best things about Java’s extensive ecosystem is the wide range of libraries, build tools, and frameworks that I can choose from.

JVM ecosystem is completely spoilt, with best-in-class libraries for almost every problem, all high performance and well maintained. Plenty of choices when it comes to building tools, including Gradle, Maven, and Bazel for fast reproducible builds.

If you’re still new to the ecosystem, Java provides default implementations for various functionalities, such as logging, database connectivity, messaging, and application servers, which is a great starting point.

For instance, let’s say you need logging for your application. No worries, Java has you covered straight out of the box with a default logging option seamlessly integrated into the JDK. What if you don’t like the default option, or it’s not enough? The default logging is just a reference implementation to the logging API. There are other nice logging libraries you can choose from.

And it’s not just logging. The Java ecosystem gives you options for database connectivity, messaging, application servers, servlets, and more.

WRITE ONCE, RUN EVERYWHERE (WORA)

This is a slogan that we often use to refer to the cross-platform benefits of the Java language. Without sounding vindictive here, I know most developers learning Java nowadays may not realize how groundbreaking this feature was to the development of software.

Here is some context. A decade before Java was born, C++ was the predominant programming language. However, one of the challenges developers faced was the platform-dependent nature of C++. Code written in C++ needed to be recompiled and often modified to run on different operating systems or hardware architectures.

BACKWARD COMPATIBILITY

Can you imagine if you had to rewrite code for your program every time there is a new version of Java? That would be very costly and time-consuming, especially for large organizations.

Java has been around for a while, and that means that there exist software products established on older versions of Java and form the backbone of many enterprises, serving essential functions in various sectors.

In enterprise development, where projects are large and complex, migration of such systems to the latest Java versions requires careful planning and execution.

Java’s commitment to backward compatibility is very important as it gives assurance to any developer or organization that has invested a lot into developing a system that it will remain operational and can be maintained without requiring a complete rewrite. Backward compatibility of Java (JVM) also streamlines the migration process, facilitating the adoption of new features and improvements without jeopardizing the stability of existing systems.

JAVA STRONG TYPE SYSTEM

Java is a strongly typed language as opposed to languages such as Python, which are loosely typed. If you have worked with Python, you would immediately feel the flexibility of assigning values of different types to the same variable, and the language would adapt dynamically.

But this flexibility comes at a cost. I remember working on a financial application that dealt with complex calculations involving different numerical data types. With Java’s strong typing, the compiler would flag any attempt to mix incompatible data types or perform operations that could lead to data loss or unexpected results. Some of these obvious bugs might have gone unnoticed with a language such as Python until runtime.

This is one of the reasons why Java is attractive for developing enterprise applications, especially in industries like banking and finance, where reliability and security are important. Apart from reducing runtime errors that you have to deal with, Java’s strong type system improves code readability by making it easier to understand the intended data types of variables, parameters, and return values.

FASTER RELEASE CYCLE — CONSTANT IMPROVEMENTS

Traditionally, as Java developers, we were used to getting new Java features following a major release every few years. However, to keep up with the requirements of modern programming, Java’s release cadence has since changed to only six months after the release of Java 9. However, for enterprise organizations that do not need to jump into new versions, Oracle proposed that it will be releasing an LTS version every three years.

The more frequent, smaller releases reduce the complexity and risk associated with upgrading to a new Java version. Developers are less likely to face major compatibility issues, as the incremental changes are designed to be more backward-compatible.

BEST IDES

Java has come a long way with so many changes and features that make it a great fit for modern development. However, this would only be useful if developers are supported by powerful Integrated Development Environments (IDEs) like IntelliJ IDEA, Eclipse, and NetBeans.

I can’t imagine what it is like writing code in an environment lacking features like intelligent code completion, automated refactoring, seamless version control integration, and many more. However, it is also important to pause and appreciate that this has not always been the case, especially in the early Java days.

Fast forward to modern IDEs like IntelliJ and Eclipse, which have made development in Java a breeze. These IDEs integrate seamlessly with build tools like Maven and Gradle, handling compilation, dependency resolution, and project management. Features like intelligent code completion make Java feel less verbose, built-in static code analysis tools make debugging easier, while access to plugins allows you to customize your environment as you like.

GRAALVM NATIVE IMAGE SUPPORT

We have already discussed how the JVM is a wonderful beast that has propelled Java to glory. But it is also true that the JVM has long been plagued by the perception of slow startup times. This can be very problematic, especially now that almost every developer I know is moving towards microservices, serverless computing, and environments where rapid startup and optimized resource consumption are critical.

Read also:

There have been efforts to lower memory footprints and achieve faster startup times compared to traditional Java applications running on the JVM. One of the solutions that I’m excited about is the GraalVM Native Image technology. Oracle GraalVM is a high-performance JDK that can speed up the performance of Java and JVM-based applications using an alternative just-in-time (JIT) compiler known as the Graal compiler.

GraalVM also includes a native image utility that compiles Java Bytecode ahead of time (AOT), allowing applications to start almost instantaneously. The Graal compiler also works as an AOT compiler, producing native executables. So, the input is Java bytecode, and the output is native executables.

Here is an example of a small Java program that reverses a String using recursion.

You can compile it and build a native image from the Java class.

The native image builder ahead-of-time compiles the Example class into a standalone executable, example, in your current working directory. You can then run the executable.

OPEN SOURCE LIBRARIES AND FRAMEWORKS

Open-source libraries and frameworks stand out as one of the key reasons why Java holds a special place in my toolkit.

These libraries and frameworks are like building blocks I can seamlessly integrate into my projects, sparing you as a developer the need to reinvent the wheel for common functionalities. It’s like having a store of well-written and test code readily available for use.

The sheer volume of these libraries means that I cannot get stuck on one solution. I can always pick one that works best for my needs. The open nature of these libraries encourages transparency and accountability. It also means that I can dive into the source code, understand how things