Still have lingering questions on the goals and future of GlassFish? Want to know a little more about the upcoming GlassFish 4.0.1 release? Something on your mind about Java EE 8/GlassFish 5? You have a golden opportunity to pose your questions and speak your mind tomorrow!

The good folks over at C2B2 have gone through a lot of time and effort to organize a very useful online event for the London GlassFish User Group - they are having me answer all your questions online, in real time, "face-to-face". Steve Millidge of C2B2 will be moderating the questions and joining the conversation. Did I mention the event was online, free and open to anyone?

The event is tomorrow (May 30th), so make sure to register as soon as possible through the C2B2 website (the registration page has more details on the event). It will be held at 4:30 PM BST / 11:30 AM EST / 8:30 AM PST - you must register to participate. Hope to talk to you tomorrow?

Kerry Wilson is a Software Engineer at the Vanderbilt University Medical Center. He served in a consultant role to design a lightweight systems integration solution for the next generation Foundations Recovery Network using GlassFish, Java EE 6, JPA, @Scheduled EJBs, CDI, JAX-RS and JSF. He shared his story at the JavaOne 2013 Sunday GlassFish community event - check out the video below:

Kerry outlined some of the details of the implementation and emphasized the fact that Java EE can be a great solution for applications that are considered small/lightweight. He mentioned the productivity gains through the modern Java EE programming model centered on annotations, POJOs and zero-configuration - comparing it with competing frameworks that aim towards similar productivity for lightweight applications. Kerry also stressed the quality of the excellent NetBeans integration with GlassFish and the need for community self-support in free, non-commercial open source projects like GlassFish. You can check out the details of his story on the GlassFish stories blog.

Do you have a Java EE/GlassFish adoption story to share? Let us know and we will highlight it for the community.

The GlassFish team would like to give an update on the GlassFish Server Open Source Edition 4.0.1 (GlassFish 4.0.1) release that we have been diligently working on.  GlassFish 4.0.1 plans include:

• Bug fixes. This release will, or course, incorporate the many bugs fixes that have already been addressed in the trunk since GlassFish 4.0. We continue to work hard fixing bugs as we head towards release.  Oracle is committed to delivering a high quality development experience with GlassFish! 
  
  
• Refresh component libraries.  GlassFish 4.0.1 plans to use updated versions of many sub-projects it relies on, like Jersey, Tyrus, Mojarra, JavaDB, and more. These projects bring their own set of bug fixes and even some incremental features.
  
  
• Java 8 certification. The latest and greatest JDK.
  
  
• Java EE 7 SDK Update.  Bundles GlassFish 4.0.1 and tutorial updates to improve your Java EE 7 learning experience. 
  
  
• NetBeans 8.0.1 alignment. GlassFish and NetBeans together offer a seamless Java EE development experience. We are planning to align our respective roadmaps to deliver GlassFish 4.0.1 with NetBeans 8.0.1.

Oracle is committed to delivering a high quality development experience with GlassFish! 

From a scheduling perspective, we'd like to go into JavaOne 2014 with GlassFish 4.0.1 on your hard drive and/or in your cloud.

We'll see you at JavaOne 2014!

Tyrus is JSR 356 (Java API for WebSocket) Reference Implementation. The Team working on it doesn't stand still as they have just released another update, i.e. Tyrus 1.6!

For additional details on Tyrus 1.6, make sure to check Pavel's blog post.

One of the things that makes JSF different from other approaches to server-side Java web development is that it offers a much higher level of abstraction and transparently maintains UI state. While this is valuable is making web development feel like more traditional pure MVC UI development (think Swing, AWT or JavaFX), maintaining UI state is not always necessary. In fact, having a stateless view can be a valuable optimization technique as long as you design for it and can afford to do it. In recognition to this fact, JSF 2.2 allows a view to be marked stateless. Ed Burns discussed this feature towards the beginning of his JavaOne 2013 talk titled JSF 2.2 New Features in Context (see embedded video below):

Beyond the video, Thomas Asel provides a detailed explanation of the feature and it's motivation. It's definitely worth a read if you are a JSF user. The entry also references a number of useful resources on the feature.

Since Java EE 6, we have seen a number of folks migrate from the popular Spring Framework to vanilla Java EE, especially in the GlassFish, JBoss and TomEE ecosystems. A small handful of these folks have spoken at JavaOne and we will likely have a few more this year as well - see the embedded slide deck below from JavaOne Rock Stars Bert Ertman and Paul Bakker.

Recently Thomas Wöhlke has taken this further by migrating the entire Spring Pet Clinic example application to Java EE 7 and RichFaces. You can learn more about the effort here. His port works well on both GlassFish and WildFly. Incidentally, the Cargo Tracker Java EE Blue Prints application is also a port of a well known older Spring and native Hibernate application.

Perhaps this is worth a look if you are considering such a migration for your own good reasons? 

Thanks to the popularity of REST, most of us now know HTTP methods like GET, POST, PUT and DELETE better than we probably care to. Nonetheless, most of you probably don't know much about a more obscure but pretty handy HTTP method - PATCH. If this is the case, you should check out this well-written blog post explaining the basics of HTTP PATCH.

JAX-RS 2 and Jersey do not support PATCH out of the box as it is not that widely understood or used quite yet. However, you can fairly easily add PATCH support using JAX-RS 2 - Oracle's own Gerard Davison shows us how. Like a small handful of us here at Oracle Gerard is a JavaLobby/DZone Most Valuable Blogger (MVB). Besides demonstrating how you might implement PATCH, the code-driven post uses a number of cool JAX-RS features such as meta annotations, name bindings, interceptors and providers. Enjoy!

In our continued efforts to reach out the Java User Groups across the different regions, I had the privilege to attend the Jozi JUG annual event in South Africa a few weeks ago. It was a full day event packed with different topics, ranging from Embedded to Java SE and Java EE. I took care of the Java EE section.

You can find some personal thoughts about this nice community event on my personal blog here.

Markus Eisele's GlassFish City Revisited

So you want to build the Reference Implementation of Java EE 7 from the source code after tweaking a little bit? Guess what, it is not hard at all. Andrew Pielage from C2B2 provided us with a nice blog post about the steps required to build GlassFish Open Source Edition from the source. Below you find just a few hints of how easy it is to build GlassFish, but don't forget to check Andrew's post for more details on how to modify source code, build with better options, load the custom build on NetBeans, and more!

#!/bin.sh
MAVEN_OPTS=-Xmx1024M -XX:MaxPermSize=512m
svn checkout https://svn.java.net/svn/glassfish~svn/trunk/main
cd main
mvn install -Dmaven.wagon.http.ssl.insecure=true \
            -Dmaven.wagon.http.ssl.allowall=true \
            -DskipTests

Do you have a nice article about GlassFish or Java EE?
Share it with us by mentioning @glassfish on Twitter!

As its title imply "Java Performance: The Definitive Guide - Getting the Most Out of Your Code" covers Java Performance at large.

Let's start with the beginning. In order to isolate any potential performance issue, you first need to be able to accurately measure performance. The first part of the book discusses general methodologies for testing Java applications. It also discusses the usual pitfalls of Java benchmarking.
Performance analysis is about about observing and understanding what an application is doing so the book continues with an ideal Java Performance Toolbox. It covers some of the tools available to monitor Java applications. It should be mentioned that Java Mission Control that has been recently added to Java SE 7 (starting with update 40) and Java SE 8 is also discussed.
The book then dive into Java performance by discussing in great details two key fundaments that are the JIT (Just-In-Time) compiler and the Garbage Collection.
The remaining chapters focus on best practice uses of various parts of the Java platform. It's the platform at large as it goes from memory use with the Java heap, native memory use, thread performance to Java EE, JPA and JDBC!

Java ME 8 is now here, just a short while after Java SE 8. From my personal experience many developers still strongly associate Java ME with feature phones and are far too quick to not pay enough attention to it. It is important to remember that Java ME is really about running Java on any small devices, not just feature phones. This means that Java ME can be hugely important for the emerging field of IoT (Internet of Things). In fact IoT is a major theme for this Java ME release for this reason. Depending on the capabilities of the device and your requirements you could also use Java SE or Java EE. For many devices in IoT though Java ME may be the only logical option.

Oracle's Terrence Barr does an excellent job summarizing Java ME 8 in a recent blog post. The entry points to some great resources for getting started. There's also the great video below:

Speaking of feature phones - if you really think you are too cool to develop on them, it may be a mindset worth reconsidering. Facebook just got into features phones via a sixteen billion dollar purchase of a company that makes a Java ME application. Believe it or not, Facebook's move is fairly well calculated. While smartphone sales just outpaced feature phones last year, most of the world's population outside of richer countries still does not own a phone. As this population gradually gets access to mobile networks over the coming years chances are they won't opt for the most high end phone available instead of sticking to a cheap, rugged, simple feature phone.

Please note that any views expressed here are my own and does not necessarily reflect the position of Oracle as a company.