It’s no secret that I’m a Java/Scala/Groovy guy. Some people, especially young people, roll their eyes at me when they hear that.

Java is old, inefficient, and dead compared to modern languages, they basically tell me. But is this really the case?

old

Yes, Java’s basic structure and limitations are old-fashioned and rely on the way code was written 20 years ago.

Programming languages don’t just happen. The habits and needs of developers are at the heart of language design, and while language inventors try to incorporate innovation into it, it would be foolish to ignore how people actually use it.

The first milestone in The history of Java can be traced back to 1995, and while the design of some of its base modules seems at least 10 years ahead of time, it is clear that today, 24 years later… It doesn’t seem to be the same thing anymore.

But it’s not just a matter of time. Java has changed a lot over the past decade. Some of these changes may seem irrelevant to Java per se, but they are incredibly important.

For example, cheap memory has made a big difference in the large-scale reintroduction of functional programming in production software. This, in turn, is linked to The Reactive Manifesto.

Cloud computing, which is easy to access and manage, has promoted the concept of microservices models, which have moved to production environments with the advent of containers.

As a result, in the evolution of the microservices model, some programming languages stand out that are well suited for some tasks but mediocre at others.

The world of programming languages is changing further than that. The new challenges posed by big data are spawning new database systems optimized to handle big data, which can ingest vast amounts of data and then analyze it.

In fact, this did not spawn a new language, but an alternative use of a language suited to the task.

Not to mention that artificial intelligence is once again in the ascendant.

But wait a minute…

Today, Python is the gold standard for machine learning, but if you take a quick look at its Wikipedia page, you’ll see that Python predates Java, even going back to 1990!

What about R? This is a common choice in data analysis. The R language began in 1993.

What about JavaScript? Oddly enough, JavaScript emerged in 1995, the same year as Java!

Erlang? In 1986…

Why is Java the only language that nobody says is such a cliche?

Because we have changed, and so have the challenges we face.

For example, Python has always been a great scripting language for writing utilities and data handlers, but it’s not generally considered suitable for bloated enterprise applications.

In general, however, microservices are small programs and data pipes made up of clearly defined functional components.

JavaScript has always been the only solution for dynamic Web pages, but with the proliferation of complex Web applications, it makes sense to bring JavaScript to the server side.

All in all, Java is old-fashioned only because it’s perfect for building bloated monolithic applications with millions of lines of code that require a lot of planning and strict ordering, which is what Java was designed for.

If you try to build an application like this in JavaScript, you’ll quickly realize that “death is not an end, it’s a transformation” (from The Dream Theatre band’s Fatal Tragedy).

Inefficient.

That certainly sounds like it.

I often use the following metaphor to explain Java:

If you need to make a matchbox, first you need 10 tons of wood, build a log cabin, and then little by little whittle the matchbox.

Because Of Java’s emphasis on a formal, rigorous approach to encouraging developers to create proper class hierarchies, developers have to set everything up the right way, even for a very small task, even if they think it’s stupid.

However, this is the problem, as we said above, none of Java’s tasks are easy.

Note that when I say “not easy” I mean not easy to implement, but architecturally it is.

Writing intricate algorithms is a daunting task, and I find it easier to do it in Python.

At this point, it’s clear that we’ve been talking about the same concept over and over again: choosing the right tool.

For a long time, Java is a very common programming language, and is used to solve the problem of various cases of various types, but as time goes by, the changes and challenges, seems more and more obvious Java is not omnipotent, not because it has evolved into a kind of special language, but because of other language more good at dealing with a specific task.

If you want to build a large enterprise platform, there are lots of internals, huge code bases, crazy parallelism, etc.

So Java is still powerful. Wait a minute, is that really true… ?

Java is dead

It may be a little dark, but there’s a good saying: “Don’t be afraid of the future. You won’t live long enough.” Do you feel like laughing…

Java is like a developer: as you age with time, you may not be as clear-headed as you were 10 years ago, but you will become smarter, more stable, and more reliable.

Sure, you can still learn Rust, but you can never do it like someone 10 years younger. You always feel something is wrong.

Java, too, is falling behind in the modernization race, and when new features come along, it feels like they’re finally here after so many twists and turns.

For example, when they first introduced lambdas, your reaction wasn’t: “Wow! Rejoice!” “But more like,” Oh my God, why did it take you so long?”

On the other hand, people don’t realize that Java’s greatest achievement is not the language itself.

A good ecosystem

Another factor that reminds me of Java when planning large-scale software is the Java ecosystem. No matter what you dream of on the Internet, Java provides you with excellent quality libraries.

Think of Spring, Akka, Tomcat, etc. (I could name hundreds). These are not side projects, but remarkable achievements.

I’m not saying other languages can’t do it, but with the push of big business, Java created the prerequisites for this kind of software to survive.

In addition, a good ecosystem takes years to develop, and the time factor is also important. Twenty years is a long time for a Java ecosystem to mature.

Of course, you can find special libraries for multiple languages, but you’ll soon realize that the survival of these libraries depends largely on whether big companies approve of these projects.

For example, it’s easy to find good machine learning libraries for Python, but you can’t deny Google’s role in this. With Facebook’s support, you have react.js (Javascript) to develop great Web applications.

Java’s greatest achievement is the JVM

Aside from the huge ecosystem we mentioned earlier, Java’s biggest achievement is the JVM. While languages may struggle with aging, the JVM seems healthy to me, at least.

Today, one could argue that containerization has weakened the need for JVMS, and in a sense it is true.

The ORIGINAL requirement of the JVM was to allow programs to execute on all operating systems, but containers changed everything, because with the help of containers, we could assume that the operating system could run anywhere, even on paper.

However, the JVM does much more than that. Memory management and garbage collection, security, basic programming libraries, and debugging and checking capabilities — the JVM takes care of all of this and provides us with a safe and comfortable environment.

People often counter me by saying, “But the JVM is very bloated and very slow!” While this is true in terms of memory footprint and boot time, from a performance perspective, a lot has changed over the past 20 years.

We often use common algorithms to make the following comparison:

Python 3 Vs. Java

Node js Vs. Java

Go Vs. Java

Erlang HiPE Vs. Java

While this comparison is unfair to some languages because algorithms are only part of the performance factor, it shows that the JVM is far from dying.

However……

To some extent, I agree that while the JVM is in good shape, Java is struggling to hold its own.

Oracle understands this pattern, and they’re trying to push Java to the top again, and while there may be some unintended consequences, no one can stop the aging process.

However, this is not necessarily a bad thing.

The JVM serves as a platform for creating modern languages that are more efficient. Not many, but some, in all conscience, have been very successful.

That’s the point. The Java juggernaut is not dead, albeit coughing. However, its descendants will continue to carry on its legacy.

Scala. My second heart love. It’s a very powerful language, statically typed, object-oriented, functional programming language. It’s still not widely adopted, but it’s one of the best technologies to invest in right now. Scala is the implementation language of the Play Framework and is often used in conjunction with Akka’s Actor model.

Clojure. A widely accepted lisp-like language known for its power in concurrent computing, which is often used to process large data sets.

Groovy. Dynamic programming scripting language, which I often find very similar to Java. Groovy is widely used for scripting and is the language that supports the Grails framework.

Kotlin. Last on the list, not to say unimportant, JetBrains’ statically typed object-oriented functional programming language is now the go-to tool for Google Android development.

We are not talking about Java extensions. These are entirely new programming languages, but they all borrow from Java, and most importantly they take full advantage of the JVM and The Java ecosystem.

But actually…

The Java programming language is not going to die any time soon.

Not only is so much software written in Java, but whether you agree with it or not, it’s still a proven programming language that’s perfect for new projects, despite its flaws.

Of course, the role of Java will change. Where once “all you needed was Java,” it only works in some areas, but it’s still a solid part.

While I’m very interested in Scala, I have to say that Oracle and the community have done a lot to improve Java, and we all enjoy the benefits of these improvements.

While the new features arrived later than we expected, there was nothing to be said for quality.

After all, slow development of programming languages can be a sign of obsolescence or success.

Since people are using your programming language on such a large scale, you have to take all major changes seriously.

Every step you make needs to consider the degree of impact and the way backward compatibility works. No problem should be taken lightly.

conclusion

I’ve been in this field for a long time, so I have reason to believe that I know something about the Java programming language.

In the past 10 years, developments in this area have accelerated, but they have been concentrated in certain areas.

When that happens, you may feel like everything is about to change. These developments make some people too excited and excited, so they go around Shouting.

But when the noise is over, you can clearly see the true nature of these developments and make the best of them.

As I said above, Java is still Java, but frankly, all the glory that Java has managed to achieve over the years has yet to be matched.

I want to say to all of you — young and old, whether you love Java or hate it: Enjoy the diversity of this wonderful age of technology!