Facilitating the Spread of Knowledge and Innovation in Professional Software Development

Write for InfoQ


Choose your language

InfoQ Homepage Articles Java InfoQ Trends Report—September 2020

Java InfoQ Trends Report—September 2020

This item in japanese

Key Takeaways

  • Cloud deployment and containerization is the megatrend in the industry, and Java is no exception.
  • GraalVM and static compilation are key building blocks to the acceleration to the cloud. Project Leyden could be an interesting new direction for this trend, but this is very much in the early stages.
  • Quarkus is attracting a lot of attention and has moved into the Early Adopters space very quickly. Partly, it draws up other trends in the industry and packages them into an easier-to-use version that addresses application use cases.
  • Java 11 adoption has now reached roughly 20% of production deployments, with Java 8 making up virtually the rest of the market—there has been no significant deployment of non-LTS releases.

This article provides a summary of how the InfoQ editorial team currently sees the adoption of technology and emerging trends within the Java space. We focus on Java the language, as well as related languages like Kotlin and Scala, the Java Virtual Machine (JVM), and Java-based frameworks and utilities. We discuss trends in core Java, such as the adoption of new versions of Java, and also the evolution of frameworks (web-based and other) like Quarkus and MicroProfile.

This report has two main aims:

  • To assist technical leaders in making mid- to long-term technology investment decisions.
  • To help individual developers in choosing where to invest their valuable time and resources for learning and skill development.

This is only our second published Java trends report, although the topic has received ample coverage since InfoQ launched in 2006, and we have been tracking Java and JVM trends internally for many years. You can find the 2019 report here.

To help navigate current and future trends at InfoQ (and QCon), we make use of the “crossing the chasm” mental model for technology success pioneered by Geoffrey Moore in his book of the same name.

We try to identify ideas that fit what Moore referred to as the early market, where “the customer base is made up of technology enthusiasts and visionaries who are looking to get ahead of either an opportunity or a looming problem.”

A key market observable for us are ideas that are likely to cross over to broad mainstream adoption. This is, of course, somewhat hard to define, and differences in local markets definitely do exist. A technology may be placed on one point on the adoption curve in one industry or local market, and somewhere quite different in another.

For example, companies that are making an aggressive drive towards serverless and FaaS technologies are likely to be further along in their exploration and adoption of Java static compilation and other technologies that promise to shrink process startup time and footprint.

Notable changes since last year include the sharp decline of the use of Oracle’s Java binaries. This is perhaps to be expected—last year’s change of support and release model hadn’t had time to fully filter into the trends report but we have now had over a full year to assess its impact.

We can now see that the market isn’t choosing to adopt the 6-month upgrade cycle of Oracle’s feature releases. Instead, Java shops are sticking almost completely to LTS releases—which means Java 8 and 11. In turn, this means that because Oracle doesn’t provide zero-cost Java binaries for more than 6 months after release, the market is increasingly turning to non-Oracle providers of binaries—with AdoptOpenJDK the main beneficiary, followed by Azul and Amazon.

The other most noticeable trend is a reflection of an industry-wide megatrend: Almost everything is going cloud faster than before. Adoption in this direction was already strong, but it is now even more pronounced. The unique pressure that Covid-19 has imposed on the industry has doubtless been a factor here.

This can be seen not only by the increased adoption of AWS and other cloud providers but also by the rise of containerized workloads and the desire to have smaller footprint services. This also shows up in the increasing popularity of frameworks such as Quarkus, Micronaut, and Spring Boot. These are all cloud-native and Kubernetes friendly, and all are increasing in popularity, although a clear market leader has yet to emerge.

For context, here is what our internal topic graph looked like for 2019. The 2020 version is at the top of the article.

Contributors to this discussion included:

  • Ben Evans, InfoQ Java track lead editor
  • Uday Tatiraju
  • Erik Costlow
  • Mike Redlich

What follows is a lightly-edited summary of the corresponding discussion between several of the InfoQ Java editors and various Java Champions, which provides more context for our recommended positioning of some of the technologies on the adoption graph.


Justin Lee (Principal Engineer, Red Hat):

I think using GraalVM directly is a pretty high bar for most shops. Using it via Quarkus or Micronaut which handles many of those details is probably the route that most should take.

Johan Vos (Co-founder, Gluon):

We’re leveraging GraalVM native-image in Gluon Substrate to create native apps for mobile and embedded (and desktop, hence Java client in general).

Developers write 100% Java and JavaFX code, and all code, dependencies, native libs, resources are compiled/linked/package in an IPA or APK and can be uploaded to stores (or used in private networks, which is popular in areas where customers want to use Java)—customers use this is production.

On mobile, GraalVM native-image is a big win as it allows use of Java on iOS (which doesn’t allow dynamic code generation). Also, startup time is very important on mobile, and the startup time from apps I’ve seen is amazing.

Roy van Rijn (Director, OpenValue):

We’ve experimented with GraalVM in production (as a native Docker image). This worked quite well for one of our simple CRUD Micronaut services. That’s also where we left it. For bigger services, (using Spring Boot and MQ/messaging), we quickly ran into problems about a year ago. Innovations on this front are moving fast though.

With the new release of Spring GraalVM Native we’re currently adding proofs-of-concept to our backlog to experiment with; our vision at the moment is that we’ll transition all our services into GraalVM Native images eventually. The speed (especially cloud start-up times) and memory usage will be a big saver for us.


Emmanuel Bernard (Distinguished Engineer, Red Hat):

The main usage we see is Quarkus microservices (not toy services, though, so think micro in the focus sense) and some function as a service.

I have seen mainly greenfield, ports of other microservices, or organizations deciding to rethink their app development stack (including being ready to abandon Java if necessary).

What we are seeing too is people taking pieces of legacy apps and adapting the few things required, but Quarkus significantly shields you from the GraalVM native image limitations.

Erik Costlow (Java Editor, InfoQ):

Quarkus has picked up the best parts of Jakarta EE, the best parts of GraalVM, and the best parts of cloud and put them together. The framework has rapid reload, automates container creation for serverless, and connects to plenty of other systems with its plugin ecosystem. On top of that, its documentation is written to clearly describe each plugin, which makes usage easy for greenfield and existing projects.

The thing I like most is that Quarkus offers a solid foundation to let developers focus on aspects that make their code or application distinctive, rather than the technical work of how it interacts with resources. Developers have the right but not the obligation to go deeper.

Java 11

Uday Tatiraju (Tech Lead, Oracle):

During the last 8 months, my team and I redesigned and rewrote our entire search platform leveraging JDK 11 and JPMS. Of course, we had to deal with challenges in using JPMS with 3rd party libraries. We had to work around issues like split packaging, reflection, and unsafe code.

There were a lot of pluses with using JDK 11 though. Using JDK 11 has helped us reduce our 3rd party library dependency. For example, the HTTP client library within the JDK is now pretty ergonomic and feature-rich. In our case, it eliminated our dependency on Apache HTTP client libraries.

We’ve also seen an increase in JDK 11 adoption, at least by other teams within Oracle. Also, many popular 3rd party frameworks and libraries, like Tomcat, ZooKeeper, SLF4J, etc., now support JDK 11 and JPMS.

Ben Evans (Principal Engineer, New Relic & Java Track Lead, InfoQ):

Our recent research from the data our customers send from their production systems shows that (as of now) around 20% of customers are using Java 11 in production, with Java 8 making up the vast majority of the rest of the market. Java 7 and before are around 1-2% and are bigger than all non-LTS releases combined.

Related to this, a pivot to OpenJDK is underway and has been one of the bigger trends we’ve seen this year. AdoptOpenJDK—now renaming to Eclipse Adoptium—is the standout distribution for Java 11 and for OpenJDK generally, and they are taking substantial market share from Oracle.

OpenJDK 11 is a great release, and we’ve been enthusiastically adopting it internally for our backend services.

Brian Vermeer (Developer Advocate, Snyk and Co-leader, VirtualJUG):

In our 2020 JVM ecosystem report - based on an Internet survey of developers - released last February we can clearly see that people are moving towards Java 11 in production with around 25% currently using it. However, it is remarkable that the majority are still using Java 8. The plan for most people (55%) is to stick with long term releases - but 22% of our respondents report that they plan to decide whether or not to upgrade on a release-by-release basis. However, the main reason for developers not to upgrade to newer versions is simple that the current setup works fine for them.

According to our research, although Oracle JDK is still dominant, there is a huge shift towards other OpenJDK providers. 1 in 4 developers chooses an AdoptOpenJDK distribution.

Although Java is still the main language on the JVM by far, the Kotlin adoption grew tremendously. At this point, Koltin is the number 2 language on the JVM overtaking Scala and Clojure. This is probably due to the seamless integration Koltin has with Java.

Trisha Gee (Java Advocacy Team Lead, JetBrains):

I’m definitely seeing an increase in adoption of Java 11 (our survey suggests 10% more than last year, but these are weird percentages since developers are using more than one JVM and so they don’t add up to 100%). All the surveys and anecdotal evidence points to a reasonable chunk of developers using 11.

Other than that, I’d say the Java developers I’m talking to are still firmly in Java-8-land. Many of them can’t move forward because they’re NOT using modern frameworks like Spring Boot, etc., (Spring Boot being by far the most popular framework from the people I speak to), and they’re stuck on some old Application Server that needs “permission from God” to be upgraded (you know the deal). Other non-trends (something you didn’t ask, of course): people aren’t using the module system, or aren’t migrating to it, but again that’s fine in the enterprise world. On the flip side, it seems modularity and Java 9 aren’t standing in the way of migration to 11.


Mike Redlich (Java Editor, InfoQ):

The MicroProfile committers have been working on forming the MicroProfile Working Group with their MicroProfile Specification Process and, as a result, have delayed the release of MicroProfile 4.0 which was originally scheduled to ship this month.

The viewpoints of our contributors only tell part of the story—and different parts of the Java ecosystem and localities may well have very different experiences. The view expressed in our trends piece should be seen as the starting point for debate rather than a definitive statement, and an invitation to an open discussion about the direction the industry is taking.

About the Authors

Ben Evans is a co-founder of jClarity, a JVM performance optimization company. He is an organizer for the LJC (London's JUG) and a member of the JCP Executive Committee, helping define standards for the Java ecosystem. Ben is a Java Champion; 3-time JavaOne Rockstar Speaker; author of "The Well-Grounded Java Developer", the new edition of "Java in a Nutshell" and "Optimizing Java" He is a regular speaker on the Java platform, performance, architecture, concurrency, startups and related topics. Ben is sometimes available for speaking, teaching, writing and consultancy engagements - please contact for details.

Uday Tatiraju is a tech lead and principal engineer at Oracle with over a decade of experience in ecommerce platforms, search engines, backend systems, and web and mobile programming.


Michael Redlich is a Senior Research Technician at ExxonMobil Research & Engineering in Clinton, New Jersey (views are his own) with experience in developing custom scientific laboratory and web applications for the past 30 years. He also has experience as a Technical Support Engineer at Ai-Logix, Inc. (now AudioCodes) where he provided technical support and developed telephony applications for customers. His technical expertise includes object-oriented design and analysis, relational database design and development, computer security, C/C++, Java, Python, and other programming/scripting languages. His latest passions include MicroProfileJakarta EEHelidonMicronaut and MongoDB.

Erik Costlow is a software security expert with extensive Java experience. He manages developer relations for Contrast Security and public Community Edition. Contrast weaves sensors into applications, giving them the ability to detect security threats based on how the application uses its data. Erik was the principal product manager in Oracle focused on security of Java 8, joining at the height of hacks and departing after a two-year absence of zero-day vulnerabilities. During that time, he learned the details of Java at both a corporate/commercial and community level. He also assisted Turbonomic's product management team to achieve $100M annual revenue in data center/cloud performance automation. Erik also lead product management for Fortify static code analyzer, a tool that helps developers find and fix vulnerabilities in custom source code. Erik has also published several developer courses through Packt Publishing on data analysis, statistics, and cryptography.

Rate this Article