Wednesday Mar 18, 2015

Java EE Management API 2.0 (JSR 373) Spins Up

As most of you know the initial wave of Java EE 8 JSRs have been underway for a little while now, including the platform JSR itself, CDI 2, JSON-B, JMS 2.1, Servlet 4, JAX-RS 2.1, MVC and JSF 2.3. Three more Java EE 8 JSRs have been more recent additions - Java EE Security, JSON-P 1.1 and Java EE Management 2. The Java EE Management API 2 (JSR 373) had been the last of these to truly spin up and I am happy to report that it too has now gone fully into high gear under the leadership of specification lead Martin Mares. Though the initial expert group has already formed, you should still feel free to join as an expert if you want - just go to the JSR page linked above to nominate yourself.

Although it does not seem to get as much press thus far, this JSR is actually potentially one of the most interesting and useful parts of Java EE 8. For those familiar, it is essentially a modernization of the very dated "J2EE Management" (JSR 77) API. The intention of the old API was to allow for managing all kinds of resources on an application server - JMS resources, JDBC resources, JCA resources, JavaMail resources, drivers, deployment artifacts, EJBs, Servlets, servers, domains and so on. For various reasons the JSR saw limited success - some have argued that the API was overly complex, abstract and cumbersome. It certainly seems dated today as it is largely centered on EJB remote interfaces.

The new management API is a great chance to take a fresh look at the problem domain using an updated tool-set. Unlike JSR 77, the new API will make use of REST, SSE and potentially WebSocket. For those familiar with the popular GlassFish REST management interface, we can reasonably expect to see something similar. From an industry standpoint, this means being able to work with all Java EE 8 application servers using a uniform, predictable cross-platform API from all kinds of tools from simple HTTP command-line clients to Chef and Puppet, whether on the cloud or on premise. Though not strictly part of JSR 77, the new management API is also slated to handle deploying artifacts instead of simply managing/monitoring them, which is also extremely useful (for the curious, this was the domain of another very dated relatively obscure API -  "J2EE Deployment" or JSR 88).

Note that you can always participate in a JSR without officially being part of the expert group by simply subscribing to the JSR user alias. In case of Java EE Management API 2.0 that alias is users at javaee-mgmt dot java dot net - go to the Java EE Management API 2.0 java.net project page to subscribe. Also remember that you can always contribute on an even more lightweight format through Adopt-a-JSR.

Wednesday Feb 11, 2015

Java EE @ Java2Days 2014

Java2Days 2014 was held on November 17-19 in Sofia, Bulgaria. It is far and away the largest Java conference in the Balkans region and now perhaps one of the most important conferences in Europe as a whole. This was another great year for this rapidly growing, vibrant event. It attracted a host of international and local speakers including Arun Gupta, Geertjan Wielenga, Roberto Cortez, Ivan St. Ivanov, Andy Gumbrecht and Andrew Lombardi. Topics included Java SE, Java EE, HTML5/JavaScript, mobile, OSGi, IoT and the cloud. I am extremely grateful that the organizers invited me again this year and very glad that I was able to accept.

Java EE had a strong showing this year:

  • What's Coming in Java EE 8 - me
  • Nuts and Bolts of WebSocket - Arun
  • Java EE 7 Hands-on Lab - Arun, Ivan and me
  • Apache Tomcat to Apache TomEE in 1-n Steps - Andy Gumbrecht
  • Java EE 7 Batch Processing in the Real World - Roberto and Ivan
  • Coding for Desktop and Mobile with HTML5 and Java EE 7 - Geertjan
  • JavaScript/HTML5 Rich Clients Using Java EE 7 - me, Ivan
  • Forge and Arquillian Hands-on Lab - Ivan, me
  • Why Open Standards and Java/EE Matter (to You) - me

More details on the sessions and Java2Days, including the slide decks, video and code, posted on my personal blog.

Thursday Jan 22, 2015

Java EE @ JMaghreb 2014

JMaghreb 2014 was held on November 4-6. Organized by the Morocco JUG, JMaghreb is one of the largest Java developer conferences in North Africa. This was yet another brilliant year for the conference. Speakers included Patrick Curran, Werner Keil, Johan Vos, Mohamed Taman, Hazem Saleh, Paul Bakker, Romain Manni-Bucau, Abdelmonaim Remani, Simon Ritter, Angela Caicedo and Mike Milinkovich. Topics included Java SE, Java EE, JavaFX, HTML5/JavaScript, mobile, NoSQL, OSGi, Big Data and the cloud. I am extremely grateful that the organizers invited me and very glad that I was able to accept.

I delivered talks on open standards/the JCP, aligning the JavaScript ecosystem with Java EE 7, aligning Java EE with Reactive Programming and Java EE 8. More details on the sessions and JMaghreb, including the slide decks and code, posted on my personal blog.

Thursday Jan 08, 2015

Initial milestone of JSF 2.3

The JSF Expert Group has started to work actively on the next version of the JSF specification (JSF 2.3 - JSR 372) that is slated for inclusion in Java EE 8.  We are still far from the planned date for the finalisation of the specification but we can already see progress as they are being made.  The initial milestone of Mojarra (JSF Reference Implementation) has just been released (download it here).  The Release Notes describes the bugs fixed but also the new features introduced in this milestone.  And from that list, we can see that a lot of focus is put around improving the JSF/CDI integration.

So despite the fact that we are in the early days of JSF 2.3, it is already possible to test some of the new features.  And since Mojarra is open source, it is also possible to use, at any time, the current Mojarra snapshot.  Josh Juneau who is a JSF 2.3 EG member has written a post explaining how to build Mojarra directly from the sources.  So feel free to give JSF 2.3 a(n early) try and provide feedback, this is important for the evolution of the JSF specification. 

We have the usual fine print to conclude, we are still far from the finalization of JSF 2.3, a lot of things will evolve and this is clearly 'work in progress' but transparency is important!

Wednesday Dec 10, 2014

Adopt-a-JSR for Java EE 8 Spinning Up

As some of you may be aware, Adopt-a-JSR was a very innovative JUG-led program that was initiated during the later parts of the Java EE 7 time-frame. The goal of the program is to make it as easy as possible for rank-and-file Java developers to contribute to the JCP through their local Java User Groups. By all accounts the program was successful as to a good number of JUGs adopting Java EE 7 JSRs. However we should aim a lot higher for Java EE 8 and Adopt-a-JSR. There is no reason not to hope that every major JUG worldwide should adopt at least one Java EE 8 JSR. Indeed although it is still very early a number of JUGs have already committed to helping with defining the next major revision of the platform including the London Java Community, Egypt JUG, Morocco JUG, the Japan Java User Group, Java Hellenic User Group and many others.

The Java EE/GlassFish team, JCP folks like Heather VanCura and the JUG community itself is trying to do as much as we all can to ensure the success for Adopt-a-JSR for Java EE 8:

  • We put together a page dedicated to Adopt-a-JSR for Java EE on glassfish.org. This page should be your first stop if contributing to Java EE 8 JSRs via the program interests you. We will make a point to keep the page up-to-date throughout the life-cycle of Java EE 8.
  • Heather, spec lead Ed Burns, JUG leader Mohamed Taman and I presented a talk on Adopt-a-JSR for Java EE at JavaOne 2014. Heather covered the Adopt-a-JSR program at a high level, Ed talked about the program from the perspective of a spec lead while Mohamed covered the adopter perspective. I finished by talking about Adopt-a-JSR in the specific context of Java EE 8. Video of the talk should be available soon and we will highlight it here as soon as we can.
  • Both I and Patrick Curran highlighted the program during our keynotes at JMaghreb and Java2Days (stay tuned for trip reports).
  • Heather has been and will continue to organize meetings (especially with spec leads) to keep promoting Adopt-a-JSR. Most recently Heather hosted an open meeting with Java EE 8 platform spec lead Linda DeMichiel. Heather blogged about the meetings here and posted the slides. The next meeting will be on December 19th at 10 AM Pacific time with Ed Burns and Manfred Riem, so stay tuned (details on how to join the meetings are on Heather's post).
  • Java EE/GlassFish author, speaker and advocate Josh Juneau is leading a meeting on Adopt-a-JSR for his local Chicago JUG in January.

You can help us too by spreading the word on Adopt-a-JSR to your local JUG. If you are interested, never hesitate to reach out as always.

Thursday Nov 27, 2014

JSR 375: Java EE Security API

Java EE has been used to develop and run enterprise applications securely since years.  Obviously, Java EE and its containers are just parts of the global security equation. When we zoom at the Java EE layer, we see that some of the security capabilities are backed into the specification while others security features are proprietary and specific to the different Java EE implementations.  Sometime, some of the security capabilities are also external add-on's (e.g. 3rd party libraries).  Security is not a self-contained matter as interactions between different components are often required (e.g. a Java EE Application Server needs to interact with an LDAP server).  Things also change when we go from an on-premises deployment to a cloud based deployment.  Finally, portability is never simple when it comes to security.

Java EE needs to evolve to stay relevant and clearly, if we look at the feedback from the Java EE 8 Community Survey, security is an area that could be improved.  And that is the goal of JSR 375 (Java EE Security API) which has just been submitted to the JCP for review.  JSR 375 is slated for inclusion in Java EE 8, its initial scope is based on the community survey feedback, on issues and RFEs filled against the Java EE specifications, on various exchanges EG members had overtime and also on various informal discussions we had during conferences, etc.

The JSR proposal gives a more detailed overview of what it will try to achieve.  In short, JSR 375’s goal is to simplify, standardize, and modernize the Security API across the platform in different area.

  • User Management: Standardization of a ’user service’ API which would enable an application to perform user management operations (e.g. create a user). The ‘user service’ would rely on a ‘user source’ which would be an abstraction of a physical user store (e.g. LDAP, data-bases, etc.).  The user service would be configurable to match the deployment requirements.
  • Password Aliasing: Standardization of syntax for pointing (alias) to passwords stored in a (secure) password repository.  This password repository might then be bundled with an application (e.g. think cloud deployment).
  • Role Mapping: Definition and standardization of a ‘role service’ API that would enable an application to perform various role mapping operations (e.g. querying a group role).  This would be done via different role mappers (e.g. LDAP, files) that would be adaptable based on the environment’s needs.
  • Authorization: Definition of a new CDI interceptor annotation that would be used to preform application-domain rules at the method level.
  • Authentication: Several enhancements are also planned around authentication (e.g. the ability for a web application to offers different authentication methods).

This is the just of overview of the initial scope. In addition, the Experts Group will also have to look at how some of the Java EE orthogonal technologies (e.g. CDI events, Expression Language, etc.) can be leveraged in order to simplify the use of those new APIs.  To know more about this JSR, make sure to read the JSR 375 proposal. You can also watch the replay of the "Java EE 8 Overview" that Linda DeMichiel gave during JavaOne as she has touched some of those ideas during her talk.

JSR 375 has entered the JCP review period; the next step should then be the approval ballot period. And if it passes this ballot, the Experts Group will be formed and the real works (and discussions) will start!   So we are just at the beginning of this effort but it’s nice to see the different pieces of Java EE 8 being put in place...

Wednesday Nov 26, 2014

JMS2 + JCP @ Chicago JUG

On September 4th, I spoke at the Chicago Java User Group on both JMS 2 as well as the basics of the JCP program. Spearheaded by the very capable likes of Freddy Guime and Bob Paulin the Chicago JUG has grown to become one of the most important Java User Groups in the world - both in terms of size, importance and impact. I am proud to say this is my second time to the JUG - a few months ago they had me speak on Java EE 7. My visit this time was very generously sponsored by Jay Zimmerman of the No Fluff Just Stuff (NFJS) tour. NFJS has always made an effort to support Java User Groups around the US.

I started the evening out with my JMS 2 talk (slides below). I also covered some of the possibilities for JMS 2.1.

I spent the last half-hour or so giving a very high level overview of the JCP program. I essentially borrowed Heather VanCura's slides (my own slides on the topic are rather old and developed when I was still an independent). Heather's slides can be found on SlideShare. The Chicago JUG has a very active interest in contributing to the JCP, which is why they had me speak on the topic. In fact with some help from US based Java EE/GlassFish advocate Josh Juneau they will soon be adopting one or more of the Java EE 8 JSRs via Adopt-a-JSR. The Java EE community is very lucky to have Josh's presence in the greater Chicago area. Josh is already an incredibly prolific author and blogger - it is awesome to see him become more prominent as a speaker as well including at JavaOne 2015 (and of course at his own local Chicago JUG).

It was great to be at the Chicago JUG and I hope to return sooner rather than later to the Windy City!

Monday Sep 22, 2014

Meet the Java EE 8 Experts at JavaOne

During JavaOne, you will have many occasions to discuss with different Java EE Specification Leads or other key Java EE staff:

This year, we have also arranged a Meet the Experts area. It is a designated space in the JavaHub where most of the Specification Leads will be present at a dedicated time (see schedule below). Oracle's Java EE Evangelists and Heather VanCura from the JCP will also be present. It will be the ideal place to carry on informal conversations about Java EE8. Also, keep in mind that the various Expert Groups are being formed so it is also the perfect time to ask what it takes to join an EG!

Monday, September 29 (Dedicated pavilion hours: 1:30-2:30 PM)

10-11 AM  Bruno Borges  Adopt-a-JSR for Java EE 8, any Java EE 8 technologies
11-12 PM  Martin Grebac  JSON-B
12-1 PM  Kin-man Chung  JSON-P and EL
1-2 PM

 Marek Potociar

 Pavel Bucek 

 JAX-RS 2.1

 WebSocket 1.1

2-3 PM  Linda DeMichiel  Java EE 8
4-5 PM  Reza Rahman  Adopt-a-JSR for Java EE 8, any Java EE 8 technologies

Tuesday, September 30 (Dedicated pavilion hours: 1:30-2:30 PM)

10-11 AM  Heather VanCura  JCP/JCP.Next (JSR 364), Adopt-a-JSR
11-12 PM  Martin Mares  Java EE Management
12-1 PM  Nigel Deakin  JMS 2.1
1-2 PM  Reza Rahman  Adopt-a-JSR for Java EE 8, any Java EE 8 technologies
2-3 PM  Ed Burns, Shing Wai Chan  JSF 2.3 and Servlets 4.0
4-5 PM  Marek Potociar  JAX-RS 2.1

Wednesday, October 1 (Dedicated pavilion hours: 2:00-3:00 PM)

12-1 PM  Brian Oliver  JCache
1-2 PM  David Delabassée  Adopt-a-JSR for Java EE 8, any Java EE 8 technologies
2-3 PM  Manfred Riem  MVC 1.0 and JSF 2.3

Friday Sep 05, 2014

JCP News (August)

Welcome to the third instalment of the JCP news focused on the server side. July was busy but August has been busy as well!

A lot of things has happened around Java EE 8 during August!

JSR 365: Contexts and Dependency Injection for Java 2.0 has passed has passed the EC JSR Approval Ballot. That means that the EG can now be formed and start to work on the specification!

In addition, the following new JSRs have been submitted for review (review closes on Sept. 8), they should then go to the EC for JSR Approval Ballot (Sept. 9-22):

  • JSR 366: Java Platform, Enterprise Edition 8 (Java EE 8)
  • JSR 367: Java API for JSON Binding (JSON-B)
  • JSR 368: Java Message Service 2.1
  • JSR 369: Java Servlet 4.0
  • JSR 370: Java API for RESTful Web Services (JAX-RS 2.1)
  • JSR 371: Model-View-Controller (MVC 1.0)
  • JSR 372: JavaServer Faces (JSF 2.3)

On the Java EE 7 front, 3 APIs are going through the Maintenance Release process:

And finally some quick updates on the JCP itself to conclude this August overview:

  • C2B2 has joined the JCP as a Corporate Member.  
  • JSR 364 (Broadening JCP Membership) has completed the Early Draft Review, a Public Review should be submitted in September.
  • The JCP EC Nominations will be open in September so if you have an interest in participating in the JCP EC, read this entry and get yourself prepared.
  • The nominations of the 12th Annual JCP Awards have been announced, the winners will be announced during the JCP Party at JavaOne (see here). 

Thursday Jun 12, 2014

Java EE 7 turns one today!

"Tell me and I forget. Teach me and I remember. Involve me and I learn."
Today marks the first year anniversary of Java EE 7. The JSR 342 specification was finalised on May 28, 2013 with the official launch taking place on June 12, 2013 (original press release).

As of today, there are already 3 Java EE 7 compatible Application Servers, coming from different 'vendors' (Oracle, TmaxSoft and Red Hat). Two of those Java EE 7 Application Servers are free and open source. We expect the list of Java EE 7 compatible Application Servers to grow over the coming months.


Source: RebelLabs - 'Java Tools and Technologies Landscape for 2014'

According to a recent independent survey, one third of the Java EE users who participated in that survey is already using Java EE 7. This is a good sign but it also means that a lot of people are not yet on Java EE 7. So if you haven't yet embarked on Java EE 7, now is really the time to do so!

There are various ways to learn Java EE 7, in no particular order ...
  • Continue to read The Aquarium. Through this blog, we are relaying Java EE news but we are also doing our best to highlight relevant technical contents such as articles, community tutorials, etc.
  • Watch the GlassFish YouTube channel. Amongst others, it contains the different videos of the Java EE 7 launch, those videos will give you good technical update on Java EE and its different components specifications (JMS 2.0, JAX-RS 2.0, EJB 3.2, etc.)
  • Take a formal training. Oracle University is starting to roll-out Java EE 7 trainings like the 'Java EE 7: New Features' class. 
  • Attend conferences and JUGs sessions. On that note, we have spent a lot of time to create a strong JavaOne 'Server-Side Java' track. It's still possible to benefit from the early bird JavaOne pricing but don't wait too much!
  • Read books. There are more than 25 (!) books related to Java EE 7 or to one of the Java EE 7 component specification. 

There are many more ways to learn Java EE but if I have to suggest one and only one way, I would recommend the Java EE 7 Tutorial. It's exhaustive and clear, it's free and it continues to evolve.

And finally as the introductory quote suggest, participation is key to learning. Participate in JUGs,  participate in Adopt-a-JSR, get involved in the different open source communities evolving around Java EE, participate in the JCP... in one word, participate!

Wednesday Jun 04, 2014

Java EE 8 update

Planning for Java EE 8 is now well underway. As you know, a few weeks ago, we conducted a three part Java EE 8 Community Survey (you can find the final summary here). The data gathered have been very influential for the next steps. You can now expect over the coming weeks and months to see updates on the various specifications that compose the Java EE platform.

Some Specification Leads are busy gathering additional feedback regarding what they should focus their efforts on (e.g. CDI 2 survey). Other Specification Leads have already publicly exposed what they think should be one of the focus for the evolution of the specification they lead.  For example, adding Server-Sent Events (SSE) support in JAX-RS is being discussed here and adding MVC support is being discussed here. Please remember that the fact we are now discussing any feature does not ensure that it will be included in the proposal, nor in any particular update to Java EE. We can expect additional enhancements, changes and evolution as we get closer to the finalization of the different specifications... and there is still a long way to go with these specification proposals!

Linda DeMichiel, Java EE Co-Specification Lead, has recently posted a draft proposal for the Java EE 8 Platform specification. Linda's goal is to recruit people and companies supporting this proposal before submitting it to the JCP.

This draft proposal is very interesting reading as it contains relevant information on the plans for Java EE 8 such as :

  • The themes:
    • Support for the latest web standards (eg. HTTP 2.0) 
    • Continue to work on ease of development
    • Improve the infrastructure for cloud support
    • Alignment with Java SE 8
  • New JSRs to be added to the platform:
    • J-Cache
    • Java API for JSON Binding
    • Java Configuration
  • Plans for the Web Profile
  • Plans on technologies to prune in Java EE 8, ...

So if you haven't done it yet, I really encourage you to read the Java EE 8 draft proposal!

Our goal for the Java EE 8 specification is for it to be finalized in the second half of 2016. It is important to note that we are in the early days of Java EE 8 and at this stage everything (themes, content, timing, etc.) is preliminary. Everything still needs to be discussed, challenged and agreed within the different Java Community Process (JCP) Experts Groups (EGs). Some EGs that still need to be formed! It could also means that the road-map will have to be adjusted to follow the progress being made in the different EGs.

Cameron Purdy, Vice President of Development at Oracle responsible for the Java EE platform, recently shared the Java EE 8 road-map at Java Day Tokyo 2014. You can view the keynote here.

This is also a good occasion to remind you that participation within those upcoming JCP Experts Groups is encouraged. Contributing in an EG is an effective lever to influence what Java EE 8 will become! Finally, as things get more concrete, we will share details on how to engage in the different Java EE 8 related Adopt-a-JSR initiatives, another way to contribute. You can also read other posts related to Java EE 8, here at The Aquarium blog. Just look for articles with the 'javaee8' tag.

Note : this post is also available in Japanese here.

Wednesday May 28, 2014

Adding SSE support in Java EE 8

SSE (Server-Sent Event) is a standard mechanism used to push, over HTTP, server notifications to clients.  SSE is often compared to WebSocket as they are both supported in HTML 5 and they both provide the server a way to push information to their clients but they are different too! See here for some of the pros and cons of using one or the other.

For REST application, SSE can be quite complementary as it offers an effective solution for a one-way publish-subscribe model, i.e. a REST client can 'subscribe' and get SSE based notifications from a REST endpoint. As a matter of fact, Jersey (JAX-RS Reference Implementation) already support SSE since quite some time (see the Jersey documentation for more details).

There might also be some cases where one might want to use SSE directly from the Servlet API. Sending SSE notifications using the Servlet API is relatively straight forward. To give you an idea, check here for 2 SSE examples based on the Servlet 3.1 API. 

We are thinking about adding SSE support in Java EE 8 but the question is where as there are several options, in the platform, where SSE could potentially be supported:
  • the Servlet API
  • the WebSocket API
  • JAX-RS
  • or even having a dedicated SSE API, and thus a dedicated JSR too!
Santiago Pericas-Geertsen (JAX-RS Co-Spec Lead) conducted an initial investigation around that question. You can find the arguments for the different options and Santiago's findings here.

So at this stage JAX-RS seems to be a good choice to support SSE in Java EE. This will obviously be discussed in the respective JCP Expert Groups but what is your opinion on this question?

Thursday Mar 13, 2014

Participate in the Future of Java

"The best way to predict the future is to invent it." (Alan Kay)

Sometime, some people tends to overlook a critical element of the Java ecosystem, i.e. the Java Community Process. The JCP is the mechanism for developing standard technical specifications for Java technology. The JCP is clearly one of the key pillar of the whole Java ecosystem.

Heather VanCura who manages the JCP Program Office has recently done a presentation at the Israel JUG. Heather's slide deck (see here) is really a useful ressource as it answers a lot of JCP related questions, it's almost a "FAQ on slides".

In her slides, Heather addresses questions such as :

  • What is the Executive Committee? How it operates?
  • The different levels of participation
  • The different roles within the JCP
  • The different deliverables of an Expert Group
  • What has the JCP done to be as open as possible?
  • How the JCP is evolving ("JCP.next")?
  • ...

And more importantly, it also explain why you should get involved in the JCP. Being involved in the JCP, at any level, allows anyone to define the future of Java!

Monday Dec 09, 2013

We need your help! Java EE 8 Survey - Part 1

As we start to plan for the next revision of the Java EE Platform (Java EE 8), we would like to get input from the community on the relative importance of some of the features that we might add.

Please participate in the Java EE 8 features survey to let your voice be heard and help us prepare the future of Java EE, it shouldn't take you more than a few minutes! 

This is the first part of a two-part survey. We'll be announcing part 2 in the beginning of the new year. So again, if you want to help shaping the future of Java EE, please participate in the survey.

Thursday Oct 17, 2013

How You Helped Shape Java EE 7...

For many of us working with the JCP for years, the commitment to transparency and openness is very clear. For others, perhaps the most visible sign to date of this high regard for grassroots level input is a survey on Java EE 7 gathered a few months ago. The survey was designed to get open feedback on a number of critical issues central to the Java EE 7 umbrella specification including what APIs to include in the standard. The survey was highly successful with a large number of high quality responses.

With Java EE 7 under our belt and the horizons for Java EE 8 emerging, this is a good time to thank everyone that took the survey once again for their thoughts and let you know what the impact of your voice actually was. I've posted the details on my personal blog. I hope you are encouraged by how your input to the survey helped shape Java EE 7 and continues to shape Java EE 8. Maybe now is the time for you to get more involved :-)?