Kevin Farnham10 articles

Now that 2021 is well underway, many prominent Java developers have taken the time to predict what 2021 may bring to the Java universe.

In this post, I arrange these predictions and observations by topic, in essence creating a series of brief panel discussions about each topic area: a sort of mini-Java conference in the form of an article!

A great many developers today are employed working with OpenJDK. If OpenJDK is the background source for your livelihood, you might want to contribute to future development of the OpenJDK.

There are many ways you can do this. In this article I outline 7 possibilities, ranging from minimal work (because you’re too busy to do much, but you’d like to do something) to intensive work (participating on OpenJDK development is everything you want to do, it’s more than a hobby, you want to contribute to the maximum extent possible).

About 7 years ago, I attended a session given by Java Champion Peter Lawrey, leader of Chronical Software, at a JavaOne conference. Since most of my prior development work in the realm of low-latency high-performance was C/C++ software, I was very interested in hearing what Peter might say about how Java addresses this problem.

I caught up with Peter again recently, and asked him some questions about what’s happened since then, and where we are today. Here are my questions and Peter’s responses.

With the invention of Java, James Gosling and friends created a system whereby any code could be run on any machine or operating system that supports a JVM.

All the coding that lets Java (or any other language that can produce Java bytecode) run anywhere is the fact that the JVM itself translates the bytecode into what’s needed for whatever operating system or hardware you’re running on.

Java bytecode is somewhat similar to the Assembly Language utilized by languages like C. Bytecode is a low level instruction set that the JVM executes in order to enact the processing created by the developer with their Java (or any other JVM language) program.

In this article, we see that the time to execute the bytecode for a simple program is a small fraction of the time to compile it using javac.

Everyone who programs in Java, or any of the other languages built on top of the Java Virtual Machine (Scala, Closure, Kotlin, Groovy, Nashorn, Jython, JRuby, et al.) is familiar with the term “bytecode.”

But how many of us understand what JDK bytecode actually is?

The brilliance of the Java Virtual Machine is that it is itself an operating system.

In other words, if you use the JVM as your base platform, you don’t have to worry about numerous “if” statements related to the specifics of hardware and operating systems.

The JVM takes care of all of that for you. Whatever you write, it’s going to run perfectly on any operating system and hardware that supports the Java Virtual Machine.

Looking at the latest TIOBE Programming Community Index, we see that Java has recently surpassed C in the TIOBE ratings index, while Python is holding steady in the third position.

So, why is this the case? Of course, any answer will be speculative, but here’s my answer!

Developers can simply use the Java Virtual Machine as the basis of their new languages and technology. This means that any advances in the JVM will automatically advance the proficiency and efficacy of any program developed in any JVM language. This is why recent developments that increase the performance of the open source OpenJDK are pertinent to the entire spectrum of developers and companies who utilize the Java JVM platform.

Is Java still an ’emerging technology’? Yes. Every advance in creating a better performing JVM will increase the performance of every program ever developed in any JVM language.