Quick recap: #JavaEE was renamed #Jakarta EE; it transitioned from JCP to Eclipse foundation. It opened the door to open governess, open compatibly testing (open TCK), and of course, open-source.
70-80% of java applications use JakartaEE APIs one way or another. e.g. Tomcat, Hibernate, ActiveMQ, Jetty, CXF, Jersey, RESTEasy, Quarkus, Microprofile, Spring. Dig a little deeper, and you will find @JakartaEE APIs.
👇
It’s a lively ecosystem; you have @JakartaEE 9, @MicroProfileIO, & Helidon. @QuarkusIO, introduced after @micronautfw & @helidon_project, remains a popular framework. Though JavaEE8 is still around, JakartaEE 9 is considered a foundation for innovation to drive new features
👇
@JakartaEE 9 moves all relevant specifications from javax to the Jakarta namespace. Unfortunately, that causes some breaking changes, but the migration rather seems easy. There are tools to do that. It also removes older deprecated technologies and moves Java 8 to Java 11.
👇
One of the most commonly used services in the Jakarta Concurrency API is the #ManagedExecutorService. It is similar to Java SE ExecutorService but in a @JakartaEE environment. Earlier, we had a vendor-specific setting to configure it. Now it can be defined with just annotation
👇
@Asynchronous
This used to be an EJB annotation, but the EJB one is a bit out of date. Also, in EJB, we can’t specify the thread pool. Now it comes with @JakartaEE 10, which doesn’t require using EJB, and we can specify the thread pool. So it can be used with any CDI bean.
👇
Bootstrap API:
If you are invoking a rest service outside of a @JakartaEE environment, e.g. unit tests, integration tests etc., this is good to have a standalone API to do that. With this, you don’t need to run the entire container.
Multipart/form-data
Every vendor used to support this in their specific way, but now we will have a standard way to deal with the multipart form submission.
@JakartaEE 10 now brings a standard way to support OpenID Connect with the #OpenIdAuthenticationDefinition annotation.
Life is much simpler; specify the required properties, such as providerURI, clientId, clientSecret, redirect URI, etc., and that's it.
👇
@JakartaEE Persistence now supports UUID as a key. This is particularly important for the Cloud environment since many databases don’t automatically generate UUID. With this, we can create a UUID key from the Java side.
You can now write your UI code entirely in Java with the pure Java faces View. If you are particularly not interested in writing any tagging language whatsoever, you'll love it.
Now a bit about @jee_ambassadors: We are an independent grassroots group of people committed to moving Jakarta EE forward through active community participation and advocacy. If you want to join, and contribute, find out more here: jakartaee-ambassadors.io
👇
And finally, keep an eye here on my Twitter (follow?) to get more similar threads in the future.
• • •
Missing some Tweet in this thread? You can try to
force a refresh
We all want to move on and migrate our code to the latest JDK to have more concise, clear, and improved idioms. However, there is a cost to this. It takes time, and often we are afraid of it.
Perhaps we shouldn't be afraid anymore.
🧵👇👇👇
Migrating code manually is a tedious process, but what if we could query the code the way we do it on the database and then apply the changes?
👇👇👇
It looks like we can with some of the available tools. e.g. ClassGraph, JavaParser, OpenRewrite and many more. 👇👇👇
#Java 19 introduces virtual threads to the Java platform for the first time; this is the primary deliverable of OpenJDK's Project Loom.
This thread is all about it:
🧵
⬇️⬇️⬇️
Java is made of threads. When we run a Java program, its main method is invoked as the first call frame of the main thread created by the Java launcher. It gives us many things: sequential control flow, local variables, exception handling, single-step debugging, and profiling. ⬇️
It makes our lives easier by providing exception handling with informative stack traces and serviceability tools that let us observe what's happening in each thread, providing remote debugging, and creating an illusion of sequentiality that makes our code easier to reason.
⬇️
#Java 19 is a major release, IMO. It includes several game-changing features that will alter the Java landscape. Many features intrigue my interest, but there are five in particular that I can't wait to try out. Let's break those down and talk about them separately.
🧵
⬇️⬇️⬇️
Under the umbrella of Project Loom, JEP 425 introduces virtual threads, which aim to dramatically reduce the effort of writing, maintaining, and observing high-throughput concurrent applications on the Java platform. ⬇️
Structured Concurrency allows you to treat multiple tasks running on different threads as an atomic operation, making multithreaded programming easier. As a result, error handling and cancellation will be simplified, reliability will increase, and observability will be boosted.⬇️
Every programming language provides ways to express our ideas and then translates them into reality. This thread will explore ten #Java programming features used frequently by developers in their day-to-day programming jobs.
Collections are used to store, sort, search, and iterate objects. It provides a few basic interfaces, such as List, Set, Map, and their implementations. The traditional way of creating Collections may look verbose. Therefore, #Java 9 introduced a few very concise factory methods.
#Java 10 introduced type inference for local variables, which is super convenient for developers.
#Java has been and continues to be the most popular language over the last two decades. After many discussions with Java developers, I have concluded the following seven key reasons why Java developers still love Java after all these years.
1. Community:
In every major city, you will find a Java user group that helps developers achieve the required skills, voluntarily and for free, who help distribute resources and solutions, increase networking, and expand #Java knowledge globally. dev.java/community/jugs/.
2. Language and Platform
An expressive and easy-to-read language helps new developers quickly get used to the existing codebase. #Java is an open-source programming platform with great documentation support. It's a platform that houses and enables a wide range of other languages.