Hashtag Jakarta EE #56

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

It is time for a new edition of Studio Jakarta EE LIVE! This time I have Emily Jiang from IBM with me in the studio. We will talk about MicroProfile 4.0 and I am pretty sure that Emily will show some cool demos as well.

Check out microprofile.io for details about MicroProfile 4.0 and MicroProfile in general. And of course, make sure to tune in to Studio Jakarta EE LIVE: MicroProfile 4.0 on Thursday!

MicroProfile 4.0 contains updates to all the specifications. It is based on the Jakarta EE 8 versions of the four specifications that form the foundation of MicroProfile. This means that it is still on the javax.* namespace.

How difficult the migration from the javax.* to the jakarta.* namespace is for your particular use case depends on the complexity of your application. The focus has mainly been on the Java package names, but there are some other areas that may require some effort as well. Check out my Migration Guide for an example of how to migrate an application that touches most of the areas.

Please reach out to me if you discover areas that I have missed in the guide. I will be happy to update it!

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

Migration Guide

In my post Migrate to Jakarta EE 9 last year, I wrote about how to migrate your application from the javax.* to the jakarta.* namespace. I think it is time to revisit this topic and outline the steps involved.

In the recent versions of the Jakarta EE 9 and Beyond talk, I have included a slide that lists the steps needed for the migration. Note that all the steps does not necessarily apply to your application.

I strongly recommend that you use the help provided by your IDE to fix the Java package names. If you choose to go the brute force way and replace all occurrences of javax. with jakarta., you will most likely experience some issues. This is important! There are still classes in Java SE that are in the javax.* namespace. These are not affected by the Jakarta EE namespace migration, but stay as they are. Some examples are:

javax.sql.*
javax.transaction.xa.*
javax.xml.*
javax.naming.*
javax.swing.*

These are just some of the examples, so be careful with the global search-and-replace!

Take a look at the Complete Duke application for a full step-by-step example of how to migrate from Jakarta EE 8 to Jakarta EE 9. I hope it helps!

Hashtag Jakarta EE #55

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

We are two weeks into the new year already, and I want to remind the specification teams that about the deadline for submitting a plan review in order to be a candidate for inclusion in the Jakarta EE 9.1 release. The deadline is January 31 as the timeline below shows.

The Jakarta EE Platform team are having weekly calls where various topics related to the platform specification are discussed. Please, do join this call if you are interested in participating in shaping the platform. Details for how to join can be found in the Jakarta EE Platform Calendar.

Barcelona JUG is the next stop on our Jakarta EE Virtual Tour. Join here! We really enjoy giving these talks, so please reach out if you are interested in hosting us at your JUG or MeetUp.

The first Jakarta EE Update Call of 2021 will happen on January 21! The topics we will cover in this call are the program plan and budget, the release plan for Jakarta EE 9.1 as well as upcoming events, programs and marketing campaigns. And, of course, there will be an opportunity to get your questions asked and answered.

Visit the Community Calendar to find the details about how to join the call.

Hashtag Jakarta EE #54

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

The main goal of Jakarta EE 9.1 is to support the Java SE 11 runtime. The APIs will still be compiled to Java SE 8 level in order to be usable to both Java SE 8 and Java SE 11. That means that there will not be need for any new releases for the individual specifications unless the specification teams have changes they wish to push forward. The absolute deadline for such plans to be put forward is January 31, 2021. See the timeline below.

Note that, it is up to the platform project to decide if any new versions should be included in the Jakarta EE 9.1 release even if a plan review is submitted within this deadline.

The Jakarta Contexts and Dependency Injection project continues with weekly calls with the goal to define a CDI Lite specification. Follow the discussions on the CDI Developer Discussions mailing list.

The Jakarta EE Virtual Tour continues in 2021. The ones we have planned so far are Silesia JUG (Jan 13), JUG Darmstadt (Jan 13), Barcelona JUG (Jan 20), and Chicago JUG (Feb 25). Please reach out if you are interested in hosting us at your JUG or MeetUp.

The jChampions Conference is starting next week. I will be a moderator for at least one of the sessions. Check out the schedule.

Hashtag Jakarta EE #53

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

Happy New Year!

It’s 2021 and a year since I wrote the very first Hashtag Jakarta EE. I find it useful for myself to write these short recaps of what’s going on in the community, and I hope you enjoy them as well!

On the very last day of 2020, Eclipse GlassFish 6 was released! Go to glassfish.org/download to check it out. GlassFish 6 meets the compatibility requirements of Jakarta EE 9. Downloads are available for both the Platform and the Web Profile.

If you want to have a look at the other fishes in the Jakarta EE and MicroProfile space, take a look at A day of fishing with Jakarta EE and MicroProfile by Edwin Derks. In this blog post, Edwin describes the differences and similarities between GlassFish, Payara, and Piranha.

The Jakarta EE Virtual Tour continues in 2021. The ones we have planned so far are Silesia JUG (Jan 13), JUG Darmstadt (Jan 13), Barcelona JUG (Jan 20), and Chicago JUG (Feb 25). Please reach out if you are interested in hosting us at your JUG or MeetUp.

Hashtag Jakarta EE #52

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

This is the last Hashtag Jakarta EE in 2020. But don’t worry, I will continue these weekly updates in 2021 as well.

This week, MicroProfile 4.0 was released! It’s been a long wait since the previous release (3.3) back in February. But now it’s here, the first release of MicroProfile following the MicroProfile Specification Process (MPSP).

This release contains updates to all specifications. See the MicroProfile Presentation for details. Note that the four Java EE 8 specifications that form the foundation of MicroProfile have been updated to the Jakarta EE 8 counterparts. This means that MicroProfile is still on the javax.* namespace. I expect that there will be a release during 2021 that will be based on Jakarta EE 9 versions of the specifications and by that support the jakarta.* namespace.

MicroProfile 4.0 will be covered in detail in the next Studio Jakarta EE LIVE as my guest on January 28th is Emily Jiang. Make sure to tune in to get all information about the 4.0 release directly from Emily.

As I mentioned in the previous Hashtag issue, I will participate in a Tech Summary Panel organized by the Barcelona JUG on December 29. In this event, we will summarize 2020 and look ahead towards 2021. It has an amazing lineup of speakers, and I am honored to be among them. You don’t want to miss this!

I’ll end this last Hashtag Jakarta EE of 2020 with a pointer to a great blog post by Payara‘s Steve Millidge: Cloud Myth: Ahead of Time Compilation Will Save You Money.

Summing up Jakarta MVC 2.0

This post concludes the mini-series about how Jakarta MVC 2.0 moves through the steps involved in the Jakarta EE Specification Process (JESP).

All the posts are listed here, so bookmark this page for reference if you are involved in, or planning to be involved in a Jakarta EE specification.

Jakarta MVC 2.0 Plan Review
Jakarta MVC 2.0 Progress
Jakarta MVC 2.0 TCK
Jakarta MVC 2.0 Release Review
Jakarta MVC 2.0 Released

I have used Jakarta MVC as an example for a specification going through the steps involved in the JESP and blogged about them here. Check out the Jakarta MVC tag to get them all.

Hashtag Jakarta EE #51

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

As we are ramping down to close 2020 and recharge for 2021, there are still things going on in the community. First, I would like to point you to the Studio Jakarta EE LIVE I had with Dalia this week where we talked about tooling for Jakarta EE.

Stay tuned for more Studio Jakarta EE LIVE coming up next year.

We released Jakarta MVC 2.0 yesterday! This was the second release since moving to Eclipse Foundation and Jakarta EE. With this release, we have moved to the jakarta.* namespace. Eclipse Krazo, the compatible implementation runs on both GlassFish and WildFly. OpenLiberty is on its way.

Jakarta MVC 2.0 will be featured in a session called “OpenDDR and Jakarta MVC” that I am co-speaking with Werner Keil at Java2Days on December 22nd.

On December 29th, I am participating in a Tech Summary Panel organized by the Barcelona JUG. In this event, we will summarize 2020 and look ahead towards 2021. It has an amazing lineup of speakers, and I am honored to be among them. You don’t want to miss this!

Jakarta MVC 2.0 Released

Jakarta MVC 2.0 passed the release review ballot and is now ratified as a final specification according to the Jakarta EE Specification Process (JESP).

The last steps for the project team after the ballot are to release the staged artifacts to Maven Central and verify that all published information is correct. That has now been done, and I have listed information about how to obtain the artifacts below.

The MVC 2.0 API maven coordinates are:

<dependency>
  <groupId>jakarta.mvc</groupId>
  <artifactId>jakarta.mvc-api</artifactId>
  <version>2.0.0</version>
</dependency>

The Eclipse Krazo 2.0.0 maven coordinates are:

<dependency>
  <groupId>org.eclipse.krazo</groupId>
  <artifactId>krazo-core</artifactId>
  <version>2.0.0</version>
</dependency>

In addition to the core component, you will also need a dependency specific to the Jakarta EE 9 implementation you are using. See Eclipse Krazo 2.0.0 download page for more information about this.

The MVC 2.0 TCK can be downloaded from the Eclipse Download area. It can also be obtained from Maven Central.

I have used Jakarta MVC as an example for a specification going through the steps involved in the JESP and blogged about it here. Follow the Jakarta MVC tag to get them all.

Planning for Jakarta EE 9.1

In the December 15 Platform Project call, the platform team made a couple of important decisions regarding the upcoming Jakarta EE 9.1 release.

The goal of Jakarta EE 9.1 is to ship Java SE 11 support as soon as possible. That means that we want to minimize releasing new API artifacts unless necessary. Specification teams are able to make changes and do minor updates if they wish, or have to in order to support Java SE 11. In order to avoid putting these on the critical path of the release, the platform team decided to enforce a deadline for announcing these changes. The deadline for starting a plan review for potential inclusion in Jakarta EE 9.1 is set to January 31, 2021.

Any API team that wants to release a new version MUST engage in a plan review by the end of January 2021 in order to be considered for inclusion in Jakarta EE 9.1.

The Jakarta EE Platform Team

Please refer to the December 15 meeting minutes for details.

The plan for Jakarta EE 9.1 has not been finalized yet but will be communicated on the Jakarta EE Platform Project pages shortly. I have taken the liberty to sketch a very loose outline for the plan below.

The only date communicated so far is the deadline for engaging in a plan review for specification projects. That deadline is January 31, 2020. The actual release date (T) is not decided yet, but it is a fair assumption that the Jakarta EE 9.1 specification will go on ballot for release review about 14 days prior to this date. Any specifications that are updated for this release will have to go to ballot before this. Preferably as soon as possible, but no later than 14 days before the platform ballot starts in order to complete on time.

A plan review is an important step in the Jakarta EE Specification Process (JESP). This is where a project team presents its plans for the Specification Team and the community for feedback.

A plan review is initiated by creating a Pull Request to the specifications repository. To make it easier for a project team to know what information to include in a plan review, the specification committee has created an example of such a pull request. The example PR contains a checklist for the project team:

## Specification PR template
When creating a specification project plan review, create PRs with the content defined as follows.

Include the following in the PR:
- [ ] A directory in the form wombat/x.y where x.y is the release major.minor version.
- [ ] An index page wombat/x.y/_index.md following [template](https://github.com/jakartaee/specification-committee/blob/master/spec_page_template.md)
- [ ] Title should be on the form "Jakarta Wombat X.Y (under development)"
- [ ] Includes a plan for the release. Usually, a couple of statements is enough. Otherwise, a link to a document describing the release.
- [ ] Includes a detailed description of any backward incompatibility (Mark with **N/A** and check if none)
- [ ] Declares optional features if there are any (Mark with **N/A** and check if none)
- [ ] Includes minimum Java SE version
- [ ] Describe any updates or required changes including splitting out the TCK (Mark with **N/A** and check if not planned)
- [ ] Link to updated release record

The planned version’s _index.md file should look something like this:

---
title: "Jakarta Wombat 1.0 (under development)"
date: 2099-12-01
summary: "First release of Jakarta Wombat"
---

Jakarta Wombat 1.0 lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

*Minimum Java SE Version:* **17**

* [Jakarta Wombat 1.0 Release Record](https://projects.eclipse.org/projects/ee4j.wombat/releases/1.0)

Instructions for Jakarta EE Specification projects regarding reviews were communicated to project leads on the Jakarta EE Specification Project Leads mailing list in this message from the Specification Committee.