JavaOne: Another Year, Another Step Forward

DZone 's Guide to

JavaOne: Another Year, Another Step Forward

Read this retrospective on JavaOne along with some materials from a few presentations.

· Java Zone ·
Free Resource

JavaOne 2015 San Francisco was held October 25-29. I am proud to say this is my ninth JavaOne as an attendee, my seventh one as a speaker, my fourth one as an Oracle employee, my third one as a member of the content committee and my second one as a track lead. I think this was another great year for JavaOne and it is 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 2015. I'll also share all the materials that I presented at JavaOne this year towards the end of the post.

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 is no doubt JavaOne is the largest and most important Java conference in the world. It is critical to continuing to strengthen and grow the Java ecosystem. Having taken part in organizing a few other fairly large conferences and speaking at numerous others, the JavaOne content is definitely of outstanding quality. 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 has the largest concentration of Java content anywhere. As it is said, however, it is far more difficult to stay on top than to get there. Fortunately in the past few years we have been able to maintain an upward trajectory for JavaOne by continually improving whatever we can. To that end we did quite a few things differently last year and this year was no exception.

How JavaOne 2015 was Different
Last year we grew JavaOne attendance numbers at a much more rapid pace than we have in the past few years. This year the challenge was to maintain or improve upon that dramatic growth. We were fortunate that we did indeed see modest growth even this year. This was despite the fact that we did not have any new releases announced of either Java SE or Java EE at JavaOne. On the Java EE front the biggest announcement was full Java EE 7 support in WebLogic (announced here), as well as WebSphere (announced here). Red Hat also announced their work towards making JBoss EAP Java EE 7 certified adding to the existing Java EE 7 community support via WildFly (take a look at the JBoss EAP beta announcement here). It was great to see a number of real world Java EE 7 adoption stories presented including from Rakuten during the JavaOne keynote (more on that below and in future Aquarium entries).

We started the CFP process as early as we could, provided as much detail as possible and kept the community in the loop with periodic updates through blogs like the Aquarium. We pre-selected a small number of rock star speakers to bypass the CFP altogether. On the Java EE track we also reached out to a larger group of folks and cordially invited them to join the CFP (you know who you are). In the end we had a large number of high quality CFP submissions. As a result we managed to create a strong content offering. The event was highly professionally run as it always has been in terms of venue, scheduling and organization. We did do a few things differently that hopefully helped in keeping things in the right direction:

  • Collecting good quality and quantity of feedback has long been a challenge at JavaOne, especially with the amount of content we have. We may have arrived at the best solution this year - we introduced voting kiosks right outside each session room. Since this was our first deployment of the machines it did not go entirely smoothly. Some speakers noticed votes disappearing in the online speaker tool. This is now a known issue in the speaker tool and no votes were actually lost (speakers can request all their feedback data specifically if needed). A small handful of sessions indeed did not have data captured due to setup issues. Despite these issues we still got eight times more session feedback votes cast than previous years. This is critical for us to improve content for the conference in the coming years.
  • Some of you probably know Java celebrated it's twenty-year birthday earlier this year. Partly in recognition to this we did the JavaOne community keynote a bit differently this year. Normally this keynote is a place to celebrate innovative work in Java, usually highlighting many Duke's Choice award winners (click here to see this year's winners announced at JavaOne 2015). This year we decided to do something akin to a theatrical production consisting of a time travel journey through the past twenty years of Java with stops along the way to highlight important technology milestones in the platform. The keynote was a success with a large cast of familiar community members including Java Champions, JUG leaders and JCP members. It generated kind words such as "...it was the best community keynote in JavaOne history!" (Frank Greco, NY JUG leader) and "One of the highlights of this year’s JavaOne is the community keynote...what a show it was!" (Baruch Sadogursky, JFrog Evangelist). You can watch the full video of the community keynote here. I am proud to say I took part in the community keynote.

A few other new ideas we attempted this year included a youth education program on the Saturday prior to JavaOne similar to the highly successful Devoxx4Kids program as well as live streaming a selected set of sessions to the Java YouTube channel.

What we did in the Java EE Track
There are a few more things we did in the Java EE track specifically:

  • The quality of the program committees is a crucial part of the overall quality of JavaOne. I am very happy to say we had a very active committee this year in the Java EE track. We aimed to minimize the Oracle and vendor footprint in the committee in favor of folks in the community including folks that help put together other successful conferences. I wrote about this year's committee in detail prior to JavaOne. I also interviewed some committee members for the Aquarium. We will try to improve the committee further in subsequent years.
  • Just as we did last year 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.
  • Just as last year we promoted video interviews with some JavaOne speakers about their sessions via the Aquarium. 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: Ivar Grimstad, Bessem Hmidi and Kito Mann. We will try to do more of this in subsequent years.

There was some specific content that we wanted to have in the track that we got to various degrees:

Java EE 8: 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. We were able to put together a number of such sessions.

Best Practices/Design Patterns: Beyond learning Java EE APIs, it is critically important to understand how to effectively apply them in real life applications, which is where best practices and design patterns come in.

Real World Adoption Stories: As we grow the Java EE community it is more and more important to highlight adoption stories, case studies and migrations from other technologies. Last year was very good in this regard and I am happy to say this year was even better. 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.

The Java EE Ecosystem: The ecosystem that builds upon Java EE APIs is critically important in keeping the platform strong. This year was far better in this regard than previous years. We always hope to highlight such content and wish there were more submissions along these lines.

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 we had the usual strong showing of Oracle speakers: David Delabassee, Geertjan Wielenga, Bill Shannon, Linda Demichiel, Ed Burns, Manfred Riem, Santiago Pericasgeertsen, Nigel Deakin and 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 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 very proud to host this year:

  • Adam Bien (JavaOne Rock Star, Java EE author, Java Champion, speaker, consultant)
  • David Blevins (JavaOne Rock Star, Java Champion, Apache TomEE project lead)
  • Arun Gupta (JavaOne Rock Star, Java Champion, Java EE advocate, author, blogger, speaker)
  • Patrycja Wegrzynowicz (CTO, Java EE researcher)
  • Antoine Sabot-Durand (CDI specification lead, Red Hat)
  • Kito Mann (Java EE author, speaker, consultant)
  • Murat Yener (Java EE author, speaker, Java Champion)
  • Peter Pilgrim (Java EE author, Java Champion, speaker, consultant)
  • Steve Millidge (London GlassFish User Group, C2B2 Consulting, Paraya)
  • Ivar Grimstad (Java EE advocate, JCP expert, blogger, open source hacker, consultant)
  • Ryan Cuprak (JavaOne Rock Star, Java EE author, speaker and JUG leader)
  • David Heffelfinger (Java EE advocate, author, blogger, consultant)
  • Aslak Knutsen (Arquillian project lead, Red Hat)
  • Mohamed Taman (Java EE advocate, Java Champion, Duke's Choice Award Winner, JUG leader, consultant)
  • Roberto Cortez (Java EE advocate, JUG leader, blogger, open source hacker)
  • Alex Soto (Java EE advocate, speaker, blogger, open source hacker)
  • Matti Tahvonen (Developer Advocate, Vaadin)

We will be highlighting some of these sessions on the Aquarium in the next coming months including videos and slide decks (more on that below).

What I did at JavaOne
The last few JavaOnes have been fairly hectic for me and this year was no exception. Indeed this was the most busy JavaOne for me by far. 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:

Sunday: As in previous years I started JavaOne 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 we had quite a bit of time allocated to us on Sunday so we decided to do things a bit differently. Instead of focusing just on GlassFish we had four sessions covering both Java EE and GlassFish. The strategy turned out to be a success and we had much higher attendance than previous years. We will try to continue this strategy in the coming years.

In the first brief session Mike Lehmann presented the GlassFish/Java EE road map. Mike talked about GlassFish 4.1.1, Java EE 8 and GlassFish 5. The second session was titled "GlassFish Performance Tuning: Tips from the Field" and was presented by Steve Millidge (founder Payara, C2B2 Consulting). The third session slot was for David Blevins as well as Oleg Tsal-Tsalko and was titled "Evolving Java EE". They shared some interesting ideas for evolving Java EE APIs using featured introduced in Java SE 8. Adam Bien presented the last session of the day titled "Building Nanoservices with Java EE and Java 8". All of the sessions, particularly Adam's one, were very well attended. Indeed we had to move the room location twice to the largest space we could find to fit everyone that wanted to come listen to Adam!

In the evening we hosted the traditional GlassFish party at the Thirsty Bear. The party was completely packed until the very end as usual.

Monday: I kicked off the Java EE track Monday morning with my two-hour workshop titled "Java EE 7 in Action". It was a fully packed house with most folks staying to the very end. The workshop is something I've successfully delivered in the past. It uses Cargo Tracker but focuses on Java EE 7 usage instead of DDD and Java EE generally. I overview Java EE 7 at a high level, go through each API change and demo some selected features using Cargo Tracker. For each demo I explain the use case for the Java EE 7 feature in use and show actual running code. The slide deck is embedded below and the source PPT can be downloaded from here.

I have deliberately added detailed speaker notes to the source PPT so you should be able to go through the workshop yourself. You can also view the video recording for the entire workshop here.

Later in the afternoon I helped out David Heffelfinger with his popular hands-on lab titled "Java EE 101". The lab is so popular that in fact it is a repeat from last year! In addition it had such high demand that it was scheduled to be run twice this year! Both sessions were completely booked and ran very smoothly. The lab goes through the very basics of Java EE including JSF, CDI, JPA and EJB. I am seriously considering having David repeat the lab again next year. All the lab materials can be downloaded here. You should also check out David's blog entry on the lab here.

In the evening I went to the JCP party which is always lively and a great way to catch up with some key folks in the Java community. This year's JCP award winners were announced at the party including some key winners on the Java EE side of things. You can read my write-up on this year's winners here.

Tuesday: I started Tuesday out with repeating the Java EE 101 lab again in the morning. Towards noon I ran a hands-on lab on JMS 2 titled "Down-and-Dirty with JMS 2". My Turkish friends Salim Kayabasi and Hasan Keklik did an awesome job helping me prepare the materials and run the lab. The lab was packed and went pretty smoothly. The goal of the lab is to give attendees some first-hand experience with the primary changes in JMS 2. In the first hour or so I did a brief presentation overviewing JMS 2 and went over the JMS 2 Javadocs. The rest of the time attendees actually wrote JMS 2 code mostly by themselves. The slides I use are available on SlideShare (click here if you can't see the embedded slide deck).

JMS.Next(): JMS 2.0 and Beyond from Reza Rahman

The lab materials are hosted on GitHub for anyone to use. The lab uses NetBeans 8, GlassFish 4 and Arquillian. I've deliberately designed the lab materials to be fairly self-guided so you can definitely use the lab materials on your own (or perhaps even run the lab in your own company/JUG) . You are always welcome to reach out to me when needed. In the lab you'll basically be putting in code to finish a set of JUnit tests using JMS 2, starting from incomplete code with comments on what to do (don't worry, a completed solution is also posted :-)). There were a few good ideas to improve the lab that I hope to incorporate soon.

Later in the afternoon I co-presented a very cool session with another good Turkish friend - Murat Yener. The talk is titled "Java EE Revisits GoF Design Patterns" and is based on Murat's excellent book. The talk explores how modern Java EE incorporates many key GoF design patterns such as singleton, factory, session facade, observer and decorator. Java EE also directly or indirectly incorporates other patterns such as MVC, entity, DAO and DTO. I also discussed how DDD patterns fit seamlessly into Java EE (this is the subject of my other design pattern talk - Applied Domain-Driven Design Blue Prints for Java EE). The talk was completely packed with good Q & A throughout the session. The slides for the session are below (click here if you can't see the embedded slide deck).

Java EE Revisits GoF Design Patterns from Murat Yener

You can watch the video for the session here. I finished the day off with briefly going to the Tomitribe party and chatting with a few old friends.

Wednesday: After a hectic few days I was beginning to feel a bit tired and thought I'd rest a bit the 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 with Steve Millidge. This is one of my newest talks titled "Down-to-Earth Microservices with Java EE". The talk has two aims. The first is to try to do the right thing in explaining what microservices really are, what practical value they offer for most of us and when you should consider them (or not). The second aim is to demonstrate why Java EE makes perfect natural sense for developing sensible real world microservices, so called "monoliths" and everything in between. I also briefly explore the work that some parts of the Java EE community is doing to support what I lovingly call "microservices Nirvana" (spoiler: I don't think most of us can or need to achieve this Nirvana state). The slide deck for this talk is below (click here if you can't see the embedded slide deck):

I've done this talk a few times already. It is clearly popular, on the mark and well received - even with what I have traditionally observed to be a hostile audience. Unsurprisingly the talk was a full house and went well at JavaOne as well.

You can view the video of the talk here.

Thursday: Thursday was the last day of JavaOne 2015. In the morning I delivered one of my newer talks titled "Reactive Java EE - Let Me Count the Ways!". It aligns Java with core Reactive Programming principles. Though many people don't realize it, Java EE has long had very good support for asynchronous, event-driven, non-blocking scalable systems. This includes features and APIs like JMS, Message Driven Beans, Asynchronous Session Beans, CDI events/observers, asynchronous Servlets/NIO, server/client side JAX-RS and the Java EE concurrency utilities. These features can be used in a highly Reactive fashion especially in conjunction with Java SE 8 lambdas, streams and CompletableFuture. The slides for the talk are here (click here if you can't see the embedded slides):

Reactive Java EE - Let Me Count the Ways! from Reza Rahman

Although JavaOne had thinned out by Thursday this talk too was packed. I finished JavaOne well this year by participating in the excellent community keynote.

JavaOne Comes to Your Computer - for Free!
I am very happy to report that you can take advantage of the materials at JavaOne even if you could not come this year. All the session titles, abstracts and most of the slides are available for all on the content catalog. In addition we've made the session videos available on YouTube. This is a wealth of knowledge available for free that you should not hesitate to take advantage of (especially over the holidays :-)).

All in all this was another 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 content.

javaone ,java ,javaone 2015

Published at DZone with permission of Reza Rahman , DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}