Well, we have already talked about what happened to Java in 2022 and what to expect from it in 2023. But, in this article, we’re going to dive a bit deeper and tell you about Java Ecosystem and predictions for the nearest future. Anyways, it’s different additional tools and improvements that enhance productivity, stability, security, and Java’s performance.
Project Loom and Virtual Threads
We’d like to begin with the long-awaited Virtual Threads (JEP 425
) created in Project Loom that have finally appeared in 2022 in the Java 19 version to address limitations in the traditional concurrency model. Though they are now available in a preview mode only, we believe it’ll change with the next release in 2023.
What is Project Loom? It’s a new Oracle’s project which main goal is to significantly reduce the effort of writing, maintaining, and observing high-throughput concurrent apps. In other words, Project Loom aims to support and advance a high-throughput, lightweight concurrency model in Java since traditional OS threads (at the core of Java’s concurrency model) have some drawbacks and are rather expensive computationally. Virtual threads, in their turn, are much more lightweight threads that are not connected with OS threads (they are managed by the JVM). This means that virtual threads are ideal for “thread-per-request” programming and can create tons of virtual threads without reducing the throughput. With that, we see that virtual threads introduced in Java 19 are pretty easy-to-use. They let developers quickly troubleshoot, debug, and profile concurrent apps with existing JDK tools and techniques.
As experts say, the introduction of Project Loom and Virtual Threads is probably one the most important events in Java history, and currently, there is quite a ton of excitement around them. Actually, many developers are now looking forward for the Virtual Threads to moving from “preview status” to “part of a Java 21 LTS” (it’s release is expected in September 2023). We predict that the adoption of Virtual Threads will continue to grow as frameworks and will eventually make it a way easier for Java developers to write more scalable software requiring millions of simultaneous connections. Cool, agree?
Jakarta EE is simply the new name for Java EE (Java Enterprise Edition) which was primarily a platform for building mission-critical business software. Though the platform got the new name after the project had moved under the control of the Eclipse Foundation, this didn’t change the essence of the platform. Jakarta EE comes to resque when you’re running a large, enterprise app that should be scalable, secure, and handle a wealth of information. Jakarta EE consists of a suite of software components, APIs, for creating enterprise Java applications. And these components are often referred to as “Jakarta EE specifications” that extend Java SE versions (standard editions).
These specifications help developers quite a lot because they rid devs of the need to code everything themselves. As a result, developers can focus on the application's business logic rather than minor, infrastructural tasks. And this is not only about saving time and effort. It’s also about creating a more efficient system for users.
What happened to Jakarta EE in 2022? The fresh version, Jakarta EE 10
became available to the Java community on September 22. And this release can boast updates to 24 specifications (12 specifications with major updates and 12 specifications with minor updates) and a new Core Profile
. The Core Profile 10 has undoubtedly become a game-changer since now it targets microservice and cloud development runtimes.
Some additional changes touched EJB Entity Beans and the Embeddable EJB Container that were removed from TCK requirements. Although they are still available within TCK, their implementation is not required for platform compliance any longer.
When it comes to expectations from Jakarta EE in 2023, we believe it’ll become a mainstream framework enabling you to elevate your business application with ease. It’ll become an ideal solution for projects that involve microservices or monolithic development. Yet, you should keep in mind that you’ll need to use the soon-to-be-released Vaadin 24 (planned in March 2023) to utilize app frameworks like Spring Boot 3 or Jakarta EE 10 compatible application servers.
When you're containerizing a Java app, you should typically first consider how much available CPU time the container will have. Then, you consider how much memory will be available (both the total amount of memory and the size of JVM, Java Virtual Machine). In containerized environments, apps may have access to all processors and, thus, run multiple threads simultaneously.
Nowadays, containerization of Java apps continues to gain ground, and this tendency doesn’t seem to change anytime soon. And since more Java workloads are now running in containers, we can see a switch from just talking about “how” to containerize a Java application to “how better”
containerize it. Also, we see more info and guidelines on best practices for running an app in a container. For instance, you may be interested in a fresh Microsoft’s article
with recommendations about memory allocation and garbage collection.
All that just being said, adoption of Native Java will also continue to increase as Project Leyden was finally resurrected in May 2022. If you haven’t heard about Project Leyden yet, it’s worth mentioning that the main goal of this project is to improve long-term pain points of Java - the slow startup time, slow time to peak performance, and large footprint of Java apps. How it’s possible? By integrating static run-time images into the Java Platform and the JDK.
By static images, we mean standalone programs, derived from apps and a JDK, which runs that app. A static image is actually “a closed world” regarding the classes that it can load (it neither loads classes from outside the image nor creates classes dynamically).
However, we’d like to note that Project Leyden isn’t aimed at enhancing the overall performance of Java apps. It just fixes the startup part and relies on the other project — GraalVM
which is constantly improving and becoming increasingly popular. Plus, it begins to support more use cases such as Spring apps.
The combo of simplicity, security, and robustness is one of the main reasons why Java keeps the leading positions among the top technologies. And 2023 is expected to become a year of deeper adoption of Virtual Threads (in JDK 20, due in March) to further promote a lightweight concurrency constructs to Java. Virtual Threads will focus on the ability for better scaling; thread API adoption of virtual threads; and simplified troubleshooting, debugging, and profiling.
It’s also projected that parts of GraalVM Community Edition Java code will move to OpenJDK in order to affiliate the development of GraalVM and Java technologies. And Oracle has already announced that community editions of the GraalVM JIT and AOT compilers will move to OpenJDK in 2023.
As you see, the changes in Java Ecosystem are significant, and they demonstrate how the industry is moving forward. And what do you think about the Java trends? What to expect in 2023?