Foojay Today

7 Reasons Why, After 26 Years, Java Still Makes Sense!

March 15, 2022

Java has been and continues to be the most popular language over the last two decades. It has always been in the top 5 in the TIOBE index in terms of popularity. Besides popularity, Java is especially dominant in the enterprise world. 

However, in recent years, with the popularity of microservices and data science, other programming languages, such as Python, have gained in popularity. Some developers may view this as concerning news, as it may indicate the decline of Java, while others would argue differently.

Java Champion Nicolai Parlog contends that the number of people coding increases every year. If we think of it as a cake, then the size of the cake is expanding. Though the Java share may dwindle slightly in the TIOBE index, the overall size of the Java share of the cake continues to increase. So there will always be more Java developers than those moving on to alternatives. 

Now, the question is, still, should we be concerned about any apparent decline? While most java developers don't necessarily find this to be a relevant question, the most pertinent question I would ask is: “Why do they like Java as much as they do in the first place, and especially to those Java developers who have been working with it for over two decades: Why have they stuck with Java for all these many years?”

I asked these questions to many Java developers and there were many and varied answers. For example, Brazilian Java champion Bruno Souza states that the main reasons for him to stick with Java are:

While many others mentioned similar ideas, Java Champion Geertjan Wielenga has shared that he’s stayed with Java, amongst other reasons, because that's where his friends are found. Indeed, that's an excellent reason for sticking with a community and thus with Java itself.

After many discussions with Java developers, combined with my personal experiences with the Java community and platform, I have come up with the following seven key reasons why Java developers still love Java after all these years and want to stick with it in the years to come.

1. Community

Software development is a unique and recent phenomenon in the history of humanity. Unlike others, the full body of knowledge is yet to be established. That's why learning and acquiring skills in this field is more-or-less mentorship-driven. We can read books, but we learn more from our peers, from our fellow developers, and by doing things in a team.

That's why the community plays a vital role in spreading knowledge and helping to build the right skillset. In that regard, the Java community is unique. It is one of the most comprehensively welcoming communities as well: in every major city, you will find a Java user group that helps developers to achieve the skills that are required, voluntarily and for free.

They regularly arrange workshops, technical sessions, and physical/virtual meetups to discuss and learn from each other. They help to distribute resources and solutions, increase networking, and expand Java knowledge globally.

I have been involved with Java user groups for many years. I always get help from the community when I reach out, such as around mentoring, job opportunities, etc. 

You will find a list of Java groups at the following link:  https://dev.java/community/jugs/

To get involved with the community, reach out to your local JUG and everyone will welcome you with a warm heart. 

2. Language and Platform

Java is a type-safe and object-oriented programming language with a high emphasis on readability. We, its developers and its users, spend a significant amount of time in our work reading code. Java being extremely readable allows developers tremendous benefits, e.g., in scaling the team. Often even non-programmers can read Java source code and understand the intention behind a particular portion of the code.

That's one of the reasons why it has had massive attraction in the enterprise software system. Typically, an enterprise produces products on a large scale and their lifecycle in a production system is quite long. The size of the product team is frequently multiplied. Having an expressive and easy-to-read language like Java helps new developers quickly get used to the existing codebase. 

Also, Java is an open-source programming platform with great documentation support, fostering a unique opportunity for developers who want to dig deeper and learn from the source code. It enables anyone to achieve mastery and helps unravel any mysteries that may come with it.  

Furthermore, while Java is an excellent programming language, it isn't limited only to a language. It's a platform that houses and enables a wide range of other languages, e.g., Kotlin, Scala, Groovy, Jython, JRuby, etc. All of these programming languages are interoperable, which means that they can take advantage of the well-known libraries that are already established.

This combination and amalgamation of language and platform features gives the Java platform a unique and robust strength, like none other.

3. More Solved Problems Than Any Other Ecosystem

It's been 26 years since Java was released. Being the dominant programming language and platform, it has solved more problems than any other ecosystem. And that's not an exaggeration: if you search around a problem, more likely someone has already solved it. Stackoverflow alone has more than a million answered questions: https://stackoverflow.com/questions/tagged/java.

Besides that, Java APIs are extensive and extensible. The standard JDK has massive Java packages that solve most of our day-to-day programming problems. However, the standard API isn't the only source: the ecosystem offers more. For example, Jakarta EE has a wide range of specifications and standards to support a comprehensive range of problems for enterprise software development.

One thing we must appreciate here is the fact that we have specifications. Specification allows multiple vendors to implement a particular library with different capabilities—for example, JPA, the Java Persistence API. JPA provides us with a set of interfaces that any vendor can implement. Some of the popular implantations are Hibernate, EclipseLink, and Apache OpenJPA. The benefit is that we can now experiment with multiple implementations and choose the appropriate one for our unique use case.

Even if we have to move from one implementation to another at some point, we can do so without code changes. That's a huge blessing in software development. This is only possible because of a shared adherence to specifications. This gives us the freedom to use whatever we want without thinking about vendor lock-in. Interestingly, this is probably not the case in most other platforms. Usually there is only one implementation available and developers have no options and are bound to use that single implementation.

Here is the list of the Quality Outreach program of free and open source Java libraries that you could learn from and contribute to: https://wiki.openjdk.java.net/display/quality/Quality+Outreach

Besides these standards and libraries, many open source frameworks, such as Spring and particularly, Spring Boot, has made our lives super easy when writing web services. Similarly, many other frameworks, such as Micronaut, Quarkus and Helidon are getting traction, too. There is an immense amount of content on the Web, and books are available on all of these frameworks, making learning easy.

Furthermore, the OpenJDK itself has multiple implementations. Oracle is by no means the only provides of the OpenJDK. Although every OpenJDK provider has its own implementation and unique sauces, if they're doing things right, they're complying with the shared Technology Compatibility Kit (TCK).

Performance may differ from OpenJDK vendor to OpenJDK vendor, but the output remains the same. For example, the default GC of Oracle JDK is G1, which is highly performant. However, if we want to use a commercial GC, such as Azul C4, that's also fine. We can do that without changing our application code. That's a tremendous freedom.

Here's a list of OpenJDK vendors: https://foojay.io/almanac/java-17/ 

4. Stability

Stability is one of the critical aspects of which the Java community is very proud. Whenever a new feature is released, backward compatibility gets the utmost priority. So, even a dusty JAR from the very past, can still be run on the latest OpenJDK distribution.

That unmatched stability is unparalleled in other platforms available out there. It makes the developer's life very comfortable when upgrading their Java version, which involves no code change.

With that stability in mind, many organizations have confidently made Java their primary language, since they have in the back of their minds the fact that their code will run on OpenJDK distributions for many years to come. 

5. Innovation

In contrast to the stability, there is plenty of innovation going on in the Java ecosystem. From Java 9 onwards, there is a new major release every six months, which makes it super easy to add new features to the OpenJDK. Each release comes with a rich set of new features, along with improving the performance of the existing codebase and fixing security issues.

For example, Java 8 reimagines our ways of writing Java code with a functional programming paradigm, with the help of lambda expressions. Likewise, the Streams API, Java DateTime, Optional, new factory methods around Collections, local type inference, text blocks, pattern marching, JShell, and more, are some of the exciting and useful new features that have been added recently to the OpenJDK. Many others are scheduled to be added. These new features make our code more readable, concise, and easier to troubleshoot.

Further into the future, we are going to see Project Loom: the lightweight concurrency model that we hope will change the future Java concurrency. Besides Project Loom, other projects, such as Valhalla, Amber, Panama, and Leydon will make our programming life even more efficient than before. 

6. Tooling

How wealthy a language and a platform are depends highly on its tooling support.

In that sense, Java is probably the richest of all. It has many IDEs and editors to choose from, such as Eclipse, IntelliJ IDEA, Apache NetBeans, Visual Studio Code, and more. These IDEs and editors have a rich set of features, such as code completion and code generation, test runners, debugging tools, refactoring features, version control integration, framework support, that significantly aid developers in reducing bugs and overall development time.

Besides the IDEs and editors, there is a need for build tools and dependency management. Again, Java has many options to choose from, such as Apache Ant, Gradle, Maven, and more. These tools enable us to integrate third-party libraries so quickly that sometimes we don't even feel they are a separate part of the project.

Furthermore, when software goes into production, we need to monitor the system's behaviour constantly, for which we have a well-established toolset, such as JMC, JFR, jstack. Mbeans, and Java Agents. 

7. Employment Opportunities

Now that we covered the technical aspect of the Java ecosystem, the most important reason for sticking to this ecosystem is the simple fact of how widespread Java is.

It is said that there are 12 million Java developers out there in the world. That makes developers readily employable. The side effect of this is that, if you know Java, you will get a job quickly or sooner or later.

Since the language is widespread and can be considered a general purpose approach to programming usable for developing pretty much anything from smart cards to large enterprise data applications, from smartphone applications to probes on Mars, you will always find something interesting to do with Java. Moreover, besides simply getting a job, being a Java developer turns out to be one of the top-paying jobs in the USA.

Conclusion

Knowing all the major points above, the argument around the ongoing success of Java becomes pretty apparent.

As a developer, you will invest your time in a particular technology by learning and being skilled at it. Once you've invested your time, you definitely will get your return of investment, which should not be limited to a year or a few years: it should be for many years to come.

Therefore, you should invest in a reliable, mature, proven portfolio with a rock-solid foundation.

In that respect, Java is clearly an excellent choice, regardless of whether you are a fresh graduate, an intermediate learner, or a seasoned developer. 

Finally, here is a Twitter thread where many well-known Java developers have expressed their views on why they have stuck with Java for the past 26 years. It's worth a read and expresses the enthusiasm underpinning our Java programming language and ecosystem

I hope you, I, and all of us will continue to work and love it and please share any additional insights or reasons you have for being part of the Java ecosystem below.

 

 

 

Topics:

Related Articles

View All
  • Are Java Security Updates Important?

    Recently, I was in discussion with a Java user at a bank about the possibilities of using Azul Platform Core to run a range of applications. 

    Security is a very serious concern when sensitive data is in use, and potentially huge sums of money could be stolen.

    I was, therefore, somewhat taken aback when the user said, “We’re not worried about installing Java updates as our core banking services are behind a firewall.”

    Read More
    Aug 03, 2021
  • Java: Where the Wild Code Isn’t

    In the last several years, the OpenJDK community has made Java significantly safer for users and developers while at the same time making it easier to design, build, and run applications quickly.

    Java users should incorporate several practices to take full benefit from the defenses of the modern JRE.

    Read More
    Oct 17, 2021
  • New Java 17 Features for Improved Security and Serialization

    In December 2020, I wrote the article Serialization and deserialization in Java: explaining the Java deserialize vulnerability about the problems Java has with its custom serialization implementation. The serialization framework is so deeply embedded inside Java that knowing how dangerous some implementation …

    Read More
    Dec 02, 2021

Author(s)

  • A N M Bazlur Rahman

    Bazlur is a Java Champion, a Software Engineer, a JUG leader, a Book Author, and an Editor of InfoQ and Foojay.IO. Bazlur has more than ten years of experience coding ... Learn more

Comments (5)

Your email address will not be published.

Highlight your code snippets using [code lang="language name"] shortcode. Just insert your code between opening and closing tag: [code lang="java"] code [/code]. Or specify another language.

Save my name, email, and website in this browser for the next time I comment.

Niclas Hedhman

I dived into the deep end (bet a new company on it) of Java in late 1996, and did the first prototype on JDK 1.0.3. “Less is More” was the slogan at the time, and I ran two JVMs plus Apache+ajp plus mail server on 32MB RAM. In 1.0.3 the java.net classes were so unreliable that I needed to write my own C/C++ for networking.

In essence; good article.

Correction in “Stability”; JDK 1.0.x didn’t have the `jar` tool, so no jar files exists from JDK 1.0 era. IIRC, it came with JDK 1.1, which was a massive update, in early 1997. And the `javac` 1.0.x (neither did 1.1.0) didn’t always generate code that was according to JVM spec, so .class files from back then MAY work (my oldest Java code stopped working in 1.4 or 1.5) and it didn’t find all syntax errors either, so code from back then doesn’t necessarily compile with modern compilers.

A N M Bazlur Rahman

Thank you for your feedback; I meant to say here that a pretty old jar can be run with modern java. I wanted to stress backward compatibility, which was true for all the distribution in the last decade, right? I’ll fix the article. Thanks again.

Prof Anand Achyutrao Barbind

Thanks for the article. I love working in Java.
I was looking for an extensive review on Java to be discussed with my students.

Kedarnath Tripathy

Really Excellent, Readable drafting for those who they confused of about the strength and versatility of this language. Because in my good sense this language brought such a revolutionary paradigm to the mankind!

OpenJDK Updates, Spring Framework 6.0-M3, Helidon 3.0-M1, JobRunr 5.0-M1 - R4 News

[…] a recent blog post on Foojay.io, Bazlur Rahman, senior software engineer at Contrast Security, discusses the seven […]

Subscribe to foojay updates:

https://foojay.io/feed/
Copied to the clipboard