Most of this week was spent at the Eclipse Foundation office in Ottawa. It is great to have the opportunity to meet the people I work with daily in person once in a while.
On Tuesday, January 14, there was an off-week MicroProfile Hangout dedicated to the discussions around the Working Group proposals for MicroProfile. The hangout was pretty well attended with the usual suspects doing most of the talking. See the presentation and meeting minutes for more details. The session was even recorded.
We even had a Jakarta EE Community Update Call where we talked about Jakarta EE 9, the Jakartification of the specification documents as well as the 2020 program and budget.
In the blog space, there is a lot being written about Jakarta EE. I will point to a couple of posts here. Will Lyons summarises The Jakarta EE 8 Community Retrospective and you can read about the approval of the Jakarta EE 9 release plan in Mike Milinkovich’ post Moving Forward with Jakarta EE 9,
This week, I have been in Sandusky, Ohio for CodeMash. This awesome conference is organized by an Ohio Non-Profit Organization and is held at the Kalahari resort in Sandusky, Ohio.
In addition to meeting a bunch of awesome people, I had a talk about Eclipse MicroProfile.
Attending conferences like CodeMash that are not entirely Java-centric is a great reminder that outside our bubble, most developers haven’t heard about Jakarta EE or MicroProfile at all!
It is both challenging and rewarding to give a talk where you are not preaching to the choir. I encourage you all to do this more often. This is how we spread the message! This is how we grow our community!
In the Jakarta EE space, we started the week with an EE4J PMC meeting followed by the Jakarta EE Steering- and Specification committees. The most important agenda item discussed is the ongoing ballot for approval of the Jakarta EE 9 release plan in the Specification Committee. You can follow the ongoing ballot on the Jakarta EE Specification Committee mailing list.
At the end of last year, the Java EE Guardians completed their rebranding to become the Jakarta EE Ambassadors. I am really happy that I was able to help in the process of getting the new logo created. This is the first approved usage of the Jakarta EE brand and logo outside of the Jakarta EE Working Group. A milestone in itself!
For a while now, I have been thinking of posting more regular updates about stuff going on in the Jakarta EE community. Kind of what Josh Long does with his “This Week in Spring” series. Being a big fan of Josh and the work he is doing in the community, I am not ashamed of copying him.
The goal is weekly updates, but being realistic I leave out the cadence from the title. So welcome to the first issue of Hashtag Jakarta EE!
The year 2020 is still young and pristine, most members enjoying a well-deserved vacation after a busy 2019.
At the end of last year, a release plan for Jakarta EE 9 was made available by the Jakarta EE Platform Project. The work with this release will start up again next week with weekly calls. These calls are open for anyone. The details can be found in the EE4J PMC Calendar.
It is time for my yearly summary of conferences and community activities. In addition to numerous local meetups and online events, I had the opportunity to speak at the following major developer conferences:
Jfokus, Stockholm Devnexus, Atlanta ConFoo, Montreal JavaLand, Brühl JEEConf, Kiev QCon, São Paulo DevTalks, Bucharest Java Cloud Africa, Johannesburg J4K, Orlando Oracle CodeOne, San Francisco EclipseCon Europe, Ludwigsburg Trondheim Developer Day, Trondheim Devoxx Ukraine, Kiev Devoxx Belgium, Antwerp Devoxx Morocco, Agadir Java2Days, Sofia
The biggest change for me this year happened in October when I joined the Eclipse Foundation as the Jakarta EE Developer Advocate. This means that I am able to dedicate all my time to community building and contributions to open source.
My new role enable me to be even more present at conferences and events around the World, so I expect 2020 to be at least as busy. I already have conferences lined up for the first quarter and more in the planning.
With Jakarta EE 8 out the door in 2019, we are now in full planning for Jakarta EE 9. The biggest impact of this release will be the namespace change from javax.* to jakarta.*. We will also prune some not very widely used technologies in order to lighten the burden for new implementations of the platform. This work will probably continue in subsequent releases.
All in all 2019 was a great year for Jakarta EE and I expect 2020 to be even better!
The Jakarta EE Platform Project calls are open for participation from anyone. If you are not able to attend a call, you can always browse to the Meeting Minutes for an update on the current discussion topics and decisions.
So, how do I get started with contributing to Jakarta EE?
The first thing you need to do is to create an Eclipse Account. If you already have an account, you may skip this step. If you want to do more than just joining the discussions on the mailing lists or calls, you need to sign the Eclipse Contributor Agreement (ECA). If you already have done this, you may skip this step as well.
The entire process is summarized below.
Congratulations! You can now be a Contributor to any project at the Eclipse Foundation.
So, how do I actually contribute then?
The easiest way of contributing is to submit Pull Requests to the project you are interested in. All the Jakarta EE Specification projects are currently located under the Eclipse EE4J GitHub organization.
The more you contribute, the more likely you are to be elected as a committer to the project (i.e. if you want to). If you get elected as a committer to a specification project, you will be asked to sign the Individual Working Group Participation Agreement. (*)
It has been a lot of talk about processes in the Jakarta and MicroProfile community lately, so I just want to remind us all about this item from the Agile Manifesto.
Individuals and interactions over processes and tools.
https://agilemanifesto.org/
That said, some process is needed. Especially for work with specifications. In this post, I explain the Jakarta EE Specification Process and also think aloud about how the same principles could be applied to Eclipse MicroProfile.
The Jakarta EE Specification Process (JESP) is derived from the Foundation Specification Process (EFSP). The short version is that it specifies how long the voting periods (ballots) are for the various reviews:
Creation Review: 7 days
Plan Review: 7 days
Progress Review: 14 days
Release Review: 14 days
Service Release Review: 14 days
The entire process is visualized in the figure below.
Eclipse Foundation Specification Process (EFSP)
So, how fast can you develop a specification using the JESP? Well, you will need to come up with a specification project proposal and submit it for review. This review may take up to 7 days to be finalized.
The next step is to present the release plan for the Jakarta EE Specification Committee for a Plan Review. This step is optional and meant as a means for the project to secure that you are on the right track. Let’s say we opt-in for this review which means another 7 days, i.e. 14 in total so far.
When your specification is ready to be released, you will submit it for a release review. This will take 14 days to complete and may run in parallel with the ratification by the Jakarta EE Specification Committee. The total amount of days in review for your specification will then be 28 days.
Without the plan review, we are looking at 21 days which is exactly the same as for any project following the Eclipse Development Process (EDP). Which applies to the e.g. the Eclipse MicroProfile project.
The difference between the governance model of Jakarta EE and Eclipse MicroProfile is that Jakarta EE is a working group and has a specification process in place for capturing the intellectual property before a specification is released. Whereas Eclipse MicroProfile is a standard Eclipse Foundation project with an ad-hoc specification process. As an Eclipse Foundation project, the project name has to be prefixed with Eclipse. As a working group, this restriction does not apply.
In the table below, I have summarized some of the similarities and differences and even taken the liberty to draw up how it could look like if a MicroProfile working group with its own specification process was established.
Jakarta EE
Eclipse MicroProfile (as a project)
MicroProfile (as a working group)
Specification Process
JESP
no
MSP (*)
Development Process
EDP
EDP
EDP
Release Review
14 days
14 days
14 days
Ratification
yes
no
yes
Working Group
yes
no
yes
Project Names
Jakarta [spec]
Eclipse MicroProfile [spec]
MicroProfile [spec]
Specs Consumable by Jakarta EE
yes
no
yes
Specs Consumable by Eclipse MicroProfile
yes
yes
yes
(*) Thinking aloud: MicroProfile Specification Process (MSP)
The MicroProfile Specification Process could be as simple as this: Adopt the EFSP with the following voting periods (ballots): (…still thinking aloud…)
Creation Review: 7 days (as today according to the EDP)
Plan Review: 7 days (or optional as today)
Progress Review: 7 days
Release Review: 14 days
Service Release Review: 14 days
To sum up, I think the JESP has captured the essence of “Individuals and interactions over processes and tools” by being as lightweight as possible while still protecting everyone involved.
It’s been a week since I started as the Jakarta EE Developer Advocate at the Eclipse Foundation!
As you may have noticed, I am involved in almost any committee around Jakarta EE and enterprise Java in general and my new role has some implications for these engagements. I have listed them below and tried to give a reasonable explanation for each of them.
EE4J PMC
I have been a member of the EE4J PMC since its inception back in 2017, and for practical reasons served as the PMC Lead the entire time. According to the charter, we are supposed to rotate the leadership among the non-foundation staff members of the PMC. In order to minimize overhead, the PMC decided to stick with me as the lead until otherwise decided.
If the PMC wants me to continue in the PMC Lead position, the “non-Foundation staff” phrase will have to be removed from the charter. This has been put on the agenda for the PMC meeting on November 5th, so then we will know…
Jakarta EE Working Group Steering Committee
I have withdrawn from my elected Committer Representative seat in the Steering Group as this seat should not be held by anyone from the Eclipse Foundation. This position is currently up for election (hint hint: if you want to be involved, nominate yourself…).
Jakarta EE Working Group Specification Committee
The position I have in the Specification Committee is the PMC Representative. It is up to the PMC whether I should continue or withdraw. This will also be handled at the next PMC meeting on November 5th.
Java Community Process (JCP) Executive Committee
I have withdrawn from my Associate Seat at the JCP since the Eclipse Foundation is already on the committee. However, I will still be lurking around here as I will be the alternate representative for the Eclipse Foundation.
The JCP Elections have started. Remember to cast your vote!
I am on my way back home from this year’s Oracle CodeOne. As always, this week is so filled with content and activities that it just flies by.
In previous years, I have always had the sort of empty feeling on Thursday (the last day of the conference); the exhibition hall and Groundbreakers Hub is packed away, lunch in the hallways, lots of people walking around with luggage just catching a couple of sessions before heading home.
This year was different. As Ed Burns said in the talk he held together with Phillip Krüger that he found Thursday to be the best day of the conference, to be able to just attend sessions without all the other distractions. And I agree! This year, I listened to great talks from 9 in the morning until 15 in the afternoon with only 15 min breaks between the sessions. No distractions, other than the usual short hallway discussions between the sessions.
and
Jakarta EE 8 was launched the week before CodeOne. Another important milestone for the community! We had a lot of great talks, BOFs and hallway discussions.
The general impression of this edition of CodeOne is that it was smaller than last year. Both in the number of attendees, but also the number of exhibitors. The community spirit, however, was as strong as always!
I am super excited to announce that October 1st, I will become the first Jakarta EE Developer Advocate at Eclipse Foundation!
So, What’s new? Hasn’t this guy been doing this for years already?
Well, yes, and no. My day job has always been working as a consultant even if I have been fortunate that Cybercom Sweden (my employer of almost 15 years) has given me the freedom to also work on open source projects, community building and speaking at conferences and meetups.
What’s different then?
Even if I have had this flexibility, it has still been part-time work which has rippled into my spare time. It’s only so much a person can do and there are only 24 hours a day. As a full-time Jakarta EE Developer Advocate, I will be able to focus entirely on community outreach around Jakarta EE.
The transition of the Java EE technologies from Oracle to Jakarta EE at Eclipse Foundations has taken a lot longer than anticipated. The community around these technologies has taken a serious hit as a result of that. My primary focus for the first period as Jakarta EE Developer Advocate is to regain the trust and help enable participation of the strong community around Jakarta EE. The timing of establishing this position fits perfectly with the upcoming release of Jakarta EE 8. From that release and forward, it is up to us as a community to bring the technology forward.
I think I have been pretty successful with being vendor-neutral throughout the years. This will not change! Eclipse Foundation is a vendor-neutral organization and I will represent the entire Jakarta EE working group and community as the Jakarta EE Developer Advocate. This is what distinguishes this role from the vendor’s own developer advocates.
I hope to see you all very soon at a conference or meetup near you!
As described in Jakarta Going Forward, we need to transition the Jakarta EE specifications to the jakarta.* namespace/base package. After long and intense discussions in the Jakarta EE Specification, we have proposed two possible ways forward to kick-start the discussions on this thread.
In this post, I am highlighting some of the content of the initial post to the mailing list for reference.
Proposal 1: Big-bang Jakarta EE 9, Jakarta EE 10 New Features
The heart of this proposal is to do a one-time move of API source from the javax.* namespace to the jakarta.* namespace with the primary goal of not prolonging industry cost and pain associated with the transition.
Proposal 2: Incremental Change in Jakarta EE 9 and beyond
Evolve API source from javax.* to the jakarta.* namespace over time on an as-needed basis. The most active specifications would immediately move in Jakarta EE 9. Every Jakarta EE release, starting with version 10 and beyond may involve some javax.* to jakarta.* namespace transition.
Other proposals should incorporate the following considerations and goals:
The new namespace will be jakarta.*
APIs moved to the jakarta.* namespace maintain class names and method signatures compatible with equivalent class names and method signatures in the javax.* namespace.
Even a small maintenance change to an API would require a javax.* to jakarta.* change of that entire specification. Examples include: – Adding a value to an enum – Overriding/adding a method signature – Adding default methods in interfaces – Compensating for Java language changes
Binary compatibility for existing applications in the javax.* namespace is an agreed goal by the majority of existing vendors in the Jakarta EE Working Group and would be a priority in their products. However, there is a strong desire not to deter new implementers of the jakarta.* namespace from entering the ecosystem by requiring they also implement an equivalent javax.* legacy API.
There is no intention to change Jakarta EE 8 goals or timeline.
Community discussion on how to transition to the jakarta.* namespace will conclude Sunday, June 9th, 2019.
There are already a lot of contributions and lively discussions going on. Please make sure you join the Jakarta EE Platform Developer Discussions mailing list https://accounts.eclipse.org/mailing-list/jakartaee-platform-dev to take part in the conversation. At the time of writing this post, the number of subscribers to the list has more than doubled! Another proof of the passion and commitment in the Jakarta EE community!
