Skip navigation

With all of my formal JavaOne conference obligations satisfied, day four was dedicated to listening. Another day, another hotel. The community keynote had a little bit of everything and was in the San Francisco Marriott, bringing to four the total number of separate buildings I had to visit for ]]>is available at Oracle. The room was full, and Intel VP Michael Greene had an attentive audience for his portion of the keynote. The keynote quickly moved on to showcasing some highlights from the Java community over the last year. There was a great selection of awards, demos, and product announcements. I was happy to see Scratch style programming return to the Java platform in the form of SnapCode, demonstrated by its creator Jeff Martin. I feel that Scratch is the gold standard in this sort of environment, and I was very disappointed when they dropped Java in favor of Flash (as part of a broader move to an entirely cloud-based development environment, which I also didn't appreciate). If you had some of the same reservations, consider giving SnapCode a try. There were some other nifty demos all of which combined to give the attendees a positive impression about how fun and cool it is to develop on the Java Platform.

Mark Reinhold re-appeared and gave the rest of the technical keynote, allowing Brian Goetz to finish his interrupted content from Sunday. Oracle has helpfully produced a single streaming file with the content from both days. Mark and Brian's presentation was followed by a question and answer panel, facilitated by the twitter hashtag #j1qa and adding James Gosling, Brian Oliver and Charles Nutter as panelists. Perhaps we should have done this approach during the web framework smackdown. The most humorous question was regarding a suggestion to move OpenJDK to GitHub. Mark's satisfyingly definitive answer was "no". As usual with large-scale Q&A panels, there was not much depth and the questions bounced around a lot. It's always great to have James Gosling on hand for some part of JavaOne, and this year he pointed out that Java has come full circle, having been intended for "Internet of Things" from the start. I'll point out that Sun had a mass-market IoT device ten years ago in theform of the SunSPOT. Did you know that Oracle Labs continues the work on SunSPOT and you can still buy them for $399? The panel closed out with the traditional t-shirt cannon distribution. I give a special thanks to my old pal Vinicius Senger for catching one for me. In a nod to a more TED-style talk, (but a mere shadow of the glory days of Douglas Adams' JavaOne keynote) Andra Keay gave a nice talk about the dynamics of robot/human interactions. Sadly missing from the talk was any mention about my pet peeve in the whole robot revolution: the need to change how society values the output of human work in a world where robots do most of the work.

The conference orgnizers thoughtfully delayed the start of the rest of the sessions by 30 minutes to accomodate the lengthened keynote. This gave me time to get back over to Parc55 for CON2131: Java EE Community Update and Panel. Bruno Borges moderated. On the panel were my (skiplevels) boss Cameron Purdy, John Clingan, GlassFish Product Manager at Oracle, Kevin Sutter, Java EE Architect at IBM, Mark Little, RedHat VP, Adam Bien, famous Java EE consultant, and David Blevins founder of Tomitribe. Sadly missing from this year's panel was any representative from Pivotal. Bruno lead off the session with some slides and allowed the panelists to introduce themselves. Interestingly, the slides in the content catalog for this session are Mark Little's, not Bruno's. Nonetheless, Mark's slides are very informative, do check them out. The discussion rapidly focused on some current trends in enterprise Java software and how Java EE has responded to and will respond to these trends. Mark Little, in typical dry British fashion, observed that what we now call microservices is really just the latest name for SOA. This observation lead to an acknowledgement that the idea of a WAR file being deployed in a container is starting to give way to the idea of a deployable application that contains an executable runtime. I hope they post the audio for this session because there was a lot more that I'm not recalling.

It turned out that the next session I attended was the only purely technical Java EE based session I could make, but it was a good one. It was CON3389: Migrating a JSF-Based Web application from Spring 3 to Java EE 7 and CDI. The slides are in the content catalog. This session by Leander Reimer was an excellent case-study of how an existing JSF based web application that was built on Spring was migrated to a pure Java EE stack. It is common knowledge that Spring has risen to prominence by positioning itself as an alternative to Java EE. What is not so common knowledge is that there has always been significant interplay and cross-polination of ideas between Spring and Java EE. For example, did you know that JSF 1.0 had its own, XML based dependency injection mechanism way back in 2004, right around the time that Spring 1.0 was released? This sort of thing is not surprising since both stacks have been trying to solve the same kinds of problems, for the same kinds of developers, and there are only so many ways to skin a cat. This fact enabled Mr. Reimer and his team to successfully and quickly complete the migration. The main idea of the talk was to show that for every thing they had in their app using Spring, there was a corresponding way to do it in Java EE. This traversal of migration tasks served as a vehicle for pointing out several pitfalls they had to safely navigate to get to production. During the Q&A I asked Mr. Reimer a two part question. First, I asked why did they use JSF in the first place when many Spring shops just go with the built-in Spring MVC? His answer: PrimeFaces. Next, I asked him to speculate how much harder would the task have been had the UI been in Spring MVC instead of JSF. I was hoping the discussion might give my colleague Manfred Riem, also in the audience, a chance to bring up MVC 1.0. Instead, Mr. Reimer observed it wouldn't be that hard to write an integration layer on top of JSF that allows its use in an action-oriented manner. This was a skillfully executed talk with a compelling topic given from an in-the-trenches perspective. Bravo.

Way back in March when I attended JavaLand I saw an excellent session from my old pals Manfred Geiler and Thomas Spiegl from Irian. The session was about their new UI technology called Ankor. I requested they submit this session to JavaOne, and thankfully it was accepted as CON2403 - Reactive UIs with the MVVM Pattern. Ed Burns and Manfred GeilerEd Burns and Manfred GeilerI was unable to attend the talk as it conflicted with Mr. Reimer's but I did catch up with Manfred and Thomas after their session for a beer in Duke's cafe. This was a special anniversary for Manfred and I. Ten years ago, at JavaOne 2004, Manfred and I met when he attended my session on JSF 1.0. Manfred approached me and said, "Hey, I have an independent implementation of JSF," and I was thrilled. This, of course, was MyFaces. To commemorate these two meetings separated by ten years, at left you see Manfred and I at JavaOne 2004, and at right, with Thomas Spiegl, at JavaOne 2014.

My final session, in the final slot, was Mike Duigou's excellent CON6309 New Tricks for Old Dogs: Collections in Java 8. The slides haven't been posted yet, but do get them when they become available. Talks like this are really useful to expose you to the new features you really need in practice. Mike's session was really useful because he gave the perspective behind the design choices in these fundamental library classes that have contributed so much to the success of Java over the years. Sadly, I see that Mike has recently left Oracle but he's now working with James Gosling directly at his Liquid Robotics outfit. I wish you the best, Mike, but I'm sure we'll see you at JavaOne next year. I ran into Stuart Marks after Mike's session and he gave me a checkup on the knowledge I had absorbed, as seen at left.

To sum up JavaOne 2014, Oracle's consistent investment in promoting the Java Developer community is very evident. Though firmly in legacy territory, Java is still very vibrant and very new. The priorities behind the design choices in Java itself (innovation packaged in an enterprise ready programming environment) are on display in the community as well.

Day three was definitely the high point of the conference for me.  As anyone who has spoken at tech conferences knows, the point in time when all of one's sessions have been given is the turning point between tempered enjoyment and pure enjoyment of the conference.  I was blessed with the scheduling this year; I was all done after Wednesday.  This put me in a great frame of mind to enjoy the Oracle Appreciation Event.  Day three also saw the culmination of a long running project: the Web Framework Smackdown 2014 edition.


My friend and colleague Reza Rahman asked me to keep the web framework smackdown meme going for another year.  This year I called in quite a few favors to pull together a diverse group of celebrity panelists: Miško Hevery, creator of AngularJS at Google, Pete Hunt creator of ReactJS at Facebook, panelists preparing and Joonas Lehtinen, creator of Vaadin.  The panel was moderated by Neal Ford of ThoughtWorks.  I rounded out the panel representing JSF.  I've learned from previous smackdowns that a confident and comfortable moderator combined with a little prep time just before the panel are the keys to success.  We met at 11am for this purpose over Patxi's pizza. From the left you can see Neal Ford, Miško Hevery, myself, Joonas Lehtinen, and Pete Hunt.  I don't think Pete and Miško had met before, and it was interesting hearing them trade notes about their approaches to the performance of handling the model update side of their frameworks.  From what I gathered, they both see that feature as the most valuable aspect of their frameworks, and they both have spent significant time optimizing that part.  When it came time to take it on stage, we started by introducing our different approaches to the task of building a stateful and responsive user interface delivered in a web browser.  Angular and React are entirely client side, while JSF and Vaadin are entirely server side.  In spite of Neal's earlier recommendation that client side is the way of the future, Joonas and I made the case for where server side makes sense.  Briefly, reasons for favoring server side over client side include simplicity, security, integratability (such as mashups), and maintainability.  Client side is better when Facebook-sized scale is important, when JavaScript fluency is a non-issue, and when "modern" browsers are a given.  You'll have to check out the audio to get the full details.  My only complaint with the panel is that it really didn't get smackdown-ish at all.  I welcome comments about the client/server UI debate.  Perhaps we can get some smackdown action in the comments.


My last official obligation of the conference was my final booth duty in the Java EE both.  This session closed out the JavaOne exhibition, and as such the traffic was a bit light.  I was able to take a tour around the exhibition to obtain some schwag for my kids.  This year it was novel to see Target with a booth.  I've long been a fan (and shareholder) of Target, avoiding Wal*mart at all (unfortunately frequently too high) costs.  They were recruiting.  JavaOne is not a job fair, but it was still nice to see them representing Minneapolis, home of Facelets creator Jakob Hookom.


Geert and the NullPointers   Freddy, Frank, and Ed Booth duty done, it was on to a bit of fun in Duke's Cafe.  As I mentioned in my JavaOne 2014 Day One blog entry, Chicago JUG leader Freddy Guime had put together a band of musician Java enthusiasts called the NullPointers. They allowed me to sit in with them for some songs during their set at 5pm Wednesday.  This was a real honor and a great blast.  At left, from the left you see Zoran Severac, Mattias Karlsson, of JFokus, Geert Bevin of ZeroTurnaround, and Jim Weaver, Java Developer Advocate for Oracle.  At right, from the right, you see Freddy, Frank Greco of the New York Java Users Group and myself.  I think my keyboard stand was formerly in the Hackergarten.


The fun kept on rolling, with the Oracle Appreciation Event.  This used to be called the Customer Appreciation Event.  I'm not sure why they renamed it.  I would probably have given it a pass this year but for my 11 year old who is a big Macklemore fan.  I'm glad I went because Macklemore was very entertaining, and Aerosmith put on a great show as well.

The flow of my JavaOne 2014 experience had each day getting progressively less demanding. Day zero was an eight hour class. Day one was booth duty, a session , EG meeting, and a BOF. By day two, Tuesday, my involvement had reduced to presenting one session, participating in the Hackergarten and meet the experts areas, and a panel discussion.

The day began by co-presenting a session with Heather VanCura, Mohamed Taman and Reza Rahman about the Adopt-a-JSR program. This session, CON6289: Adopt-a-JSR for Java EE 7 and Java EE 8 was a lot of fun to prepare and present. We examined how the community has been involved with the JCP specifications that make up Java EE in the past few years, pointing to some sucessess and lessons learned. We looked at the topic from several perspectives. Heather presented the overview, Mohamed presented the Adoptor perspective, I presented the Adoptee perspective, and Reza presented the beneficiary perspective. With all these viewpoints on the problem, I think we had it covered pretty well. The slides have already been posted to the JavaOne content catalog.

As with yesterday's servlet session, we lead a parade from the conference room over to the Hilton, this time to the Hackergarten. The idea with the Hackergarten is to give attendees a zero-commitment opportunity to experiment with some new technology, in this case JCP specifications. As with Adopt-a-JSR, the Hackergarten is an opportunity for spec leads to leverage the excitement of the community to the benefit of their specification. I saw Anatole Tresch using the Hackergarten to advance the state of his Config JSR. During my time in the Hackergarten, I met with several people who were interested in Servlet and HTTP2, as well as meeting the JCP EC representive from ARM, who was very excited about recent developments in Java ME.

It was a short hop from the Hackergarten to the Meet the Java EE Experts table. While there, I had a nice conversation with Yara Senger (the heart of Java in Brazil), and a gentleman from the US Department of Education. He mentioned that uses JSF for a large number of different siloed applications and were interested in using the Resource Library Contracts and Faces Flows features of JSF 2.2 to separate the appearance of an application from its behavior.

Rounding out the technical content of the day, was the late addition to the Java EE schedule of my colleague Manfred Riem. Manfred presented a BOF about MVC 1.0, one of only two brand new JSRs in Java EE 8. Manfred presenting MVC 1.0 Manfred has uploaded the slides to the JavaOne content catalog. My take on this JSR, and I'm going to get admitedly biased here, is that with the addition of MVC and the soon to be filed Security 1.0 JSR Java EE will really be a complete stack for enterprise software development on the Java platform. I think of security and MVC as the last two missing pieces in the Java EE puzzle.

My last session obligation of the day was participation in BOF3031 Meet the Java EE Specification Leads. This BOF was schedule challeged, with an 8pm start time. At the start of the session we had more people on stage (13 spec leads) than in the audience, but thankfully a few more people trickled in, tipping the balance in favor of the audience. Even with the light attendence, there was useful dialog, on topics such as security, database migration during development, and testability. I was happy to have the involvement of Emmanual Bernard and Antoine Sabot-Durand on the panel. Without non-Oracle vendors, there is no JCP, so RedHat is a very important partner.

Update 1: added content about Greg Wilkin's Async IO session.


The first real day of the conference began with session one of two obligatory Oracle booth duty assignments.  Our booth had two foci: showing off Java EE 7 using the Cargo Tracker Blueprints Application and providing insight into our plans for Java EE 8.  To spice things up a bit and perhaps draw some people in, I brought along my kit-built homebrew Theremin, pictured here. Homebrew Theremin In my opinion, Java EE 8 is all about solidifying the platform by increasing cohesion between the already loosely copuled parts, while making incremental improvements to the parts of the platform that relate directly to building HTML5 delivered web applications and hosting them on the cloud. I've taken the liberty of uploading David Delabassee's excellent Java EE 8 slides to slideshare (Congrats on the $118 million payout, by the way.)  I always enjoy doing booth duty.  I look at it like I'm a TA doing office hours: if people want to catch me at JavaOne, this is the best time for it.


Another fun aspect of JavaOne is how it all blends together.  Towards the end of my booth duty session, my colleague and Servlet co-spec lead Shing Wai Chan stopped by and we put the finishing touches on our slides for "CON5898 - What Servlet 4.0 Means to You".  Of all the JavaOne conference sessions and BOFs in which I played a role this year, this was to be the most technical.  I've uploaded the slides to slideshareDavid Delabassee tells me this one will be in the first or second group to be uploaded to Parleys.  There were 162 pre-registrations for the session and I'd estimate there were about 200 in the room.  The session was notable for being the only Java EE session that featured Java SE 9 technical content.  After explaining the why and how of HTTP2, as well as how it may be exposed in the Servlet 4.0 API, I included some content on JEP110, the HTTP2 client for Java SE 9.  Both the client and server side are still very undefined at this point, but it's good to give people an insight into where we're going.


Directly after the Servlet 4.0 session, we lead a parade over to the Sutter conference room in the Hilton for the combined JSF 2.3/Servlet 4.0 EG kick-off meeting.  While a pale shadow of its former self, it was still a useful meeting.  The full audio has been uploaded to the project area on for both Servlet and JSF.  My intention for the meeting was to establish the scope for these two specs and decide on next steps.  One big take-away, suggested by Greg Wilkins, is the need for additional use cases for HTTP2 server push, aside from the obvious and important one of a web framework that has a-priori knowledge of the resources that are associated with a given web page. We all took the action item to look for such cases and share them with the EG.  Another notable item for the kick-off meeting was an interesting idea from Neil Griffin.  Neil suggested we might investigate using our announced dependency on Java SE 8 and its built-in JavaScript engine, to increase the dynamism of JSF apps.  Briefly, Neil's idea is to introduce a lifecycle phase after render-response that would do some processing on the rendered view to prepare it for quick display in the browser DOM, delivering a direct-to-DOM view of the page.  I asked Neil to think about it some more and consider sharing the idea on the EG list.


As a general rule, I like to listen at more than I talk, but today the only session I was able to attend was Greg Wilkins's CON2236 Async IO session.  The slides have already been posted at the JavaOne website.  Greg is an excellent speaker, do make a point of seeing this session when it comes up on Parleys.  Greg did an excellent job of explaining the gotchas of async IO programming, without any Responsive Manifesto hype.  Very interestingly, he did admit that the his original objections to some of the Async Servlet API during the JSR-340 expert group discussion proved to be unfounded and that he rather liked how the API turned out in the end.


JCP Party Picture Next on the agenda was the Annual JCP Awards Party.  The nominees and award winners are documented at < >.  There was some real competition in the events this year, but I'm happy to announce that Heather VanCura won the JCP Member/Participant of the year award.  Speaking as a fellow Oracle employee, we all owe a debt of gratitude to Heather and her colleagues for continuing to demonstrate the value of the Java Community Process within a very shareholder-value (that is, short-term value) focused company.  Standards pay dividends, but they tend to be long-term rather than short term.


This year continues the tradition started last year of hosting the event at the Cityscape area on the top floor of the San Francisco Hilton.  In the image at left you'll see Heather announcing the awards. You'll also notice some musical instruments.  These were furnished courtesy of JFrog and played by a group fronted by Geert Bevin. The group was a pick-up band composed of members of the Java Community and went by the name of, "The NullPointers".  In addition to Geert, the band included Freddy Guime of the Chicago Java Users Group, Frank Greco of the New York Java Users Group, Jim Weaver, Java Developer Advocate for Oracle, Zoran Severac, Cesar Hernandez, and Mattias Karlsson, of JFokus.  I was going to sit-in on keyboard, but, as mentioned above, things blend together at JavaOne, and I had to leave the party early to present my JSF 2.3 BOF over at Moscone.  Thankfully the band gave me another chance to sit in during their 2nd performance on Wednesday.  It was sub-optimal to have to leave such a great event, but the community is more important than the community, in this case, so off to Moscone I went.


This was the first year since the Oracle acquisition that any part of JavaOne has been held in Moscone.  This year only the Mondy night BOFs were held there, but I'm hoping it's the beginning of a trend.  This being a BOF, rather than a technical session, I incorporated content from two JSF Expert Group Members, Kito Mann and Ian Hlavats.  My slides are at slideshare, as well as Ian's. The basic idea for JSF 2.3 is to provide a vehicle to attend to the fit and finish of the JSF spec, addressing JSF customer issues that have accrued over the years, and give the community a vehicle to propose, drive, and implement features that they feel are important, subject to final-cut from Manfred and I.  The former category will include things like multi-component validation, Ajax method invocation, and better CDI integration.  The latter category may include things like Kito's proposed JSON component rendering and Ian's proposed Twitter Bootstrap integration.  Again, the emphasis in the latter category is for the community to do the heavy lifting, with oversight, veto authority and integration help from Oracle.


That's not a bad first day!  Booth duty, technical session, EG meeting, JCP Party, and BOF.

Filter Blog

By date: