Friday, January 23, 2015

Adopt-a-JSR for Java EE - CJUG Meetup Recap

This fall, the Chicago Java User Group (CJUG) adopted JSR-366, the Java Platform, Enterprise Edition (Java EE 8) Specification.  To that end, the CJUG will be hosting periodic meetups to work on contributing towards Java EE 8.  Our first meet with regards to this agenda was held on January 15, and we covered JSF 2.3 (JSR-372)...for beginners and advanced users.  This meetup was geared towards anyone who wanted to contribute to Java EE 8 in some way, and we hosted two tracks during the meetup:  "I Want to Learn JSF", and "I Want to Hack JSF"...beginner and advanced, respectively.  Both of the tracks were well received.

I Want to Learn JSF Recap:  

Bob Paulin, CJUG President, led the group through a tutorial that focused on building a simple JSF application using the NetBeans 8 IDE.  Specifically, this tutorial led the group to building entity classes against some of the sample database tables, creating EJBs, and finally, generating JSF views to work with the data.  The tutorial can be found here if you are interested in taking a look.  The sources for the basic tutorial are in GitHub.

I Want to Hack JSF Recap:

I led the more advanced JSF track through a series of advanced tasks...digging into the Mojarra code a bit.  First, we covered the basic steps to checkout the Mojarra 2.3 Milestone and trunk.  We then covered the build process, and how to pull the sources into an IDE, such as NetBeans.  Finally, we decided to dig into the code a bit and try to debug an existing JIRA issue, JAVASERVERFACES-3429.  The team worked the issue, loading the test project into NetBeans and using the debugger to step through the code.  We were able to reproduce the issue and pinpoint the cause of the problem to a specific method within the Mojarra sources.  We were unable to determine the exact cause of the issue due to time constraints, but the group gained useful experience digging through the Mojarra sources.

The evening was a success, as we were able to spread information on how anyone can contribute to Java EE, even those who are new to the platform.  We also sparked new interest in JSF, and presented some of the upcoming JSF 2.3 features.


What are some of the ways you can contribute?  How about the following, just to list a few:

  1)  Read through the documentation/specification and provide feedback.

  2)  Provide documentation for a specific JSR...perhaps work on the release notes for a particular milestone, write examples, or do a presentation.

  3)  Test against the milestone releases, and submit issues if any are found.

Again, this is just a short list of how anyone can get started contributing.  I am looking forward to the next Adopt-a-JSR meetup for CJUG, and I look forward to hearing about your JUG's contribution towards making Java EE 8 great!

Wednesday, December 10, 2014

Honored to be Part of the NetBeans Dream Team

I have recently been honored via invitation to join the NetBeans Dream Team.  I've been using NetBeans IDE since its infancy, and I've watched it evolve into one of the top IDEs for developing Java applications, amongst other things.  I am honored and privileged to have the opportunity to help promote NetBeans, and collaborate with the other NetBeans Dream Team experts to help make the NetBeans IDE even better.

There were 16 new members that were invited to join, and Geertjan Wielenga has written a post about the new members here:   I want to thank all of the members for having me as a NetBeans Dream Team member...I am looking forward to working with you.

To kick off my membership to the NetBeans Dream Team, I wanted to write a post that promoted some of my favorite, but perhaps most overlooked NetBeans features.  I will list three such features in this post, as I must keep my writings short...and I could go on writing about my favorite features for quite some time.  All that are my favorite NetBeans IDE features that are oftentimes overlooked:

#1:  Built-in Terminal:  Did you know that NetBeans has a built in terminal at your disposal?  Sure, it is acceptable to have a terminal window or command line open outside of NetBeans, but maintaining one or more of them inside of the IDE makes it even easier to focus on your tasks at hand...without the need to move outside of the IDE.  (Speaking of which, did you know there is a task list in NetBeans...sorry, I digress).  The NetBeans built-in terminal provides you with the ability to open one or more terminal sessions right within the IDE, and you can even open up an SSH connection to a remote server.  This provides a unified development environment at its best!  To open up a terminal, simply go to the "Window" menu, then select "IDE Tools" -> "Terminal".

#2:  Version Control Made Easy:  No matter which version control you use, NetBeans makes it simple, providing convenient integration points for version control with your NetBeans projects.  I've used Mercurial, Subversion, and Git within NetBeans, and each of them is easy to use...with an intuitive interface, and even some additional plugins to make use easier.  One of my favorite plugins is the Git Toolbar, which provides easy buttons for showing history, committing changes, etc.

#3:  Debugger:  When I am having an issue with one of my applications, the NetBeans debugger can be an invaluable utility.  Perhaps my favorite feature of the NetBeans debugger is the ability to see the values of variables as the application is running.  

The debugger provides the ability to set breakpoints (conditional if you'd like), so that one can evaluate the current status of the code when breakpoints are reached.  If you are having an issue in one of your classes, the debugger allows you to see the current variable values, and step through the code to find the offending line.  It also provides you with numerous other capabilities, such as the ability to set expression watches, easily see the call stack, the ability to see which classes are currently loaded, sessions, current threads, and more.  The debugger has become one of those features that I cannot live without, and it deserves a book of its own.

That does it for this short post.  Once again, I want to thank Geertjan and all of the members of the NetBeans Dream Team for having me...I am very glad to be a part of the team!

Friday, November 28, 2014

Book Review: RESTful Java Patterns and Best Practices

I had the privilege to review the book RESTful Java Patterns and Best Practices, authored by Bhakti Mehta for Packt Publishing.  In short, this book hits the sweet spot when it comes to learning utilization of RESTful web services.  As the book provides a solid foundation for the creation, testing, and utilization of RESTful web services with JAX-RS 2.0, it also provides information on essential topics, such as authentication, security, and performance.  There is even coverage of advanced topics, such as rate-limiting, polling, and micro services.  

The book begins by providing a general understanding RESTful web services, design principals, and the differences between the various HTTP verbs.  This discussion is provided at a high level, such that it is generalized enough to cover various RESTful web service implementations.  The first chapter then goes into the Java API for RESTful Web Services.  This section of the first chapter is brief, and to the point.  It clearly explains how to create services and then test/access them via the Client API, cURL, and other utilities.  As mentioned at the top of this post, Chapter 1 provides a solid foundation...and it is a quick read also, which enables developers to get up and running quickly with the JAX-RS API.

Chapter 2 covers fundamentals, such as returning various content types (JSON, XML, etc.), and designing meaningful URL patterns to obtain the desired media type.  This chapter delves into streaming and chunked content, parsing JSON, and versioning support.  Chapter 2 builds upon Chapter 1 very nicely, further explaining the fundamental concepts of RESTful services.

The third chapter covers security, validation, and logging of RESTful web services.  This is a chapter for intermediate users, as it goes beyond the basics and covers the use of filters for logging, and constraint annotations for validation.  It then provides a brief example of building an exception class.  Lastly, this chapter goes into authentication practices using SAML (Security Assertion Markup Language), OAuth, and tokens.  While this chapter sets a good stage for discussing the various types of authentication, it does not go into detail on these topics.

Chapter 4 covers performance via caching, asynchronous and long-running jobs, and partial updates.  The chapter clearly explains how to utilize the Cache-Control header and ETags.  It then explains how to design asynchronous web services, and some best practices.  The last topic in the chapter is partial updates...a topic that is briefly explained, but leaves room for further exploration.

The next chapter goes into advanced topics for RESTful web services...including rate-limiting, response pagination, internationalization and localization, and pluggability and extensibility.  I really liked the way that this chapter covered rate-limiting in detail, and explained why this is an important topic.  It then provides a detailed explanation for response pagination, along with a good example.  The internationalization and localization section is brief, but provides a good enough explanation for getting started with internationalization.  Lastly, the chapter provides a brief overview HATEOAS (Hypermedia as the Engine of Application State), testing, and extensibility.

The final chapter does a good job of wrapping up the many topics of RESTful web services, discussing the future of REST and emerging standards.  It is a chapter that explains polling and the importance of providing real-time APIs for avoiding inefficiencies.  Along the way, it touches upon various topics, such as WebHooks, SSEs (Server Sent Events), and WebSockets, and how they relate to RESTful services.

The book contains a helpful Appendix which covers various APIs from GitHub, Facebook, and Twitter.  It is a nice closeout to the book, providing an overview of how to glean information from these important social media networks.

Overall, this book is a great read for getting started with RESTful web service creation and utilization with JAX-RS.  I enjoyed the fact that the book was authored by Bhakti, who is very experienced with the topic, as she is a founding member of the GlassFish Application Server.  I recommend this read for anyone who wants to get up and running quickly with REST, and also learn about various other RESTful concepts along the way.  While this book does not delve into fine-grained details of topics such as authentication and partial updates, it provides a good foundation for learning more on such topics.  Readers will go away from this book with a solid understanding of how to develop RESTful web services, and they will be able to start developing services after reading through the book.  Those who wish to delve into more advanced topics will be provided with a good overview after reading this book, and they'll be pointed into the right direction for learning more on such topics.

Sunday, November 23, 2014

NetBeans Tip: Working with JPQL

Have you heard of the NetBeans JPQL tool?  This is an often overlooked feature of NetBeans IDE that can save developers a lot of time.

If you are a Java EE developer, then you've likely encountered moments when you would like to see the results of a Java Persistence Query Language (JPQL) query before you've written your session bean method.  Being that I come from a database administrator background, I am oftentimes finding myself at the SQL command-line (or NetBeans SQL Editor) writing queries, and then translating the SQL into JPQL.  NetBeans IDE contains a JPQL tool (since NetBeans 7.3), which makes it easy to write JPQL queries and retrieve results immediately.  Let's see how:

The JPQL tool can be invoked within the context of a NetBeans project.  The project must have a valid Persistence Context, meaning that it is wired up for database access.  Once this is in-place, simply right click on the persistence.xml file, and click on the "Run JPQL Query" to open the tool.

The tool provides a nice editor that provides a top pane for entering a query, and a bottom pane for showing the SQL or the results of the query execution.  If you have more than one Persistence Context within your persistence.xml, then you will have the option to select which context you would like to utilize for the query.

To execute the JPQL, simply click on the button next to the Persistence Context pull-down, or right click in the query editor and choose "Run JPQL".

The tool comes in super handy when you are executing queries that involve more than one entity.

Another handy reference for the tool, Geertjan's blog post:

Note:  Be sure to "Build" your project successfully before trying to use the JPQL tool.  If you do not have a successful build, you will likely encounter an error stating that the abstract schema type cannot be found:

Tuesday, November 04, 2014

Building and Testing

The JSF 2.3 Expert Group is hard at work determining which features will be part of the upcoming release.  The JSF Team been working hard improving CDI alignment, among other things.  There are already a number of new features in the JSF 2.3 codebase that you can begin to test.  I will attempt to keep this post updated with the latest features that have been added.  For the most up-to-date reference, please see Manfred's blog.  To reference the information from Manfred's blog, take a look here.

JSF 2.3 Features

**Updated on 01/25/2015:
The features that have been added since 11/4/2014 are as follows:

- Utilize a CDI managed validator:

  @FacesValidator(value = "myValidator", managed = true)
  public class MyValidator implements Validator {

     MyModel model;


- Utilize a CDI managed converter:

  @FacesConverter(value = "myConverter", managed = true)
  public class MyConverter implements Converter {

The features that have been added as of 11/4/2014 are as follows:

- Inject @ViewMap

Map viewMap;

- #1333 - Support @Inject for UIViewRoot

UIViewRoot viewRoot;

- #1332 - Let CDI handle #{view}
- #1331 - Let CDI handle #{application}
- #1254 - contracts attribute too restrictive.
- #1328 - Let CDI handle #{session} EL resolving
- #1325 - Let CDI handle #{applicationScope}
- #1311 - Let CDI handle #{facesContext} EL resolving
- #1323 - Support @Inject for the applicationMap

Map applicationMap;

- #1322 - Simplify #{externalContext} to use ExternalContextProducer
- #1309 - Support @Inject for ExternalContext

@Inject ExternalContext externalContext;

- #527 - Support @Inject for FacesContext

 @Inject FacesContext facesContext;

Please reference the JavaServer Faces JIRA for more information.

* Be sure to test against one of the milestone releases before placing JIRA issues.

Taking JSF 2.3 for a Test Spin

If you would like to start testing out these new features today, the easiest way to get started is to simply download the 2.3 SNAPSHOT and then replace the javax.faces.jar file within your GlassFish/glassfish/modules directory with the snapshot.

You will need to be sure to reference version 2.3 in your faces-config.xml. as follows:

<faces-config  version="2.3"


If you are adventurous and you would like to build JSF from source, that is also fairly simple.  To do so, follow these steps:

1)  Check out the trunk using SVN:
svn checkout --username yourname --password x
2)  Copy the file to
3)  Edit the file and set to your source home.
4)  From the source home, run ant clean main

The jsf-api.jar will be in SOURCE_HOME/jsf-api/build/lib and jsf-impl.jar will be in SOURCE_HOME/jsf-ri/build/lib

For more information on building the sources (and even contributing), please see the following reference:

Friday, October 17, 2014

NetBeans PrimeFaces Lightning Talk

During JavaOne 2014, I had the pleasure to present a lightning talk covering the excellent PrimeFaces support that is offered by NetBeans 8 IDE.  Thanks to Geertjan Wielenga for inviting me to present.

I have recorded a screencast covering the lightning talk content, just in case you missed it.

Tuesday, October 14, 2014

Reflecting on JavaOne 2014 - Java 8, JavaFX 8, IoT, and Java EE 8

There were many buzz-words flying around JavaOne 2014: Java 8, JavaFX8, IoT, Java EE 8, NetBeans, Lambdas, Streams, Parallel Processing, JavaScript, DukeScript, Groovy, Scala, Drones...

To sum it all up:  Java is everywhere, and it is a dominant player in IoT, desktop, and Enterprise.

In Reflection:

After having a few days to reflect on my experiences at JavaOne 2014, a few things come to mind.

First, this was by far the most jam-packed JavaOne that I've attended.  Not only were there more attendees this year, but there also seemed to be more great sessions.  In many cases, I did not know which direction to turn, as there was usually more than one session that I wished to attend in any given time slot.

Second, the networking opportunities at JavaOne are world-class.  There are so many knowledgeable resources at JavaOne, it is worth the trip just to have the chance to speak with the industry leaders.

Third, the community really is driving Java forward.  I just recently joined the JCP, and also the JSF 2.3 Expert this year I paid particular attention to the JCP sessions.  That said, the JCP is doing an outstanding job of driving community participation, with the Java EE 8 specifications, in particular.  Throughout the conference, there were dozens of examples from around the world that spoke to the great work that the JCP has been doing...keep up the great work!

Finally, the Java ecosystem is strong, and it is gaining momentum.  Java really is everywhere...and even though I primarily focus on enterprise, it is great to see all of the many areas in which Java is being utilized.  There were many great examples and presentations of embedded Java in the IoT space specifically...can't wait to see what's in store for years to come.  All that said, this year's trip to JavaOne was great.  I was delighted to have the fortunate opportunity to present during a few different sessions this year, which made it all the better!

In the next few sections, I will provide a brief overview on most of the sessions that I attended.  Hope you will find it useful and utilize the information to help you determine which slides to download and sessions to watch on Parleys once the videos are added.

Duke's Cafe

Sunday, Sept 28:

The conference began with a bang, as the attendees in registration were talking about the days to come.  Excitement filled Moscone South, as NetBeans Day was jam packed full of useful information, and sessions covering all areas of Java.  I attended a few NetBeans community panels, which were all filled with interesting use-cases and success stories revolving around Java and the NetBeans IDE.  It was great to see all of the many different ways that people are utilizing NetBeans.

GlassFish RoadMmap and Executive Panel

This has become an annual session for me, as I am a huge fan of GlassFish. This panel was hosted by Reza Rahman, and attendees learned about the future of the application server from John Clingan, Mike Lehman, and Cameron Purdy.  GlassFish 5 is slated for release with Java EE 8, and therefore GlassFish will remain the reference implementation of Java EE.  There were questions regarding the adoption rate of Java EE...specifically around Java EE 7, since there were only a handful of compatible containers at the time.  The panel remarked that they hope to reduce the adoption time for Java EE 8, with hopes that WebLogic will release a Java EE 8 compatibility within 6 months of the Java EE 8 reference implementation release.  Glad to hear that GlassFish has a vibrant future as the reference implementation for Java EE.

GlassFish Adoption Story

Next up, I attended the GlassFish Adoption Story to learn that Mohamed Taman's team had implemented a Java card system very rapidly via GlassFish and Java EE 7.  Martin Mares, one of the talented GlassFish developers, then provided a brief demo of the powerful GlassFish admin utility.  It was great to see how others are making use of GlassFish, and it was also nice to have the opportunity to hear from one of the GlassFish developers first hand.

Java Strategy and Technical Keynote

I attended the Java Strategy and Technical keynote next.  Although it was not quite as exciting as JavaOne 2013...which included great announcements like Java EE 7 and coverage if Java 8 and JavaFX 8 new features...this keynote was inspiring, as there were many examples demonstrating great things that people are achieving with Java technology.  Watch here...

Java Strategy and Technical Keynote

NetBeans Day Sessions

I finished off the day with a couple of more NetBeans day sessions, learning how companies such as Boeing and the oil industry is making great use of NetBeans IDE.  I was privileged enough to present a lightning talk, covering some of the great NetBeans and PrimeFaces integration.  During these NetBeans Day events, I ran into some great Java minds...too many to name!  In my session alone, I had the honor to present with Tim Boudreau, Kirk Pepperdine, Stephen Reinert, and Martijn Verburg.  It was a great experience to have the opportunity to network with these brilliant people.

Java EE Appreciation Event

On Sunday evening, the excellent networking continued as I met up with the Jython leads: Frank Wierzbicki and Jim Baker, followed by the annual Java EE Appreciation Event at Thirsty Bear.  I was lucky enough to have in-depth conversations with people like Freddy Guime, John Clingan, David Heffelfinger, Sven Reimers, and more.  I also had the privilege of meeting Ed Burns for the first time since joining the JSR 372 expert group.  One of my favorite networking events of JavaOne, by far...thanks Oracle!

Monday, Sept 29

Monday was a full day...starting at 7:30 and going until 10:00 in the evening.  Of course, the day actually started at 8:30 am, but I had to get to Duke's Cafe for my morning coffee fix first!  I started my day off right with a JSR-107 (JCACHE) Tutorial.  This was an excellent 2 hour tutorial that was led by Steve Millidge of C2B2.  He had a few slides, but delved into lots of code examples.  We did not cover a server-side scenario, but instead we focused on a Java SE-based solution with Oracle Coherence.  I got a lot out of the session, and it was jam packed with information for the full two hours.

Next up was a session on Java EE 8, led by Linda DeMichiel, Java EE 8 Specification Lead.  This was an informational session regarding ideas and concepts that are being kicked around (and some already implemented) for Java EE 8.  Nice indeed to learn about the possible future of Java EE by the leaders themselves.

Parc 55 Lounge

My afternoon was full of great sessions (including one of my own). The schedule went like this:

HTTP 2.0 Comes to Java:  What Servlet 4.0 Means To You

Excellent session hosted by Ed Burns and Shing Wai Chan discussing the future with Servlet 4.0.  HTTP 2 will make quite a difference behind the scenes...sounds like these two have a great strategy for moving forward.  If you work with Java EE and you missed this talk, I recommend checking out the slides.

Java EE 7 Recipes (My Talk)

I covered 25 different topics in this talk, spanning across most of the Java EE 7 APIs.  I gave a similar talk for the Chicago Coder Conference a couple of months back, but I changed a few recipes a bit and added a recipe covering JAX-RS AsyncResponse.  I feel that my Java EE 7 Recipes talk was well received, but I tried to pack too much into it.  I ended up stumbling a bit because I was a bit too rushed...I'll have to cut back on the content a bit next time so that I have more time to answer questions.  I was honored to have a full room, along with Reza Rahman (Oracle Java EE Evangelist) in the audience.

Coder Conference Video:

Java API for JSON Binding

This talk was given by Martin Grebac, and it discussed the upcoming JSON-B API for Java EE.  Well attended, and very informative...looking forward to working with this API!

What's Next for WebSocket API

I was unable to attend the entire WebSocket session, although I did make most of it.  Throughout the session, Pavel Bucek went through the history of the API, usage, and then touched upon a few of the updates that we will see in the next release.

JCP Community Party

No doubt, this was a highlight of the trip for me!  The JCP Community is celebrating 15 years, and the party was great.  Held on the top floor of the Hilton, this party was located in a fantastic setting, and I met up with many brilliant minds there...David Heffelfinger, Freddy Guime, Bob Paulin, Jim Weaver, Geertjan Wielenga...just to name a few.  It was a quick visit, as I had to be off to the GlassFish BOF over at Moscone!

Top of the Hilton at the JCP Community Party

GlassFish BOF

I came in toward the end of this BoF, as I was late arriving from the JCP Party.  Always great to speak with the leaders of GlassFish...including Reza Rahman, John Clingan, David Delebasse, and more.  It was great to learn the needs that others in the industry have with respect to GlassFish.

What's Next for JSF?

Excellent BoF, hosted by Ed Burns and Manfred Riem.  Discussed the future of JSF...focused efforts on tidying up via Oracle, but more of a community-driven effort to add new features.  Kito Mann discussed how he'd like to add JSON Rendering to the spec, and Ian Hlavats presented an excellent talk on adding Twitter bootstrap support and/or RenderKits that target AngularJS directives.

Calling all GlassFish Users and Groups

This was a small-sized BoF, as there were only a handful of attendees since it was so late in the evening.  We were able to engage in conversation with Reza Rahman, Steve Millidge, John Clingan, and others to learn about how we can help GlassFish to move forward.  Most important things we can do are testing bug repairs, clean up the issue tracker, download and test the builds, etc.  Take a look at
to learn more about getting involved.

Tuesday,  Sept 30

Another day full of excellent tutorials, sessions, and BoFs.  I had no scheduled talks on Tuesday, so I was open to take in the conference...and I did just that.  I started the morning with another 2 hour tutorial given by Michael Finocchiaro and Ryan Cuprak on getting applications to mobile using Cordova.  Very detailed, and based around a real life application deployment.

Adopt-a-JSR for Java EE 8

In this talk, Heather Vancura, Reza Rahman, Ed Burns, and Mohamad Taman discussed the different ways in which JUGs could assist if their organization were to join the Adopt-a-JSR program.  This was very beneficial to me personally because I am going to be helping the Chicago Java User Group with their efforts in adopting JSR 366.  Heather provided an excellent overview of the program.  Reza discussed about the focus points for Java EE 8.  Ed spoke to his experience with user groups adopting JSRs that he has led in the past.  Mohamed discussed how he and his organization had successfully rolled out a major enterprise system utilizing Java EE technologies and Java Card.

Stop! or My Duke Will Shoot!

The excellent Dierk Konig presented on OpenDolphin and communications with IoT devices.  During the presentation, he utilized a mobile phone to target and shoot the audience with foam darts.  OpenDolphin is an open source framework for constructing JavaFX applications using an MVC architecture.  In summary: have a look at OpenDolphin...looks great!

** Lunch with Apress:  I was lucky enough to grab lunch at Duke's cafe with my Apress editor, Jonathan Gennick.

** Creating Our Robot Overlords

This one gets two stars, as it was one of my most enjoyed sessions of the conference.  Jim Weaver hosted the IoT and JavaFX experts: Mark Heckler and Sean Phillips, who demonstrated how to program Drone devices with Java.  Mark presented a very amusing and brilliant session with a drone that he ended up programming to fly in several different patterns.  During his presentation, he mentioned that he did not achieve the end result without injury or ruin in his living room.  The drone took flight in front of the audience, all the while presenting data that was displayed in real time via a JavaFX GUI written by Jens Deters.  Sean was in charge of constructing a 3D JavaFX fly pattern simulator, with which he did an outstanding job.  The simulator showed a TIE Fighter flying the same pattern as the drone just flew in front of the crowd.  The entire presentation was impressive!

About to Put Drone Into Flight

Simplifying HTML5/JavaScript Rich Clients with Java EE

In this session, Geertjan Wielenga demonstrated how to easily construct a JSF application from entity classes using NetBeans.  Johannes Wiegend then demonstrated how to do the same with AngularJS.  Informative, and it makes me love JSF, NetBeans, and PrimeFaces even more.  While there is benefit to being diverse with choice in development frameworks, I'll continue to use JSF where possible, and leave AngularJS and other client side frameworks to those that tend to weigh more on the client or require more statelessness than JSF offers.

Model-View-Controller in Java EE 8

I have been curious to see how the new MVC framework for Java EE evolves.  I am happy to know that it is in the good hands of Manfred Riem, Spec lead.  In this BoF, Manfred covered where he believes the JSR will focus, and re-iterated that it is not meant to be a JSF replacement.  It will be good to have a standard in Java EE for this style of web development.  More tools for the job!

Meet the Java EE Specification Leads

I arrived a bit late for this BoF, but it was very important for Java EE.  In this BoF, Linda DeMichiel and Bill Shannon outlined what is in store for Java EE 8, thus far.  All Java EE 8 spec leads were on the panel, and answered various questions regarding their specifications.  I had the honor of speaking with Bill Shannon after the BoF for a few minutes regarding the Adopt-a-JSR program.

Wednesday, Oct 1

I was energized when I woke up on Wednesday because I was really looking forward to my Java EE Recipes for Concurrency talk later that afternoon.  This was the mood of the day, as I only attended a few sessions, but had the opportunity to take in the best of JavaOne...the networking.

PrimeTime JSF with PrimeFaces 5.0

Kito Mann is an excellent speaker.  What's better than to have an excellent speaker talk on an excellent topic.  Hands down (IMO), the best JSF framework available today, PrimeFaces was covered from top to bottom via Kito's presentation.  While I am already very familiar with the framework, I did learn a few new tips from Kito...very insightful.  Also very surprised to receive a tweet from Cagatay Civici (PrimeFaces Lead) during the presentation, requesting a photo.  I have the honor of sitting on the JSF 2.3 Expert Group with both Kito and Cagatay.

Java EE 7 Hands On Lab

David Heffelfinger and Mark Heckler were the presenters for this year's Java EE Hands On Lab, and they did a terrific job.  I had the opportunity to help answer questions for the class, along with Sven Reimers and Bob Larson.  It was great to interact with the students, learning the areas in which they develop and why they are trying to learn Java EE.  For those who began their journey into Java EE with this class, they couldn't have begun a better way.

David Heffelfinger Teaching JSF

Mark Heckler Spreading Knowledge of JavaEE

Debugging and Profiling Robots

Int his session, the great James Gosling presented along with other JavaFX and IoT experts:  Mark Heckler, Jose Pereda, and Jens Deters.  Geertjan Wiengela ran interference during this session that provided some good tips, "lessons learned", and great tooling tips from the IoT masters.  James Gosling told some tales regarding his experiences with the wave gliders.  I was surprised to learn that the biggest issue is fishermen.  Mark Heckler flew the drone and spoke about NetBeans for debugging and profiling.  Jose and Jens demoed their Raspberry Pi tablets and controlled devices over seas in a live session.  All in all....great!

James Gosling's Wave Runner in the Exhibition Hall

Project Avatar:  Server-Side JavaScript on the JVM

John Clingan led this talk, followed by some discussion with the Project Avatar team members.  During this session, Project Avatar 2.0 was announced, which virtually enables Node.js applications to run on the JVM.  They call Avatar "serverside JavaScript for the JVM", and I can see its use-case.  I'll certainly keep an eye on this project, as it seems to have a great team behind it.

Java EE 7 Recipes for Concurrency

I was honored to present on the Concurrency Utilities for Java EE as the last presentation time slot for the day.  The room was jam packed, and it was full of smart individuals who asked great questions.  I was very happy with the way that this session went, and I was happy with the great crowd of attendees.  Thanks, and I hope that it was useful.


JavaOne Appreciation Event

I had the privilege to attend the JavaOne Appreciation Event with some of the smartest minds in the business.  It was great to get out for the evening and see one of the classics, Aerosmith, and also to engage in some highly technical collaboration.

Oracle Appreciation Event

Thursday, Oct 2

Final day...what a week!  It flew by, and I barely had a moment to sit down and take a breather in Duke's Cafe (although I did catch the NullPointers playing there for about 1/2 hour and they were excellent).

JavaOne Community Keynote

The keynote was great, and I was lucky enough to sit only a few rows back, right in the center.  I was happy that the technical session was presented again, and Mark Reinhold and Brian Goetz did a great job.  Jim Weaver is always a great presenter, as were all of the others on stage.  This is truly a great time to be a Java developer...exciting times in all areas of the platform!

Mark Reinhold
JavaOne Q&A with the Experts

Java EE 8 Community Update and Panel

The panel in this session was comprised of Java application server product leads (David Blevins, John Clingan, Cameron Purdy, Bruno Borges, Kevin Sutter, Mark Little), as well as the expert community voice of Adam Bien.  In this session, the leads gave their thoughts on Java EE 8, and what features or ideas are most important from their perspective.  The community had a voice in that the audience was invited to ask questions and raise comments/discussions on what features the community feels are needed for Java EE 8 compliant containers.

Building Java Applications with JavaFX 8 and Java EE 7

Bruno Borges presented some ideas around different integration points for JavaFX8 applications with the Java EE 7 stack.  He outlined which Java EE 7 APIs are likely useful for use with JavaFX applications, and which would be less useful.  He also touched upon some ideas on how to achieve integration, as well as highlighted some frameworks that are currently in existence to help fill the gaps.

Enterprise Nashorn

This talk was presented by Adam Bien, and he delved into some real-life use-cases for Nashorn within Java Enterprise environments.  It was interesting to hear how his projects have made use of Nashorn and also how easy the integration between Java and JavaScript can be achieved.

Applying Groovy Closures for Fun and Productivity

I closed out the conference by attending this talk, which was presented by the great Venkat Subramaniam.  In this talk, Venkat did an excellent job of showing how useful Groovy closures can be.  He also went into some detail on other useful features, such as currying and memoization, both of which Groovy has to offer.


JavaOne 2014 was well worth the trip.  Not only was it chocked full of great session content and tutorials, but it also provided a world-class collaboration composed of some of the greatest minds in Java.