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. I 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.