It is the JPA reference implementation and therefore should be part of database persistence and as part of the database node

Under JDK, I think there should has a Node Jakarta EE to cover all Jakarta EE sepc and popular implementations.

• Servlet -> Apache Tomcat, Eclipse Jetty
• Faces -> Eclipse EE4J Mojarra, Apache MyFaces, Omnifaces Utilities
• Rest -> RedHat Resteasy, Eclipse EE4J Jersey
• CDI -> Weld, Apache OpenBeans
• Persistence -> EclipseLink, Hibernate, (Apache OpenJPA, DataNucleus is not active)
• Validation -> Hibernate Validator
• Data -> EclipseLink, Hibernate
• Messaging -> Eclipse OpenMQ, Apache ActiveMQ Artemis
• Security -> Eclipse Soteria
• JSONP/JSONB -> Eclipse JSONB/JSONP, Apache Johnzon
• Concurrency
• Transaction
• Mail/Activation
• Expression Language - Eclipse ExpressLy

Jakarta EE includes three profiles to categorize the above spec into different group:

• Platform
• Web Profile
• Core Profile

MicroProfile should be a sister project of Jakarta EE, it is based on Jakarta EE Core Profile, and currently almost all products use RedHat SmallRye implementations.

• Config
• JWT
• Reactive Messaging
• RestClient
• Telemetry/Metrics/Health
• OpenAPI
• etc

The Jakarta EE runtimes/implementers include:

• Glassfish
• WildFLy
• OpenLiberty
• Apache TomEE
• Payara(an early fork from GlassFish, open source and commercial support)

Testing tools.

• Arquillian
• Rest Assured
• MicroShed
• WireMock
• Pact(CDC testing, Spring Cloud has a project named Spring Cloud Contract)

The derived projects and frameworks.

• Spring 6 traditional WebMvc aligned to Jakarta EE 9/10+
• Quarkus supports Jakarta EE 10 + MicroProfile
• Helidon supports partial Jakarta EE 10 + MicroProfile
• Micronaunt 4 has already aligned to Jakarta EE 10 and move to jakarta namespace.

Hello there,
I think 'Code Analysis' should be linked to the main learning path.
Great work and thanks for sharing!

There are a few names in the image are out of date and could mislead new developers.

• JSF -> Jakarta Faces
• JMS -> Jakarta Messaging
• JPA -> Jakarta Persistence

Good to know.

Testing:

• Contract testing
  • Spring contract
  • Pact

E2E testing:

• Karate

Unit testing:

• TDD/BDD

The reactive streams define the spec, but Java 9 copies the Java API into its java.util.concurrent.Flow, the content is the same, but the package name is different.

• https://www.reactive-streams.org/
• https://docs.oracle.com/javase/9/docs/api/java/util/concurrent/Flow.html

The popular libs that implement Reactive Streams spec include:

• Reactor -> Spring WebFlux supports it by default, also supports others. The Mono&Flux is just reactor-specific APIs
• RxJava3 -> Vertx, Micronaut supports it.
• SmallRye Mutiny -> Quarkus supports it by default, also supports rxjava3, etc.

Java Flow(since Java 9) -> Including a simple Publisher implementation, the newest SmallRye Munity switches to Java Flow API.

Apache OpenJPA is not so active these years and is not aligned to the latest JPA 3.2.

BTW, from Jakarta EE naming, we call JPA Jakarta Persistence today.

Similar to WebSocket, SSE... GraphQL, REST, RSocket and gRPC, etc. should be belong to the domain of client/server communication protocol.

• GraphQL can be implemented by HTTP, WebSocket, SSE, RSocket, etc.
  • Spring GraphQL
  • Netflix Dgs framework
  • Vertx, Quarkus, and Micronaut have built-in GraphQL supports, including the client and server side.
• Spring WebFlux includes RSocket protocol supports(client/server), and Spring GraphQL includes a Rsocket implementation of GraphQL.
• Spring RSocket can be implemented by Websockets/HTTP, unlike general web applications, a Spring Rsocket server can be opened via a TCP port without a web environment.

The SOAP-based web service was removed from Jakarta EE spec.

I do not think in 2024 it is still valuable for new Java developers.

Hi Stephan,

RabbitMQ is not a JMS provider (https://www.rabbitmq.com/jms-client.html), so I wouldn't tie it to JMS, but to Messaging instead.
AMQP is so much more powerful than JMS...

Thanks,

Dimitri

PS: no space between "Rabbit" & "MQ" 😉

The Blockchain community initiates Web3, it is not illegal for many countries. It should not be part of a Java learning path.

Suggesting to include OpenLiberty as Possibilities in the roadmap. IMHO, the framework utilizes Microprofile and JakartaEE. Most of the people using IBM Java Tech Stack are using this framework.

https://www.gebish.org/

BTW Selenium and Webdriver goes together: "Selenium/Webdriver":

• https://www.selenium.dev/documentation/overview/
• https://www.selenium.dev/documentation/webdriver/

Vertx SQL Client is another reactive client that is used to connect to the RDBMS.

• Hibernate Reactive is based on Vertx SQL Client, and Hibernate Reactive support is included in Micronaut and Quarkus
• Quarkus also Vertx SQL Client or variants implementation of Mutiny.
• Vertx supports Vertx SQL Client and varaints of RxJava2/3, SmallRye Mutiny.
• Micronaut also supports Vertx SQL Client and its variants.

BTW, Vertx includes a collection of its own Async API by default.

For Java backend developers today, Mongo, Redis, Neo4j, ElasticSearch, Couchbase etc. is popular .

• Spring Data has umbrella projects to support these NoSQL
• Eclipse JNoSQL also supports the popular NoSQL

Microprofile is a collection of specs and ready for Microservices.

Helidon includes the implementation of Microprofile, also includes reactive and functional stacks.

Quarkus also includes several Microprofile spec supports.

Spring Boot, Micronaut, Quarkus, Helidon have native build supports, but I am not here Spring Native what it means.