JavaOne 2014 San Francisco was held October 25 – 29. I am proud to say this is my eight JavaOne as an attendee, my sixth one as a speaker, my third one as an Oracle employee, my second one as a member of the content committee and my first one as a track lead. I think this was a particularly good year for JavaOne in many ways and it's certainly been a privilege to try to do justice to the crucial role of Java EE track lead. In this hopefully relatively brief post I'll share my thoughts, observations and experiences at JavaOne 2014. The astute among you may have noticed that this post is belated. It's a reflection of the fact that's it's been a very hectic few months in terms of US and International conferences and in fact it'll be the very worthy first of a handful of belated trip reports now that the seemingly unofficial Java conference season towards the year's end is over.
A Look to the Past, A Look Ahead
There's very little doubt JavaOne is the largest and most important Java conference in the world. In fact it is critical to continuing to strengthen and growing the Java ecosystem itself. Having taken part in organizing a few other fairly large conferences and attending/speaking at numerous others, the JavaOne content is definitely of outstanding quality even as compared with many other conferences of similar magnitude. It's clear the best and the brightest in the Java ecosystem still see participating in JavaOne as a badge of honor. In terms of quantity, JavaOne beyond any doubt has the largest concentration of Java content anywhere. That all being said there's no denying the fact that JavaOne today is a relative shadow of what it used to be in the early days of Java. Perhaps to some degree that's alright. After all Java is not a spring chicken debutante any more and Java is probably the most widely covered topic at events worldwide today. Nonetheless JavaOne is the single most prestigious gathering of the minds with a sole focus on all things Java. Keeping that fact in mind we must do everything that we reasonably can to keep it the magnate event for Java developers everywhere. As they say, it is far more difficult to stay on top than to get there. To that end we did a few things differently this year that seems to have paid off.
How JavaOne 2014 was Different
There were a number of important encouraging signs from the very beginning for JavaOne 2014. We had the highest number of JavaOne CFP submissions in the recent few years. In fact the CFP process was so effective that unlike many previous years there wasn't a need to extend the CFP deadline. As a net result we at least maintained or improved upon both the quality and quantity of content. The event was highly professionally run as it always has been in terms of venue, scheduling and organization. Most encouragingly we grew the attendance numbers at a more rapid pace than we have in the past few years while still growing or maintaining a community feel. These are trajectories we should try and maintain in the coming years to keep JavaOne what it should really be.
There can be many reasons why we saw what we saw - economic cycles, pent up demand for developer training, a desire to learn more about the Java SE 8 and Java EE 7 releases, a desire to preview the newly minted Java EE 8 or Java SE 9 effort and so on. We would like to hope the small handful of things we did differently at least helped in getting things in the right direction:
- We started the CFP process earlier, provided as much details as possible and kept the community in the loop with periodic updates. For the Java EE track, we did this via the Aquarium blog as well as the official JavaOne blog.
- JavaOne like many larger conferences has traditionally taken a very egalitarian (perhaps too egalitarian) approach to speakers. The reality as we all know though is that not all speakers are created equal. There are some speakers out there that deserve recognition by way of an individual invitation to speak at the conference on a topic of their choice. For the Java EE track we had a small number of these well-deserved speakers that bypassed the official CFP process altogether: Adam Bien, David Blevins, Patrycja Wegrzynowicz, Arun Gupta and Anatole Tresch. Besides these Java EE rock stars we also reached out to a much larger group of people and cordially invited them to join the CFP (you know who you are). We announced these rock stars and their talks as soon as we could.
- We required a video of either the submitted session or a brief overview of the session as part of the talk proposal. The goal of this was in fact to level the playing field for new or inexperienced speakers.
What we did in the Java EE Track
There are a few more things we did differently in the Java EE track specifically in addition to the general changes to JavaOne:
- The quality of the program committees is a crucial part of the overall quality of JavaOne that needs to improve far more. Ideally we should be aiming to minimize folks from vendors (Oracle included specially) and folks that are more "honorary" than "participatory" in favor of folks genuinely passionate about actively contributing to the Java EE track in the community - including folks that help put together other successful conferences. We made some gradual efforts towards this goal this year.
- In the same vein we did our best to trim down speakers and content from Oracle and other vendors in favor of folks from the community. This balance is crucial in keeping JavaOne the conference for the Java community and not a vendor sales conference.
- As soon as we could we recorded and promoted video interviews with key JavaOne speakers about their sessions via The Aquarium and the JavaOne blog. We tried to do as many interviews as we could right up until the beginning of the conference. The folks we had time to highlight this year: Arun Gupta, Adam Bien, David Blevins, Ed Burns, Antoine Sabot-Durand, Kito Mann and Greg Wilkins.
There were some specific goals that we wanted to accomplish in the track that we reached to various degrees:
Upcoming JSRs: One of the unique value propositions for JavaOne is that it is the best place to learn about what is ahead in terms of standard Java technologies right from the source - the spec leads themselves. This was particularly true this year with Java EE 8 JSRs submitted right before JavaOne or shortly thereafter. Luckily, we were able to put together a number of such sessions:
- Java EE 8
- Java EE 8 Panel
- Meet the Java EE Specification Leads
- Adopt-a-JSR for Java EE 7 and Java EE 8
- HTTP 2 Comes to Java: What Servlet 4 Means to You
- Java API for JSON Binding: Introduction and Update
- JSON Pointer and JSON Patch: Updates to the Java API for JSON Processing
- Let's Talk JAX-RS.next!
- The Path to CDI 2
- Model-View-Controller in Java EE 8
- What Do We Want in JMS 2.1?
- What's Next for JSF?
- What's Next for the WebSocket API?
Existing JSRs: In order to continue to grow the Java EE community, it is vitally important to cover existing JSRs at JavaOne, especially as they pertain to solving new and emerging problems. We had a number of such sessions at JavaOne, most led by the community itself:
- Java EE Game Changers
- Java EE 7 Recipes
- Using the New JCache
- JSF 2.2 in Action
- Introducing Contexts and Dependency Injection (CDI)
- Going Farther with CDI 1.2
- Java EE 7 Recipes for Concurrency
Real World Case Studies: As we grow the Java EE community it is becoming more and more important to highlight adoption stories, case studies and migrations from other technologies. Whatever the underlying factors this year was particularly good for this. In fact there were a number of such submissions that we could not accept this year that we hope will be resubmitted in the coming years:
- Java EE 6 Adoption in One of the World's Largest Online Financial Systems
- Migrating a JSF-Based Web Application from Spring 3 to Java EE 7 and CDI
- Bean Validation: Practical Examples from a Real-World Java EE 7 Application
- Lessons Learned from Real-World Deployments of Java EE 7
- eBay, Connecting Buyers and Sellers Globally via JavaServer Faces
- JPA Gotchas and Best Practices: Lessons from Overstock.com
- Java EE 7 Batch Processing in the Real World
Best Practices and Design Patterns: Beyond learning Java EE APIs, it is important to understand how to properly use them, which is where best practices and design patterns come in. This year we had a decent number of such sessions in the track but we could hope to improve upon this:
- 50 EJB 3 Best Practices in 50 Minutes
- Lazy Versus Eager Loading Strategies for JPA 2.1
- 50 JMS 2 Best Practices in 50 Minutes
- JavaServer Faces (JSF) Antipatterns and Best Practices
- Applied Domain-Driven Design Blueprints for Java EE
The Java EE Ecosystem: The ecosystem that builds upon Java EE APIs is critically important in keeping the platform strong. We always hope to highlight such content and wish there were more submissions along these lines:
- Apache TomEE, Java EE Web Profile, and More on Tomcat
- Prime Time JSF with PrimeFaces 5
- Testing Java EE Applications with Arquillian
- VRaptor 4: Agile Development with CDI in a Java EE World
Labs and Tutorials: Hands-on-Labs and tutorials are the unsung heroes of JavaOne. They provide opportunities to gain first hand experience with Java EE technologies, do deep dives or acquire basic knowledge. We didn't do too badly with labs and tutorials this year but this is another area where we could use better quality submissions:
- Java EE 101: An Introduction
- Java EE 7 Soup to Nuts
- Hybrid Mobile Development with Apache Cordova and Java EE 7
- Building Secure Applications with Java EE
- JSR107: Come, Code, Cache, Compute!
- Java Batch Hands-on Lab
- JSF 2.2 Deep Dive
Fostering Java EE Community Speakers: One of the key reasons attendees come to JavaOne is to hear from Oracle's Java technologists. Unsurprisingly the most well attended sessions tend to be led by Oracle speakers. This year was no exception and we had the usual strong showing of Oracle speakers: David Delabassee, Geertjan Wielenga, Bruno Borges, Yoshio Terada, Bill Shannon, Linda Demichiel, Ed Burns, Manfred Riem, Santiago Pericasgeertsen, Marek Potociar, Nigel Deakin, Pavel Bucek, Heather Vancura just to mention a few. In order to continue to grow the Java EE community however it is vitally important to foster a greater number of community speakers that advocate Java EE. While this has gotten much better over the years, we certainly need to do more at JavaOne to encourage speakers to take up Java EE as a topic. These are just some of the community speakers that we were proud to host this year:
- Adam Bien (JavaOne Rock Star, Java EE author, speaker, consultant)
- David Blevins (JavaOne Rock Star, Apache TomEE project lead)
- Patrycja Wegrzynowicz (CTO, Java EE researcher)
- Antoine Sabot-Durand (CDI specification lead, Red Hat)
- Kito Mann (Java EE author, speaker, consultant)
- Peter Pilgrim (Java EE author, speaker, consultant)
- Steve Millidge (London GlassFish User Group, C2B2 Consulting, Paraya)
- Ryan Cuprak (JavaOne Rock Star, Java EE author, speaker and JUG leader)
- David Heffelfinger (Java EE author, consultant)
- Josh Juneau (Java EE author)
- Mohamed Taman (Duke's Choice Award Winner, JUG leader)
- Ivan St. Ivanov (Arquillian Committer, JUG leader)
- Roberto Cortez (Consultant, JUG leader)
- Michael Remijan (Java EE author)
Besides presenting my own sessions (detailed below) I tried to audit as many sessions as I could (all content committee members are really supposed to do that but sadly few actually do). Everything I saw was good in the Java EE track and I scouted a few very good folks I have made a point to follow up with (you know who you are).
What I did at JavaOne
The last few JavaOnes have been fairly hectic for me and this year was no exception. Frankly that's exactly how I prefer it. As a speaker (and a host in this case) I am there to deliver as much as I possibly can for attendees. Here's what kept me busy this year:
Keynote Demo: This year I helped put together the keynote demo. The demo consisted of an end-to-end Java story for vehicle telemetry. At the lowest level, Java Embedded was used to collect vehicle sensor data such as speed, acceleration, geo-location, odometer reading, engine temperature and the like. Some of this data was incorporated into a pretty slick vehicle on-board dashboard interface using Java FX. All of the sensor data got forwarded real time to a centralized IoT (Internet of Things) gateway. The idea of the IoT gateway is that any third party could securely connect to the gateway to subscribe to collated vehicle sensor data instead of connecting directly to a vehicle. Once a third party endpoint is registered for subscription, sensor data is forwarded to the endpoint via REST calls. Third parties could be auto makers, insurers, service shops and so on. For the demo we created a third party back-end system that put the sensor data on a cool real time line graph on an HTML 5 page. The back-end would also issue warnings to the HTML 5 interface as well as issue an SMS message to any registered users when significant events are detected such as an engine or mechanical problem (for example an imminent required tire or oil change).
Sunday: Besides the keynote demo, I started JavaOne this year with hosting the Sunday GlassFish community events. This has long been the rallying point for GlassFish fans at JavaOne and this year was no exception. This year I broke up the GlassFish events into two distinct parts with a small break in the middle:
In the first session, John Clingan presented the GlassFish road map and we had the annual Oracle GlassFish executive panel. John talked about Java EE 7, GlassFish 4.1, Java EE 8 and GlassFish 5. The panel this year consisted of John, Mike Lehmann and Cameron Purdy. I asked a few set questions to the panel and then opened the panel up to community Q & A. If you haven't yet attended the GlassFish Sunday event, the panel is basically our annual town hall meeting. This session was packed (much more so than last year) and went extremely well.
In the second session we heard a GlassFish 4.1/Java EE 7 adoption story and did a deep dive into a GlassFish feature. The adoption story is something we've had for a few years now. This year we had a particularly cool story. Mohammed Taman shared the story of the first known real world deployment of Java EE 7 on GlassFish 4.1. Mohammed detailed a highly innovative and important project he helped develop for the United Nations High Commissioner for Refugees (UNHCR) and the World Food Program (WFP). The project won the Duke's Choice Award for 2014. Mohammed is a consultant, Morocco JUG member, Egypt JUG leader, JCP executive committee member and expert group member for multiple JSRs. He has been a very active participant in the Adopt-A-JSR, Adopt-OpenJDK, and FishCAT programs.
A new component to the community events we decided to add this year is a technical deep dive. We wanted to show the nuts-and-bolts of a cool GlassFish feature presented by an actual GlassFish engineer. Martin Mares shared the details on the GlassFish extensible command line framework. It is an extremely innovative feature that allows an end user to extend and customize the rich command line capabilities built into GlassFish. Martin is now leading the Java EE 8 Management JSR and much of the work he presented actually forms the basis of that upcoming standard.
Like the first session, the second session was also packed (again a significant improvement from last year when some folks left early). Like past years, we actually created a dedicated page on glassfish.org for the Sunday events that's worth checking out if you are interested.
In the evening we hosted the traditional GlassFish Party at the Thirsty Bear. The party was completely packed until the very end even despite the fact that we got a bigger space this year! I gave out a few Java EE 7 shirts and posters to a few very well deserving folks in the community (you know who you are).
Monday: I spent most of Monday auditing a handful of sessions on the Java EE track including Linda's Java EE 8 session, the batch lab and Josh's Java EE 7 recipes talk. Everything seemed to go extremely well. In the late afternoon I manned the "Meet the Experts" table. The idea here was to have folks talk to us about various upcoming Java EE 8 APIs as well as Adopt-a-JSR. The idea was good but I think we got only mixed results from the effort. Next year we may need to better publicize it. In the evening I went to the JCP party which is always lively and a great way to network with some key folks in the Java community. I skipped the GlassFish BoF this year as I had a subsequent very late BoF with Steve titled Calling All GlassFish Users and User Groups: Please Contribute to GlassFish. Steve and I talked about the various ways to contribute to GlassFish. Steve did a brief demo on how easy the GlassFish source code was to setup and build. Unfortunately the BoF was very lightly attended probably because it as so very late in the evening (9 PM - 10 PM).
The demo application code is posted on GitHub. The code should be a helpful resource if this development model is something that interests you. Do let me know if you need help with it but the instructions should be fairly self-explanatory. The talk was packed and seemed to be very well received.
Later that morning Heather, Ed, Mohamed and I had our session on Adopt-a-JSR + Java EE titled Adopt-a-JSR for Java EE 7 and Java EE 8. 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. The talk was very good but unfortunately only moderately attended mostly by folks already involved in the program in one way or the other. Next time we need to figure out how to better boost attendance for these kinds of talks at JavaOne. I audited a few more sessions after the talk before manning the "Meet the Experts" table once again after lunch.
Most of the rest of the afternoon I audited a few more sessions before heading over to Oracle OpenWorld for a BoF on using WebLogic 12.1.3 with Arquillian. The BoF was a joint effort between me and Aslak Knutsen (Arquillian project lead). Given that OpenWorld has a weak reputation for developer centric topics, our expectations were fairly low. To our surprise, the talk was pretty decently attended though the audience was definitely more aloof than at JavaOne with very few developers in the audience. I finished the day off with briefly going to the Tomitribe party and chatting with a few friends.
Wednesday: After the hectic Tuesday I felt pretty tired and thought I'd rest a bit the next morning and catch up with email before my next session. I arrived at JavaOne shortly before lunch and delivered my next talk in the afternoon on Cargo Tracker/Java EE + DDD. This talk basically overviews DDD and describes how DDD maps to Java EE using code examples/demos from the Cargo Tracker Java EE Blue Prints project. Below is the slide deck for the talk:
The talk was totally packed, there was very good audience interaction and I got some excellent feedback from a few folks afterwards. After the talk I headed over to a book signing for the second edition of EJB 3 in Action along with my co-authors Micheal and Ryan. It was great to get a chance to catch up with them and the book signing went well at the JavaOne book store. I did not really have much else scheduled for the day so I headed back to my hotel for a quiet evening preparing for the next and last day of JavaOne.
Thursday: The last day of the conference I started by attending the Java EE 8 panel in the morning. The panel went pretty well but was surprisingly modestly attended, especially compared to previous years. After the panel I audited a few more sessions including the one on migrating from Spring to Java EE 7. The session was very well attended and participated by other folks also apparently in the middle of such a migration. Let's hope those folks submit sessions sharing their experiences the coming years! I finished off the conference with my talk on effectively testing Java EE applications using Arquillian. The talk basically goes through each major Java EE API and demonstrates through code how the API could be tested using Arquillian. The slides for the talk is posted below:
The code for the talk is available on GitHub. If you are looking into testing Java EE applications using Arquillian, the code should be very helpful to you. Feel free to give me a holler if you need any help. The session was very well attended despite the fact that it was one of the last sessions of the conference and I got some very good feedback afterwards. It was the perfect way to end JavaOne 2014!
JavaOne 2014 will Come to Your Computer - for Free!
I want to remind all of you that we make a point to make JavaOne content openly available to all. Some of the recorded sessions have already been made available and more is on the way. In fact, we've already started highlighting these sessions on The Aquarium blog and will continue to do so in the next coming months, so do stay tuned.
On a more personal note, I did get to do something that's been on my to-do list for a while on this trip - hike Mount Diablo (yes, that's "Devil Mountain" in Spanish). The mountain so close to and so visible from the Bay area is pretty unique - although it's fairly short at only about 3,800 feet, it is said that you can see the second largest amount of the surface of the earth from it's tallest peak. That's because the area surrounding the mountain is incredible flat increasing visibility dramatically. This is also true of Mount Kilimanjaro - the place where you get to see the most amount of the surface of the earth (to top it off Mount Kilimanjaro is the tallest mountain in the African continent by a good margin). What I find really fascinating is actually the beautiful semi-arid landscape in the Diablo Mountain chain (see for yourself in the pictures I took below). I've seen it many a time while driving around the Bay area and it was awesome to finally see it up close and personal. If you ever plan to take the hike yourself be cautious - the hike is long and strenuous with many successive rapid elevation changes both upward and downward.
All in all this was a great JavaOne that we hope we repeat or improve on in the coming years. Hopefully you'll make the JavaOne pilgrimage one of these days too if you haven't already? For those of you that did attend it would be great to hear what you though especially with regards to Java EE?