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.
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.
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.
Eclipse MicroProfile (as a project)
MicroProfile (as a working group)
Eclipse MicroProfile [spec]
Specs Consumable by Jakarta EE
Specs Consumable by Eclipse MicroProfile
(*) 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.
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.
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!
The agreement between the Eclipse Foundation and Oracle regarding rights to Java trademarks has been signed! This is truly an important milestone for Jakarta EE since we will now be able to move forward with Jakarta EE.
One part of the agreement is regarding the use of Java trademarks. The implications for Jakarta EE is that we have to rename the specifications and the specification projects. This work is ongoing and is tracked in our specification renaming board on GitHub. The EE4J PMC has published the following Naming Standard for Jakarta EE Specifications in order to comply with the trademark agreement.
The javax Namespace
The major topic of the agreement is around the use of the javax namespace. The agreement permits Jakarta EE specifications to use the javax namespace as is only. Changes to the API must be made in another namespace.
While the name changes can be considered cosmetic changes, the restrictions on the use of the javax.* namespace come with some technical challenges. For example, how are we going to preserve backwards compatibility for applications written using the javax.* namespace?
The Jakarta EE Specifications Committee has come up with the following guiding principle for Jakarta EE.next:
Maximize compatibility with Jakarta EE 8 for future versions without stifling innovation.
With the restrictions on the use of the javax.* namespace, it is necessary to transition the Jakarta EE specifications to a new namespace. The Jakarta EE Specification Committee has decided that the new namespace will be jakarta.*.
How and when this transition should happen is now the primary decision for the Jakarta EE community to make. There are several possible ways forward and the forum for these discussions is the Jakarta EE Platform mailing list.
Please make sure that you subscribe to the mailing list and join in on the discussion. We hope that we will be able to reach some form of consensus within a month that can be presented to the Specification Committee for approval.
While the restrictions on the use of Java trademarks and the javax.* namespace impose both practical as well as technical challenges, it is also an opportunity to perform some housekeeping.
By renaming the specifications, we can get a uniform, homogeneous naming structure for the specifications that makes more sense and is easier on the tongue than the existing. By having clear and concise names, we may even get rid of the need for abbreviations and acronyms.
The shift from javax.* to jakarta.* opens up for the possibility to differentiate the stable (or legacy) specifications that have played their role from the ones currently being developed.
Naming is hard and changing names that we have become attached to is even harder. Most of us also have this inherent feeling that change is bad and should be avoided. At the same time, we live in this ever-changing industry where embracing change is, not only a mantra but also a requirement to survive. Add to this, that some of the names we are talking about in this context are pretty bad. Some of them so long that we have to google the acronym to be able to describe what it actually abbreviates. Some of the acronyms we are using daily aren’t even acronyms, but more of an artificially created letter combination following some sort of standard. A couple of examples:
I think most of us agree that Jakarta Authentication is far more easy to remember than The Java Authentication Service Provider Interface for Containers.It may not be as precise and descriptive, but should that really be the requirement of the name? Wouldn’t it be better to have a name that we can remember and use in daily talk?
Think about Jakarta REST versus Java™ API for RESTful Web Services. I don’t think anyone ever uses the long name, but rather the abbreviation/acronym JAX-RS. Which isn’t even an acronym! It is just some collection of letters to fit into the JAX-* naming standard used by Sun back in the J2EE days.
The Java™ Message Service specification covers create, send receive and read messages. So it is much more than just a message service. In this case, Jakarta Messaging would be a much more descriptive name.
Please join the discussion by commenting on the issue related to the particular specification you are interested in. If you are the first commenting on an issue, please move it to the In Progress column. I will try to keep the status updated, but all help is welcome.
I am positive to renaming the specifications even if it is a lot of work and may seem like an unnecessary use of resources. It is an opportunity to fix something to the better in one go and this is probably the perfect time to do it.
Those of you following Jakarta EE probably know that the upcoming Jakarta EE 8 release will be functionally equivalent to Java EE 8. The reason for this is that we want to prove that the transfer from Oracle is complete and that we are able to produce the processes, specifications, test suites and a compatible implementation through the Eclipse Foundation.
So far Eclipse GlassFish 5.1 has been released and certified as Java EE 8 compatible. The next step is to set everything up for Jakarta EE 8 and release Eclipse GlassFish 5.2 as Jakarta EE 8 compatible.
One of the tasks that need to be done in order to release Jakarta EE 8 is to transform the existing Java EE specification documents to Jakarta EE. This will involve renaming the specifications according to the trademark agreement between Oracle and Eclipse Foundation*.
What I have described in this post is just a couple of the things that need to be done regarding the specifications in order to get Jakarta EE 8 out the door. There are a lot of other activities involving the TCK and not the least Eclipse GlassFish 5.2 that need to be done as well. But for now, the most critical item is to get through the legal hurdles of the trademark agreement and the transfer of the specification documents over to Eclipse Foundation.
*) The details of this agreement is yet to be defined when this blog post is published.