Hashtag Jakarta EE #68

Welcome to the sixty-eighth issue of Hashtag Jakarta EE!

We have a date for Jakarta EE 9.1!

Eclipse GlassFish 6.1.0.RC1 passes the Jakarta EE 9.1 TCK and is available for download. The TCK project is in the process of wrapping up everything for the release. We plan to initiate the review ballot for the Jakarta EE 9.1 specifications on April 30, which means that the artifacts will be released to Maven Central on May 14th. This is a soft launch as we have been doing the last couple of releases, so the official release date with all the marketing splash around it will be May 25th.

Worth noting for this release is that it looks like GlassFish won’t be alone as a compatible implementation when the specification is ratified. A number of vendors are working hard to have their implementations available along with Glassfish for the release review ballot.

When the Jakarta EE Platform team set April 15 as a deadline for specifications to file for plan reviews in order to be considered for the next Jakarta EE release, we didn’t really know what to expect. There have been quite a few efforts to write down expectations, such as the Jakarta EE AmbassadorsGuide to Contributing to Jakarta EE 10, Arjan TijmsJava for the enterprise: What to expect in Jakarta EE 10 and Greg WilkinsLess is More? Evolving the Servlet API!. But would this crystalize into concrete plans?

I guess it is safe to say that we were blown away by the number of detailed plans and outlines submitted as pull requests to the Jakarta EE Specifications repository. Just take a look at the list below grouped by major and minor updates to the specifications.

Major updates
Jakarta Authentication 4.0
Jakarta Authorization 3.0
Jakarta Concurrency 3.0
Jakarta Expression Language 5.0
Jakarta Faces 4.0
Jakarta JSON Binding 3.0
Jakarta RESTful Web Services 4.0
Jakarta Security 3.0
Jakarta Servlet 6.0
Jakarta SOAP with Attachments 3.0
Jakarta Standard Tag Library 3.0
Jakarta XML Binding 4.0
Jakarta XML Web Services 4.0

Minor updates
Jakarta Activation 2.1
Jakarta Connectors 2.1
Jakarta JSON Processing 2.1
Jakarta Mail 2.1
Jakarta MVC 2.1
Jakarta Persistence 3.1
Jakarta Server Pages 3.1
Jakarta WebSocket 2.1

I can’t wait to dive into the details of these plans as they progress through the plan reviews stipulated by the Jakarta EE Specifiation Process. Take a look at the JESP Guide for a simple walk-through of the process.

In addition to the efforts around Jakarta EE 9.1 and Jakarta EE 10, there are ongoing discussions about the alignment between Jakarta EE and MicroProfile. These discussions take place in the CN4J Alliance. Read Jakarta EE/MicroProfile Alignment Survey Results! by Reza Rahman to see how the community responded to the alternatives being discussed.

Hashtag Jakarta EE #67

Welcome to the sixty-seventh issue of Hashtag Jakarta EE!

One of the most exciting things that happened in the Jakarta EE space this week is that the Jakarta EE Platform project decided to start working on a new Jakarta EE Core Profile. The Pull Request to start the process of creation- and plan reviews from the Jakarta EE Specification Committee has been created. I will post more when work progresses.

If you are involved in a Jakarta EE specification project, do remember to submit a request for plan review by April 15. This will make it possible for the platform team to get an overview, and plan for the content of the next release. Refer to the JESP Guide for useful pointers and links to help you navigate the Jakarta EE Specification Process (JESP).

The 2021 Jakarta EE Developer Survey is now open. This has become an annual tradition and is your chance to influence the direction of the Jakarta EE working group. It takes less than 8 minutes to complete.

Take the 2021 Jakarta EE Developer Survey!

Another exciting thing that happened this week is that Microsoft announced their build of OpenJDK. Of course, I went ahead and installed it directly 🙂

$ java -version
openjdk version "11.0.10" 2021-01-19
OpenJDK Runtime Environment Microsoft-18724 (build 11.0.10+9)
OpenJDK 64-Bit Server VM Microsoft-18724 (build 11.0.10+9, mixed mode)

Hashtag Jakarta EE #66

Welcome to the sixty-sixth issue of Hashtag Jakarta EE!

Jakarta EE 9.1 is on track for the mid-May release. GlassFish 6.1 now passes the TCK and a release candidate will be made available this week.

Meanwhile, the work with planning for the next Jakarta EE release goes on. We are getting very close to be proposing a new profile in addition to the current Full Platform and Web Profile. This profile will most likely be called Jakarta EE Core Profile and be specifically targeted at smaller runtimes for microservices and capable of producing minimal cloud-native images.

For the other component specifications, please do remember to submit a request for plan review by April 15. This will make it possible for the platform team to get an overview, and plan for the content of the next release. We will also shortly invite all specification projects to participate in a community meeting. Stay tuned and look out for the invite that will be socialized on all appropriate channels when we have nailed down the details.

I will encourage specification projects to open calls to help drive their work forward. Since we currently don’t meet in the hallways at events and conferences, these meetings are an important way of having discussions in realtime. Makes life on the mailing lists so much easier afterward…

We have created the Specifications Calendar specifically for this purpose. All the project leads of Jakarta EE specification projects have been given permissions to add events to the calendar.

As an inspiration for topics, please check out Arjan’s excellent article Java for the enterprise: What to expect in Jakarta EE 10 in the Java Magazine.

I also want to point you to the newly released Jakarta EE white paper and my accompanying article Why Java Developers Continue to Rely on Jakarta EE.

Why Java Developers Continue to Rely on Jakarta EE

Over the past year, the Eclipse Foundation spoke to leading Java developers around the world to discuss why they rely on Jakarta EE and the unique benefits of using Jakarta EE technologies. Their input is captured in our white paper, which describes the important advantages Jakarta EE offers today and for the future.

Download the Jakarta EE white paper!

They’re Looking Ahead, Not Back

With Jakarta EE’s long history as Java EE, it’s sometimes easy for developers to dismiss the technology as yesterday’s approach. But Jakarta EE technologies are embedded, and relied upon, in a way no other technologies are. Here are some examples you might not be aware of:

  • Apache Tomcat implements several Jakarta EE specifications
  • Eclipse Jetty is a certified implementation of Jakarta Servlet 5.0
  • Spring Boot embeds Eclipse Jetty or Apache Tomcat as a runtime


Open Specifications Bring Important Advantages

One of the advantages every one of the developers raised was the value of the specification-based approach to technologies in Jakarta EE.

The clear boundary between fully tested specifications and underlying implementations means developers can easily switch between the implementations with minimal impact on the application code. This agility saves considerable time, effort, and money when changes are required.

Jakarta EE Provides a Unique Combination of Features and Functions

The developers also described a combination of strategic and technical advantages that aren’t available in any other platform. Some of the main Jakarta EE benefits they noted include:

  • Stability and backward compatibility. Jakarta EE provides a mature and proven foundation for innovation that allows organizations to fully leverage the investments they’ve already made in enterprise Java applications.
  • Architectural flexibility. Organizations can support cloud-based microservices architectures, as well as traditional, monolithic architectures. They can also seamlessly incorporate newer technologies, such as MicroProfile, Docker containers, and Kubernetes orchestration.
  • Speed and simplicity. A Jakarta EE application can be set up with significantly less configuration compared to other frameworks.
  • Development and deployment freedom. Developers can use any Jakarta EE-compatible runtime, and they can implement and blend whichever aspects of the application server are needed to leverage Jakarta EE capabilities in a modern and efficient way.
  • Longevity. The open, vendor-neutral, and community-driven approach at the Eclipse Foundation ensures applications developed using Jakarta EE will remain relevant and usable over the long term.

Get the Full Story

These insights are just a few of the reasons leading Java developers remain committed to Jakarta EE. For the complete story, download the white paper.

Visit the Jakarta EE website to learn more about Jakarta EE and explore the Jakarta EE specifications.

Hashtag Jakarta EE #65

Welcome to the sixty-fifth issue of Hashtag Jakarta EE!

It looks like Jakarta EE 9.1 may be delivered sometime in May. The Jakarta EE Platform project discussed the possibility for a release date in mid-May at this week’s platform call. There are still a couple of details to be sorted out before a final date can be announced. Stay tuned for updates.

The platform team has also started discussions regarding adding a profile to the next release of Jakarta EE. This discussion is currently going on the mailing list.

On Wednesday, March 31, I am giving a short keynote at JakartaOne LivesStream – Russian. What’s interesting about this one is that it will be in Russian. Since I, unfortunately, don’t speak Russian, the organizers have been very helpful in translating my talk and adding a Russian audio track. I hope you will enjoy it!

As you can see, the program for JakartaOne Livestream – Russian is packed with great content!

If you still can’t get enough of Jakarta EE, please don’t hesitate to contact us if you want to host us at your local JUG or Meetup. We still offer free use of Crowdcast for JUGs for streaming your events.

Tanja and I are always eager to visit you and talk about Jakarta EE. We have visited a lot of JUGs in the last 6 months. And we want to visit more. If you want your JUG on this list, you know what to do. Contact us!

At the end, I want to point you to the new Adoptium web site that was just recently launched. This is your one stop shop to download prebuilt OpenJDK binaries for free.

Hashtag Jakarta EE #64

Welcome to the sixty-fourth issue of Hashtag Jakarta EE!

$ java -version
openjdk version "16" 2021-03-16
OpenJDK Runtime Environment AdoptOpenJDK (build 16+36)
OpenJDK 64-Bit Server VM AdoptOpenJDK (build 16+36, mixed mode, sharing)

Java 16 contains a lot of goodies for us, so go ahead and download it to give it a try. or me, the most important feature in JDK 16 is Records (JEP 395). The reason for this is that it reduces the amount of boilerplate code needed. The possibility to write record Point(int x, int y) { } rather than the entire class listed below really appeals to me. The code never written is the best code, as it is guaranteed not to contain any bugs.

class Point {
    private final int x;
    private final int y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    int x() { return x; }
    int y() { return y; }

    public boolean equals(Object o) {
        if (!(o instanceof Point)) return false;
        Point other = (Point) o;
        return other.x == x && other.y = y;
    }

    public int hashCode() {
        return Objects.hash(x, y);
    }

    public String toString() {
        return String.format("Point[x=%d, y=%d]", x, y);
    }
}

I participated in three sessions at JavaLand 2021. First out on Tuesday was Jakarta EE 9 and Beyond which was followed by a Jakarta EE Panel. On Wednesday, it was time for Mobile Java Web Applications with MVC and OpenDDR where I was presenting together with Werner Keil. Despite some technical difficulties with the streaming platform on Tuesday, the conference went smoothly. Let’s hope that we will be back in Phantasialand for next year’s edition!

Work with Jakarta EE 9.1 continues. An agenda item for the platform call this week is to set a release date for Jakarta EE 9.1. We have also started the work by looking ahead towards the next releases. Currently, there are some interesting discussions happening on the Jakarta EE Platform mailing list regarding the definition of new profile specifications.

Also, note that the platform team requests plan reviews from the specification projects to be ready for ballot by April 15 in order to be a candidate for the next release. If you are unsure what to do for a plan review, check out the JESP Guide.

Hashtag Jakarta EE #63

Welcome to the sixty-third issue of Hashtag Jakarta EE!

We have tried to keep the overhead to a minimum with the Eclipse Foundation Specification Process (EFSP). Compared to other specification processes, it is pretty lightweight. Both the Jakarta EE Specification Process (JESP) and the MicroProfile Specification Process (MPSP) adopts the EFSP with a couple of additions that are so similar that they are barely distinguishable.

While knowing the process is good, every developer does not need to know the nitty-gritty details. That is why we have created a step-by-step guide to help developers on Jakarta EE specification projects with the steps of the JESP. Take a look at the JESP Guide to check it out!

JavaLand 2021 is happening this week! We have a lot of great content and community activities to look forward to. Here is a pointer to some of the talks on Wednesday, March 16 by Emily Jiang, Ondrej Mihalyi, and yours truly.

On Wednesday, March 17, I have a joint talk with Werner Keil where we use Jakarta MVC in one of the demos. Directly after, Emily Jiang and Ed Burns show how to port an application from Spring Boot to MicroProfile.

At the end, I want to point you to the article Don’t replace Spring Boot with Quarkus, replace it with Wildfly by Hélio Bessoni Rodrigues. This is an excellent write-up comparing microservices with modular monoliths that encourages developers to build software that lasts rather than being led by hypes and trends..

Hashtag Jakarta EE #62

Welcome to the sixty-second issue of Hashtag Jakarta EE!

One of the major changes introduced with Jakarta EE over how it used to be is that the TCKs are available for free to anyone that wants to certify their implementation. I described how to do this in Compatible Implementations.

This is exactly what the Eclipse Jetty team has done, so Eclipse Jetty 11.0.1 is now certified as a compatible implementation of Jakarta Servlet 5.0! Congratulations to the Jetty team!

In parallel with the work on Jakarta EE 9.1, the individual specifications plans for future releases. Some of the teams are setting up ad-hoc or regular calls in addition to discussing on the mailing lists. In order to have a common calendar to keep track of these calls, we have created the Jakarta EE Specifications Calendar. We encourage the teams to publish their meetings on this calendar. This will make it easier for the community to attend calls they are interested in.

JavaLand 2021 is coming up next week. It will be an online two-day conference happening on March 16 and 17. I have one Jakarta EE talk scheduled. I will also co-speak Mobile Java Web Applications with MVC and OpenDDR with Werner Keil. There is also a Jakarta EE panel scheduled.

That’s it for this week. Hope you enjoyed it, and see you again next week!

Hashtag Jakarta EE #61

Welcome to the sixty-first issue of Hashtag Jakarta EE!

Tanja and I have been touring JUGs over the last couple of months. So far, we have visited JUGs (virtually) in India, South Africa, Sweden, Serbia, the USA, Poland, Germany, and Spain. And we don’t want to stop there! Please reach out to us if you want us to visit YOUR JUG or Meetup!

It is the end of February already, and the release date for Jakarta EE 9.1 is approaching quickly. A release candidate of the API is available in Maven Central. The current activities are around updating the compatible implementations to pass the TCK on JDK 11.

In order to make it to the proposed release date of March 25, the release review must start at the latest on March 11. That means that there are less than two weeks to get Eclipse GlassFish to pass the TCK on JDK 11.

Beyond Jakarta EE 9.1

Looking ahead, discussions around the next release have started in the Jakarta EE Platform Project. To be able to define the scope of the next release, we need input from the component specifications. Plan reviews are due on April 15, 2021 to be considered as candidates for the next release of Jakarta EE. The plan submitted for review must be possible to implement within 6 months. Which in turn means that we are looking at a Jakarta EE release in October, 2021.

Hashtag Jakarta EE #60

Welcome to the sixtieth issue of Hashtag Jakarta EE!

As I mentioned last week, the release plan for Jakarta EE 9.1 has been published. The target release date is the end of March 2021. GlassFish 6.1 now compiles and runs on Java SE 11, and the work with getting it to pass the TCK goes on.

The Jakarta EE Platform team has also started to prepare for the next Jakarta EE release after 9.1. At them moment, we are collecting input from the various specification projects to be able to define the content of this release. The deadline for starting plan review for the next Jakarta EE release is April 15, 2021. Make sure to check the minutes for updates. We encourage specification projects to join the Platform calls and give an update on their plans. The details for the platform calls can be found in the Jakarta EE Platform Calendar.

The JUG Leaders Summit and Devnexus took place this week. Devnexus is an awesome conference to visit, and the virtual edition this year was no exception. Let’s just hope that we will be back in Atlanta for next year’s edition.

There is only one more stop planned on the Jakarta EE Virtual Tour, and that is Chicago JUG on February 25. We really enjoy giving these talks, so please reach out if you are interested in hosting us at your JUG or MeetUp.