Java Trends Report 2021-2022

“What will be hot and what to learn in 2022? This article is participating in the” Talk about 2022 Technology Trends “essay campaign.

This article is a translation from the following sources.

By Michael Redlich and Ben Evans
Java Trends Report — December 2021

🤞 personal home page: @Qingcheng sequence member Stone 🤞 fan benefits: plus one to one fan group to answer questions, get free rich resume template, improve learning materials, do a good job in the new era of volume king!

Key Takeaways

Java 11 has reached parity with Java 8 in terms of market share.
Java 11 has reached parity with Java 8 in terms of market share.
Quarkus, introduced after Micronaut and Helidon, continues to be a popular framework and has “crossed the chasm” into the Early Majority space.
Quarkus was introduced after Micronaut and Helidon and is still a popular framework and has “crossed the chasm” into the early majority space.
Containers have broken through and are now the way that the majority of Java applications are deployed.
Containers have broken through, and most Java applications are now deployed this way.
Microsoft furthers its commitment to Java with the release of their own downstream distribution of OpenJDK and having joined the Java Community Process. Microsoft Build of OpenJDK is a new participant in the OpenJDK downstream distribution space.
Microsoft has further strengthened its commitment to Java by releasing its own downstream release, OpenJDK, and joining the Java community process. The Microsoft Build for OpenJDK is a new player in the OpenJDK downstream distribution space.
Spring Framework 6 and Spring Boot 3, scheduled for GA releases in 2022, will be a major overhaul of these projects to adopt modularity. Spring Native has emerged as a new tool to convert existing Spring Boot applications, written in Java or Kotlin, to GraalVM native images.
Spring Framework 6 and Spring Boot 3, scheduled for GA release in 2022, will be significant improvements to the adoption of modularity for these projects. Spring Native has emerged as a new tool for converting existing Spring Boot applications (written in Java or Kotlin) into GraalVM Native images.
MicroStream has emerged as a new participant in the Java ecosystem.
Has become a new player in the Java ecosystem.
After years of stagnation, VS Code is shaking things up in the Java IDE space.
After years of stagnation, VS Code is changing the javaide landscape.

This article provides a summary of how the InfoQ Java editorial team currently sees the adoption of technology and emerging trends within the Java space.

This article summarizes how the InfoQ Java editorial team currently views technology adoption and emerging trends in 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 focus on the Java language and related languages such as 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 such as Jakarta EE, Quarkus, Micronaut, Helidon, MicroProfile and MicroStream.

We discussed trends in core Java, such as the adoption of new versions of Java, and the evolution of frameworks such as Jakarta EE, Quarkus, Micronaut, Helidon, MicroProfile, and MicroStream.

This report has two main goals:

The report has two main objectives:

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

This is our third published Java trends report. However, this topic has received ample news coverage as we have been internally tracking Java and JVM trends since 2006.

This is our third Java Trends report. However, we have been tracking Java and JVM trends internally since 2006, and the topic has been well covered.

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.”

To help guide current and future trends in InfoQ and QCon, we draw on the “crossing the Chasm” mental model of technological success pioneered by Geoffrey Moore in his book of the same name. We try to find ideas that fit into what Moore calls an “early market,” “a market where the customer base is made up of technophiles and visionaries who want to stay ahead of opportunities or looming problems.”

As we have done for the 2020 and 2019 Java trend reports, we present the internal topic graph for 2021:

As we did for our Java Trends reports for 2020 and 2019, we provide an internal theme map for 2021:

For context, here is our internal topic graph for 2020

Below is our internal theme map for 2020

Aside from some new technologies having been identified in the Innovators space, notable changes include: defining versions of Spring (and their related projects), Jakarta EE and Scala into different categories. We decided on this approach to avoid generalizing these technologies into one category when varying degrees of maturity and adoption exist.

In addition to finding some new technologies in the innovation space, notable changes include defining versions of Spring (and related projects), Jakarta EE, and Scala as separate categories. We decided to take this approach to avoid generalizing these technologies into a single category when there are different levels of maturity and adoption.

Spring Framework 6 and Spring Boot 3, scheduled for GA releases in late 2022, will be going through an overhaul to adopt modularity and will require JDK 17+ and Jakarta EE 9. A preview has recently been made available with the first milestone release of Spring Framework 6.

Spring Framework 6 and Spring Boot 3, scheduled for GA releases by the end of 2022, will be overhauled and modularized, and will require JDK 17 + and Jakarta EE 9. Recently, with the release of the first milestone release of Spring Framework 6, a preview version has become available.

Introduced at the beginning of 2021, Spring Native is a new tool to convert existing Spring Boot applications, written in Java or Kotlin, to GraalVM native images and is in the very early stages of development.

Introduced in early 2021, Spring Native is a new tool for converting existing Spring Boot applications (written in Java or Kotlin) into GraalVM Native images and is still in the very early stages of development.

Scala 3, released earlier this year, was overhauled with many new features, new syntax and the much-anticipated new Dotty compiler that has been under development for a number of years.

Scala 3, released earlier this year, was overhauled with a number of new features, new syntax, and the much-anticipated new Dotty compiler, which has been in development for years.

Earlier this year, Microsoft furthered their commitment to the Java programming language when they introduced Microsoft Build of OpenJDK, their own downstream distribution of OpenJDK.

Earlier this year, Microsoft further committed to the Java programming language with their own downstream release of OpenJDK, Microsoft Build.

AdoptOpenJDK joined the Eclipse Foundation and was immediately renamed Adoptium. The transition to Adoptium included the creation of an Eclipse Working Group and a split of AdoptOpenJDK into multiple sub-projects under the Adoptium top level project: Eclipse AQAvit, Eclipse Temurin and Eclipse Temurin Compliance.

Joined the Eclipse Foundation of AdoptOpenJDK and immediately changed its name to Adoptium. The transition to Adoptium involves creating an Eclipse workgroup and splitting the AdoptOpenJDK into multiple subprojects under the Adoptium top-level project: Eclipse AQAvit, Eclipse Temurin and Eclipse Temurin Compliance.

JDK 17

Beckwith: Java is now a more vigorous enforcement of OOP principles via JEP 403: Strongly Encapsulate JDK Internals. Vector computation via a platform-agnostic Vector API. The language additions, such as Records, and JVM improvements, such as project Valhalla, remove many verbosities and further embrace the concept of immutability, thus providing opportunities for performance optimizations.

With JEP403: Strong encapsulation of JDK internals, Java is now a stricter enforcement of OOP principles. Vector computation based on the platform independent Vector API. Added languages, such as Records, and JVM improvements, such as Project Valhalla, eliminated many verbose errors and further embraced the concept of immutability, thus providing opportunities for performance optimization.

Mihalceanu: This year pleasantly surprised Java developers with both LTS and non-LTS Java releases. The Java 17 release was the confirmation that many of those preview features are now generally and long-term available. It also added a sense of urgency for some projects that still run on Java 8 to migrate to a newer version. Java 17 is the LTS that fulfilled the lifelong dream of having helpful NullPointerExceptions.

Mihalceanu: This year likes · One Person Java developers released both LTS and non-LTS Versions of Java. The release of Java 17 confirms that many preview features are now common and available for a long time. This also adds a sense of urgency for some projects still running on Java 8 to migrate to the new version. 17 is the LTS that has realized nullPointerException’s lifelong dream.

Rahman: As always, all parts of the Java ecosystem remain lively. This speaks to the fundamental strength of Java. I think Java SE 17 has been particularly well received, especially features like Records. Runtimes like WildFly, Payara and Open Liberty are adopting Java SE 17. While some developers have adopted Java SE 11, Java SE 8 remains remarkably sticky. It is possible Java SE 17 will finally change that.

Rahman: As always, all parts of the Java ecosystem are still alive and kicking. This illustrates Java’s fundamental advantage. I think Java SE 17 is particularly popular, especially with features like Records. Runtimes like WildFly, Payara, and Open Liberty are adopting Java SE 17. While some developers have adopted Java SE 11, Java SE 8 is still pretty sticky. 17 May finally change that.

Ritter: The release of JDK 17 has been significant. This means developers now have a new long-term support (LTS) release from all the OpenJDK distributions. For those not wishing to upgrade their Java version every six months to remain as stable and secure as possible, this is an important release.

Ritter: The release of JDK 17 is significant. This means that developers now have a new long Term Support (LTS) version from all OpenJDK distributions. This is an important release for users who do not want to upgrade the Java version every six months to remain as stable and secure as possible.

I like the way that we are seeing more small language features added to the platform more quickly than we’ve ever seen before. This is thanks to the six-month release cadence, which also makes both incubator modules and preview features practical.

I like the fact that we are seeing more small language features added to the platform at an unprecedented rate. This is thanks to the six-month release pace, which also makes the incubator module and preview functionality useful.

There are also some interesting developments in how the JVM can work in a cloud environment such as the new project in OpenJDK called co-ordinated restore at checkpoint (CRaC). Features, like records, are great for developing new code.

There are also some interesting developments in how JVMS work in cloud environments, such as a new project in the OpenJDK called Coordinated Restore at Checkpoint (CRaC). Features, such as records, are useful for developing new code.

Evans: The release of Java 17 LTS, and the ability to finally start deploying code that leverages Records and Sealed Types, as well as JFR Streaming for monitoring groups of JVMs. The path towards standardization in the Observability space – especially OpenTelemetry. Early signs of a consensus emerging around what it means for Java to be statically deployed (“Static Java”). I also think Panama will be a bigger deal than people expect.

Evans: The release of Java 17 LTS, and the ability to finally start deploying code that leverages Records and Sealed Types, and the ability of JFR Streaming to monitor JVM groups. Standardized paths to observable space — specifically opentelementtry. Early signs of consensus are emerging about what it means to deploy Java statically (” Static Java “). I also think Panama will be more important than people expect.

Downstream Distributions of OpenJDK

Costlow: There are too many non-differentiated JDK distributions out there now. Microsoft has one, Eclipse has Adoptium with Temurin, Oracle has theirs and an OpenJDK build, Azul, AWS Corretto, Red Hat, Liberica, SAP Machine, etc. I’m seeing a proliferation of these, but it’s hard to keep them straight. Snyk’s survey seemed relatively in line with what I see in terms of usage. Given that they’re all compatible, I’d like to see a “Just get me OpenJDK” randomizer in the marketplace to remove a decision for new junior Java devs. The Eclipse branding in particular is confusing: Adoptium is a group inside Eclipse, which is also a group. Temurin is the thing you use and it is OpenJDK. Imagine learning Java on your own and reading this sentence: “Eclipse Temurin is the name of the OpenJDK distribution from Adoptium.” Fewer brand names is better.

Costlow: There are too many indiscriminate JDK distributions out there. Microsoft has one, Eclipse has Adoptium and Temurin, Oracle has their and OpenJDK builds, Azul, AWS Corretto, Red Hat, Liberica, SAP Machine, etc. I see more and more of these things, but it’s hard to keep track of them. Snecker’s survey seems to be relatively consistent with the usage I’ve seen. Given that they are all compatible, I would like to see a “Just Get Me OpenJDK” randomizer on the market to remove the decision of new junior Java developers. The Eclipse brand is particularly confusing: Adoptium is a group within Eclipse, which is also a group. It’s something you use, OpenJDK. Imagine learning Java and reading this: “Eclipse Temurin is the name of Adoptium’s OpenJDK distribution.” The fewer brands, the better.

Janssen: Liberica, which is from Bellsoft, actually offers quite some interesting products which differentiate them from other JDK vendors. For instance, a full JDK which still contains JavaFX. I only know of ojdkbuild which offers a similar build. Next to that, they have more variants of the JDK and the JRE.

Janssen: Liberica from Bellsoft actually offers some interesting products that set them apart from other JDK vendors. For example, a full JDK still includes JavaFX. All I know is that OjdkBuild provides a similar build. In addition, they have more JDK and JRE variants.

Azul supports non-LTS versions with minor updates for a longer period of time. Some vendors offer Docker images, etc. So there are some differences, but it’s hard for end users to compare them and make a good decision about which one to select.

Azul supports non-LTS versions and small updates over a longer period of time. Some vendors provide Docker images etc. So there are some differences, but it’s hard for the end user to compare them and make a good decision about which one to choose.

Java EE/Jakarta EE

Javaee/Jakarta EE

Rahman: The transition from Java EE to Jakarta EE is one of the largest and most significant technology transfers in our space. That is finally on solid ground with Jakarta EE 9.x. It is very good to see how Jakarta EE 10 is now progressing towards a release early next year. It looks like many of the items in the Jakarta EE Ambassador’s Contribution Guide are materializing, closing some long-standing gaps. I think this is a big relief to long term Java EE users.

Rahman: the transition from javaee to Jakarta EE is one of the biggest and most important technology transfers in our field. Eventually a solid foundation was established with Jakarta EE 9.x. It’s good to see that Jakarta EE 10 is making progress towards a release early next year. It appears that many of the projects in the Jakarta Energy Efficiency Ambassador Contribution Guide are being implemented, closing some long-standing gaps. I think this is a great relief to long-time javaee users.

I am also very happy to see Jakarta EE 9.x building momentum. Most runtimes have adopted the javax to jakarta namespace transition including Tomcat and Jetty. Spring Framework 6 is committed to adopting both Java SE 17 and Jakarta EE 9. Similarly, MicroProfile 5 is transitioning to Jakarta EE. According to the 2021 Jakarta EE Developer Survey, a substantial number of developers have already transitioned to the jakarta namespace or are planning to do so.

I’m also happy to see Jakarta EE 9.x gaining momentum. The javax to Jakarta namespace transformation is used by most runtimes, including Tomcat and Jetty. Spring Framework 6 is dedicated to Java SE 17 and Jakarta EE 9. Also, MicroProfile 5 is transiting to Jakarta EE. According to the Jakarta EE Developer Survey 2021, a significant number of developers have moved or plan to move to the Jakarta namespace.

The Jakarta EE 10 Core Profile is paving the way for Quarkus and Helidon becoming fully compatible, the MicroProfile Config API is transitioning to the new Jakarta Configuration specification and the same is happening with MicroProfile Context Propagation. It is possible the same will happen with the MicroProfile REST Client and JWT Propagation.

10 Core Profile is paving the way for full compatibility between Quarkus and Helidon, and the MicroProfile Config API is transitioning to the new Jakarta Configuration specification, The same is true for propagation of the MicroProfile Context. The same is likely to happen with MicroProfile REST clients and JWT propagation.

Redlich: With the release of Jakarta EE 9, tooling vendors can support the new jakarta package namespace, development teams can test migration of their applications to the new namespace, and runtime vendors can test and deliver options and capabilities that support migration and backwards compatibility with Jakarta EE 8.

Redlich: With the release of Jakarta EE 9, tool vendors can support the new Jakarta package namespace, development teams can test migration of applications to the new namespace, and runtime vendors can test and deliver options and features that support migration and backward compatibility with Jakarta EE 8.

Jakarta EE 9 may also be considered a foundation for innovation to drive new features in Jakarta EE 10 and beyond.

Jakarta EE 9 can also be seen as the foundation for innovation to drive new features in Jakarta EE 10 and beyond.

GraalVM/Spring Native

Mihalceanu: Building a native executable is another topic often marked as “most wanted” as the race for smaller, faster containerized applications continues.

Mihalceanu: As the race for smaller, faster containerized applications continues, building native executables is another topic that is often labeled “most wanted.”

Rahman: It is also very good to see that Spring Native is making progress.

Rachman: It’s also good to see “Springtime Natives” making headway.

Costlow: I like seeing the role of native apps taking shape, but disappointed by the lack of an actual specification or working group. It seems to be kind of “you get whatever GraalVM happens to do” and it behaves differently at times than a standard JDK – similar but not the same.

Costello: I like to see the role of native applications take shape, but I’m disappointed by the lack of an actual specification or working group. It looks a bit like “GraalVM does whatever it happens to do,” and sometimes it behaves differently from the standard JDK — similar but different.

Janssen: Spring Native competes with all the GraalVM and other frameworks with fast startup times and low memory usage.

Competing with GraalVM and other frameworks is Spring Native, with its fast startup and low memory usage.

Silz: Once Spring Boot supports native compilation with GraalVM, fast and small native Java programs will go mainstream. This makes Java more competitive for serverless solutions and may help it in the microservices arena. I say “may” because as of today, I think that the JVM JIT still has better throughput/performance for long-running processes than GraalVM. Either way, that’ll get a lot of press and make Java more competitive overall.

Silz: Once Spring Boot supports native compilation of GraalVM, fast and small native Java programs will become mainstream. This makes Java more competitive in serverless solutions and may help it grow in the microservices space. I say “probably” because so far I think the JVM JITS still have better throughput/performance than GraalVM for long running processes. Either way, this will get a lot of attention and make Java more competitive overall.

ARM64/Windows on ARM

Beckwith: ARM64 is now commodity hardware. As a result, the presence of Java development kits and the Java runtime environments optimized for deployment on ARM64 have gained mainstream popularity.

Arm64 is now commercial hardware. As a result, the emergence of Java development kits and Java runtime environments optimized for deployment on ARM64 has gained mainstream popularity.

Silz: Java 16 supports Windows on ARM. But I think only Java 17 with ARM on macOS will blow the doors wide-open. I believe about a quarter of all Java developers use Macs. And by the end of 2022, they can only buy Macs with ARM. I expect that this will push both Windows and Linux on ARM to get better, too.

16 Supports Windows on ARM. But I think the only way to open the door is to install ARM’s Java17 on macOS. I believe about a quarter of Java developers use the MAC. By the end of 2022, they’ll only be able to buy Macs with ARM. I hope this pushes Windows and Linux on ARM for the better as well.

Jakarta EE and MicroProfile Alignment == Cloud Native for Java

Redlich: The MicroProfile and Jakarta EE Working Groups, two complementary initiatives under the auspices of the Eclipse Foundation, have collaborated to form a Cloud Native for Java (CN4J), an alliance to define Jakarta EE and MicroProfile positioning and alignment, both branding and technical for cloud-native technologies.

Redlich: The MicroProfile and Jakarta EE working group, two complementary projects supported by the Eclipse Foundation, have teamed up to form a Cloud Native for Java (CN4J) for Java, An alliance that defines the positioning and alignment of Jakarta EE and MicroProfile, including brands and technologies for local cloud technology.

Rahman: It is a pleasant surprise to see Quarkus making well-earned headway with both Java EE and Spring developers. It is also very good to see Jakarta EE and MicroProfile alignment finally happening.

Rahman: it was a pleasant surprise to see Quarkus making good progress with javaee and Spring developers. Glad to see the alignment between Jakarta EE and MicroProfile finally implemented.

JavaFX/Gluon

Costlow: I am extremely impressed at the work that Gluon is doing to make a single JavaFX codebase run across everywhere. Web was the missing piece from before and, frankly, client Java now seems cool again.

Costlow: I’m impressed with the work Gluon has done to get the JavaFX code base everywhere. The Web was the missing piece, and frankly, client Java now looks cool again.

Adopting Modularity

Silz: I think that JPMS tries to solve three problems: class loading woes for app servers; better structuring of the JDK and all Java applications; and reducing the JVM footprint for deployment/runtime.

Silz: I think JPMS is trying to solve three problems: application server class loading difficulties; Better building the JDK and all Java applications; And reduce deployment/runtime JVM footprint.

But at least when JPMS finally launched after multiple delays, there were good enough solutions for these problems already: OSGI for class loading; Domain-Driven Design/Clean Architecture/Modulith/ArchUnit tests for Java program structure; and ahead-of-time compilation for reduced JVM footprint.

But at least when JPMS was finally released after many delays, there was a good enough solution to address these issues: OSGI for class loading; Domain-driven design/clean architecture/module /ArchUnit testing for Java program architecture; And precompilation to reduce JVM footprint.

As few unreliable data points we may have, they all show usage of Java 8 and older either being greater than or equal to that of Java 11 and later. I think this is partly because modules gave Java 9+ the reputation of being “hard to upgrade to from Java 8,” as Mark Reinhold acknowledges. That’s an unintended consequence of JPMS. And it means that at least half of all Java developers can’t use the Java advances of the last seven years because they’re stuck on Java 8.

Although we may have some unreliable data points, they all show usage of Java 8 and above greater than or equal to Java 11 and above. I think this is partly because modules have given Java 9+ a reputation as “hard to upgrade from Java 8”, as Mark Reinhold admits. This is an unintended consequence of JPMS. This means that at least half of Java developers cannot use the Java advances of the past seven years because they are stuck with Java 8.

The opportunity cost of working on modules for probably 7+ years means that many other Java improvements either fell to the wayside or only appeared in Java 10 and later. The var keyword for variables, the new switch syntax, and Java records reduce a lot of the boilerplate that Java’s infamous for. If those were in Java 9 instead of Java modules, I think Java would be in a better place now because it had better developer productivity.

The opportunity cost of working on modules for more than 7 years means that many other Java improvements either fall by the wayside or only appear in Java 10 and beyond. The var keyword for variables, the new Switch syntax, and Java documentation eliminate many of Java’s notorious boilerplate files. If these modules were in Java 9 instead of Java modules, I think Java would be in a much better position now because it has better development efficiency.

What Has Changed Since Last Year?

Beckwith: Many architects and developers have tamed the GC (garbage collection) pause times due to the improvements to the existing collectors. Many others have tamed the tail latencies by transitioning to low-latency, adaptive GCs for their workloads.

Beckwith: Many architects and developers have tamed GC pause times due to improvements to existing collectors. Many others have tamed tail latency by transiting to a low-latency, workload adaptive GC.

Evans: Java 11 has essentially reached parity with Java 8 in terms of market share. Containers have broken through and are now the way that the majority of Java apps are deployed. Quarkus continues to mature and gain ground and new fans.

11 has basically reached the same level of market share as java8. Containers have broken the ice, and most Java applications are now deployed this way. Kwakus continues to mature, grow, and attract new fans.

Redlich: A few Eclipse Foundation Working Groups have been established: MicroProfile, OSGi and Adoptium (formerly known as AdoptOpenJDK). The MicroProfile Working Group and the Jakarta EE Working Group have collaborated on a Cloud Native for Java (CN4J) Alliance initiative.

Redlich: Several Eclipse Foundation working groups have been established: MicroProfile, OSGi, and AdoptOpenJDK. The MicroProfile Working Group and the Jakarta Electronic Engineering Working Group have collaborated to develop a consortium initiative for Cloud Native (CN4J) for Java.

Microsoft furthers its commitment to Java by creating its own downstream distribution of OpenJDK, Microsoft Build of OpenJDK, and by joining the Java Community Process.

Microsoft has further strengthened its commitment to Java by creating its own downstream release of OpenJDK, the Microsoft Build of OpenJDK, and joining the Java community process.

What is the Java Community Saying?

Beckwith: Pattern matching for switch statements, native image, cloud native-JVM, and JVM on accelerators, project Loom and Graal.

Beckwith: Pattern matching for switch statements, native images, cloud native JVMS, and JVMS on accelerator, project Loom, and Graal.

Mihalceanu: Upgrading. Because the Java language evolved, framework features flourished as well. In my experience, writing clean and secure code promptly depends on the practices shared by a team. Nowadays, it is possible to minimize the time spent developing or fixing code with continuous testing and fewer local configurations thanks to some framework built-in capabilities.

Mihalceanu: upgrade. With the development of the Java language, framework features have also flourished. In my experience, writing clean, secure code in a timely manner depends on shared team practices. Today, with constant testing and less native configuration, the time spent developing or fixing code can be minimized thanks to features built into the framework.

Rahman: Java SE 17 and Quarkus are enjoying the limelight. Kubernetes remains wildly popular. There is early enthusiasm around Spring Native. Folks in the open standard Java community are watching Jakarta EE 10 and MicroProfile/Jakarta EE alignment closely. There is something good happening pretty much for everyone in the ecosystem.

Rahman: Java SE 17 and Kwakus are enjoying the spotlight. Cubernetes remains hugely popular. Early people were enthusiastic about Spring Natives. People in the open standards Java community are paying close attention to Jakarta EE 10 and MicroProfile/Jakarta EE alignment. There are some good things happening for everyone in the ecosystem.

Ritter: The focus for pretty much all developers, at least when working on new development, is how to make the most effective use of the cloud, especially through a microservice architecture. Leveraging containers and technologies like Kubernetes and Spring Boot are very powerful when writing these types of applications. I hear a lot of discussion about how to use these.

Ritter: The focus of almost all developers, at least when developing new projects, is how to best leverage the cloud, especially through microservices architecture. Leveraging containers and technologies such as Kubernetes and Spring Boot is very powerful when writing these types of applications. I hear a lot of discussions about how to use these.

Evans: Java 17, Loom, Quarkus.

Loom, Quarkus.

What’s New and Exciting That We Didn’t Expect?

What’s new and exciting that we didn’t expect?

Beckwith: I had anticipated the richness of the Java ecosystem and the different JDK vendor flavors of the Java Dev Kits offerings. Still, the sheer participation and the agreement towards the accelerated release cadence were a welcome surprise.

Beckwith: I anticipated the richness of the Java ecosystem and the different JDK vendor styles that Java Dev Kits offer. Still, the involvement and agreement to speed up the pace of release is a welcome surprise.

Mihalceanu: What I love about Java is that each release adjusts both the language and the experience of developers. Enhancements such as the new date formatter for period-of-day introduced in java.time.format.DateTimeFormatter and DateTimeFormatterBuilder classes, pattern matching with switch, or the default method toList() in java.util.stream.Stream interface help developers to write cleaner and easier to read code.

Mihalceanu: One of the things I like about Java is that each release adjusts the developer’s language and experience. Enhancements such as date formatters were introduced in java.time.format. DateTimeFormatter and DateTimeFormatterBuilder classes, pattern matching with switch, or the default method toList () in java.util.stream. The flow interface helps developers write clearer and easier to read code.

Ritter: Looking at the Java platform, there wasn’t anything we didn’t expect and that’s a good thing. Now that new features use JEPs to define what they are intended to do, we have a clear roadmap of the things that will be included in Java looking some years into the future. This means developers can be comfortable that there are not going to be big changes that impact backwards compatibility, at least not without plenty of time to evaluate and discuss them.

Ritter: Looking at the Java platform, there’s nothing we didn’t expect, and that’s a good thing. Now that new features use JEP to define what they intend to do, we have a clear road map for what Java will include in the years ahead. This means that developers can rest assured that no significant changes will occur that affect backward compatibility, at least if there is not enough time to evaluate and discuss those changes.

Evans: A new focus on warm start / suspend-and-resume / CRaC technologies from a number of providers, including Azul and Red Hat.

Evans: There is a new focus on hot start/pause and recovery /CRaC technologies from many vendors, including Azul and Red Hat.

Redlich: The emergence of MicroStream, a Java persistence company. While their history goes back to 2013, the company was formally founded in 2019. Since then, they open-sourced MicroStream earlier this year with the release of MicroStream 5.0 and has collaborated with MicroStream has been integrated with Helidon and has just released version 6.0.

Redlich: Advent of MicroStream, a Java persistence company. Although their history can be traced back to 2013, the company was officially founded in 2019. Since then, they released open source MicroStream 5.0 earlier this year and have partnered with MicroStream, already integrated with Helidon and just released version 6.0.

Silz: After years of stagnation, VS Code is shaking things up in the Java IDE space. It’s something new: A cross-platform, cross-language IDE that’s fast, has great plug-ins, and is loved by its users! If that sounds like “Eclipse IDE 20 years ago”, you’re right!

Silz: After years of stagnation, VS Code is changing the javaide landscape. Here’s something new: a cross-platform, cross-language IDE that’s fast, has great plug-ins, and users love it! If this sounds like the “Eclipse IDE of 20 years ago,” you’re right!

VS Code recently boosted its Java capabilities. I expect it to become the best free Java IDE. I think Eclipse recognized that threat and created a Working Group to coordinate a defense. I’m not sure how much IntelliJ will be affected.

It has recently improved its Java capabilities. I want it to be the best free Java IDE. I think Eclipse is aware of this threat and has created a working group to coordinate defense efforts. I don’t know how much intelligence that would affect.

One exciting side effect of using VS Code for Java development is that you can easily develop with non-JVM languages. I don’t think you can do that in Eclipse at all, or only in a limited way. You can develop with non-JVM languages using JetBrains “All Products Pack”, but then you have to launch different IDES that don’t share settings, plug-ins, or keyboard shortcuts.

One of the exciting side effects of using VS code in Java development is that you can easily develop in non-JVM languages. I don’t think you can do this at all in Eclipse, or only in a limited way. You can use JetBrains “All Products Pack” to develop in a non-JVM language, but you must start a different IDE that does not share Settings, plug-ins, or keyboard shortcuts.

The Java Community

Mihalceanu: I started my Java journey while in university, learning that Java supports Object-Oriented Programming with design patterns and coding best practices. As a professional, I am happy to see that throughout the time, the language has embraced other paradigms as well: functional, reactive thus giving more implementation options without losing the readability. How to choose between each model? Occasionally profile your application, spot bottlenecks, and improve your implementation logic.

I started my Java journey in college and learned that Java supports object-oriented programming through design patterns and writing best practices. As a professional, I was pleased to see that language embraced other paradigms along the way: functional, reactive, and thus offering more implementation options without losing readability. How do you choose between each mode? Analyze your application occasionally, find bottlenecks, and improve your implementation logic.

Yet, no advancement is possible without people. The Java Community is large, vibrant, and welcoming, present both physically and virtually all for one purpose: to share knowledge, improve ourselves, and succeed when facing problems.

However, progress is impossible without people. The Java community is a large, vibrant, passionate community that exists, real or virtual, for one purpose: to share knowledge, to improve, and to succeed in the face of problems.

Boy, haven’t you seen enough? Click on the details of the stone, casually have a look, maybe there is a surprise? Welcome to support the likes/attention/comments, your support is my biggest motivation, thank you!