Tuesday Dec 22, 2015

JavaOne 2015 - Another Year, Another Step Forward

JavaOne 2015 San Francisco was held October 25-29. I think this was another great year for JavaOne. It is always a privilege to try to do justice to the crucial role of Java EE track lead. I'd like to share my thoughts, observations and experiences at JavaOne 2015 from that perspective. I'll also share all the materials that I presented at JavaOne.

Besides helping organize the conference, I participated in the very cool community keynote celebrating twenty years of Java, faciltated the Sunday GlassFish community events, ran a few hands-on labs, led a workshop and presented a few technical sessions. This was by far my busiest JavaOne conference ever. More details on all of this, including thoughts, analysis, slide decks, videos and code, is posted on my personal blog.

Monday Dec 07, 2015

Please Welcome Siwpas as Java EE Certified Option!

Siwpas (short for Simple Web Profile Application Server) has been an interesting project for a little while. Very similar to the more widely known TomEE, Siwpas is a Java EE application server based on Tomcat. In addition to Java EE support Siwpas offers production ready features such as clustering and security. You can also get commercial support from a Turkish based company named MechSoft.

Although Siwpas has been around for some time it had not been certified. The folks behind the application server now announced that they have achieved Java EE 6 Web Profile compatibility through the OW2 Foundation. For those unaware, the OW2 Foundation has long been granted a full Java EE TCK license for a long time. This is the license Siwpas is able to use by joining and contributing the server to the OW2 Foundation. 

Siwpas founder Gurkan Erdogdu shares the story of how the server achieved Java EE 6 Web Profile certification on his blog. You can find out more about Siwpas here and download it from the official OW2 forge. As Gurkan mentions the next step for Siwpas is Java EE 7 certification. Please welcome their valiant effort in expanding options for the Java EE community.

Friday Nov 20, 2015

2015 Duke’s Choice Award Winners Announced

The incredible amount of innovation that uses and builds upon standard Java/EE technologies is one the most important factors that keeps our ecosystem so uniquely strong. The annual Duke's Choice Awards is a small way of recognizing and encouraging such innovation. Every year a panel of judges gives out ten of these awards at JavaOne (in the interest of full disclosure I am one of those judges). Every year Java EE makes a strong showing at the awards and this year was no exception (in fact I'll share that Java EE makes an even stronger showing in the total number of nominees). In particular the following winners are worth highlighting on this humble blog.

UN/WFP School Subsidy Card: Thousands of students in developing countries lack access to adequate food, Egypt is sadly no exception. Egypt based consulting company e-Finance developed the United Nations’ World Food Program (UN/WFP) School Subsidy Card to help combat this problem. The project was developed for Egypt’s Ministry of Education. The project is now live as a pilot that helps 20,000 families in two poor cities. The project uses Java EE 7, Java SE 8, GlassFish 4 and NetBeans. The project is led by Mohammed Taman. Mohammed is an experienced architect, consultant, Morocco JUG member, Egypt JUG leader, JCP executive committee member and expert group member for multiple JSRs. He is an ardent advocate for Java EE and has been a very active participant in the Adopt-A-JSR, Adopt-OpenJDK, and FishCAT programs. Mohammed's work was highlighted at JavaOne, including in the Java EE portion of the keynote.

OmniFaces: One of the core strengths of JSF is the ecosystem built around it, in particular popular component libraries like PrimeFaces. Though not a component library, OmniFaces is a rising star in the JSF ecosystem. It is a collection of useful utilities for JSF developers. If you were familiar with Seam Faces, OmniFaces reminds me quite a bit of it. OmniFaces is led by Arjan Tijms and Bauke Scholtz - two JSF/Java EE community heroes in their own right. Bauke is one of the foremost JSF community experts. Many in the JSF community know him as BalusC - the ever present voice online always ready to help with very knowledgeable and helpful answers to JSF questions anywhere! Similarly Arjan has long been a strong contributor to the JCP and many of his good ideas are already standardized in Java EE. You can find out more about OmniFaces here.

KumuluzEE: The ranks of fat jar solutions targeting microservices hype in the Java EE ecosystem seems to be ever expanding. There is WildFly Swarm, Payara Micro/GlassFish Embedded as well as TomEE embedded. KumuluzEE is an interesting part of this crowd as unlike the others it does not come from a traditional application server pedigree and is a very community based project that still uses Java EE APIs to create a fat jar solution. KumuluzEE is led by Slovenian Java Champion Matjaz B. Juric. Besides being a Java Champion Matjaz's impressive credentials include simultaneously being an Oracle ACE Director and IBM Champion! You can find out more about KumuluzEE here.

I'd like to take this opportunity to congratulate all of the winners, most certainly not just the ones above. You can find out about all of this year's winners here

Tuesday Nov 17, 2015

2015 JCP Award Winners Announced

An open standard like Java EE involves a lot of hard work from a lot of different groups of people. The hard work of these people, largely selflessly, benefit countless Java developers. For specification leads the work in the JCP is often far beyond just a job. I have seen the same to be true of many vendor experts on a specification. Especially admirable are the independents that contribute to specifications largely on their own time as well as Adopt-a-JSR participants. The annual Java Community Process awards is a small way of recognizing some of these great people and their work. There are four different awards:

  • JCP member or participant of the year
  • Outstanding specification lead
  • Most significant JSR
  • Outstanding Adopt-a-JSR participant

The following are the nominations I had personally made for this year's awards (in no particular order):

  • Josh Juneau (for outstanding Adopt-a-JSR participant)
  • Arjan Tijms (for JCP member of the year)
  • Adam Bien (for JCP member of the year)
  • David Blevins (for JCP member of the year)
  • Ivar Grimstad (for JCP member of the year)
  • Antoine Sabot-Durand (for outstanding specification lead)
  • Manfred Riem and Santiago Pericas-Geertsen jointly (for outstanding specification lead)
  • CDI 2 (for most significant JSR)
  • MVC 1.0 (for most significant JSR)

The winners of the JCP awards were announced in a lavish party during JavaOne 2015. I am happy to see that one of my nominations - Adam Bien - won this year and the others were strong contenders. I am also happy to see the other winners - Anatole Tresch (for outstanding specification lead), JSR 363 - Units of Measurement API (for most significant JSR) and Rajmahendra Hegde/JUG Chennai (for outstanding Adopt-a-JSR participant). In particular JUG Chennai has long been a strong supporter for Java EE through the Adopt-a-JSR program. I would encourage you to read a bit about the winners and all of the nominees. It's no surprise Java EE has a strong showing in the nominations. These are all true Java heroes in my book. All the details are posted on jcp.org for you to take a look at.

Friday Oct 23, 2015

DZone Survey Shows JPA Dominates Java Persistence

For those of us that have been around Java for a while it has been a long, hard road for Java persistence. In a relatively brief period of time we have seen a chaotic flux of persistence solutions - plain JDBC, homemade JDBC utilities, Apache Commons DBUtils, TopLink, Castor/JDO (Java Data Objects), EJB 2.x Entity Beans, iBatis, Spring JDBC, and so on. For most it was a relief that our industry seemed to finally converge on ORM as an imperfect but generally workable, productive solution to the very complex problem of persistence. For many others though persistence remains a highly contentious topic. It is not too surprising then that DZone took up the topic in it's wide ranging 2015 Java Ecosystem Survey. The analysis of the results of that survey will be part of the upcoming 2015 Java Ecosystem Guide to be published during JavaOne (you can register to get it here). Fortunately DZone shared the results with a selected set of MVBs (Most Valuable Bloggers) including yours truly and gave me permission to share some preview perspectives on the data. As the title of this entry suggests the survey results bode very well for JPA.

The survey asked a very simple question - "What persistence tools do you use today?". The answers included the survivors of the Java persistence wars past and some relative newcomers like jOOQ. The answers were mutually inclusive which was a wise choice that reflects reality. As the results highlighted shows, a very strong majority - almost 64% of developers voted for JPA. The closest contender lagging far behind at 37.6% was very old school plain JDBC!

Also very interesting was the fact that Hibernate native was a separate choice that received only about 17% percent of votes. This represents a successful transition from non-standard APIs to open standards based APIs. For context, even after achieving near de-facto dominant position in Java persistence the Hibernate team, Gavin King and Red Hat decided to standardize on JPA. The native Hibernate APIs were also maintained as a matter of legacy as well as a space for value-added features. For a while it was unclear whether the Hibernate community will opt to make the transition to JPA. This survey clearly shows the transition has happened, paving the way for continued healthy competition in the persistence space via JPA.

The surprisingly high usage of plain JDBC is notable as well. Clearly in this day and age one can do far better than using such a low level API. This data point represents an opportunity for further JPA adoption either through advocacy, migration or sensible evolution of the JPA open standard. It also represents an opportunity for more SQL-centric persistence solutions such as relative newcomer jOOQ.

Overall the survey shows a fairly mature Java persistence landscape that still has a few surprises in store for us all to keep an eye on.

Wednesday Oct 21, 2015

Developers Affirm Strong Support for Java EE 7 in DZone Survey

                    "The reports of my death have been greatly exaggerated."

                                                                                                      – Mark Twain

It sometimes seems like there has been a raging debate on the role of Java EE in server-side Java since the beginning of time. The debate is perhaps just as old and stale as the question of whether Java is finally dead or irrelevant. One of the latest dimensions of this debate has been around adoption of Java EE 7. It is not too surprising then that DZone took up the topic in it's wide ranging 2015 Java Ecosystem Survey. The analysis of the results of that survey will be part of the upcoming 2015 Java Ecosystem Guide to be published during JavaOne. Fortunately DZone shared the results with a selected set of MVBs (Most Valuable Bloggers) including yours truly and gave me permission to share some preview perspectives on the data. As the title of this entry suggests the survey results bode well for Java EE 7 specifically and Java EE generally.

The survey asked a very simple question - "Which of the following Java platforms do you use today?", including various versions of Java EE and some key alternative technologies as mutually inclusive answers (I think the mutually inclusive part is an important reality check towards the aforementioned debate that generally tends to have a tone of mutual exclusion). As the results highlighted shows, almost 39% of developers chose Java EE 7. A total of over 90% responses chose one version of Java EE or the other - well ahead of the other technologies listed. Java EE 7 community support seems to have already edged out the very well regarded Java EE 6 release. These patterns will likely get even stronger with the recent Java EE 7 release of WebSphere Liberty and full commercial support of Java EE 7 through WebLogic and JBoss EAP in the next coming months.

Fortunately we also have interesting past data points to compare in the RebelLab's 2014 Java Tools and Technologies Landscape survey. That survey asked similar but slightly different questions with regards to Java EE. In that survey 68% indicated that they were Java EE users, which is likely a lower rate than in the DZone survey. Most importantly a significantly higher percentage, 49% indicated Java EE 6 usage than Java EE 7 usage that stood at 35%. For clarity this report treated Java EE version usage as mutually exclusive (probably a mostly reasonable assumption). It did not attempt to collate data on Java EE vis-a-vis alternatives. To roughly compare with the DZone report format that means that of total respondents, about 24% reported Java EE 7 usage while 33% reported Java EE 6 usage. All this bodes well for Java EE and Java EE 7. The two surveys taken roughly a year apart indicate higher levels of usage for Java EE overall and strengthening community support behind Java EE 7, even as compared with Java EE 6.

On behalf of the Java EE team here at Oracle it is only correct to thank everyone that indicated their support for Java EE and Java EE 7 in such surveys. Our work is intended to benefit you first and foremost - it is good to see that intent does not get lost in the muddle. As you may be aware we make an effort to highlight your success adopting Java EE in our blogs, JavaOne and through the core Java EE community. It is always a good time to drop us a note to share your story with the broader community.

Monday Oct 12, 2015

Kito Mann's JavaOne 2015 Sessions on JSF, MVC and HTML 5

For the Java EE track at JavaOne 2015 we are highlighting some key sessions and speakers to better inform you of what you can expect, right up until the start of the conference.

To this end we recently interviewed Kito Mann. Kito is a long time JSF advocate, popular author, speaker, consultant and very prolific contributor to the JCP. Just as previous years, Kito has one of the highest number of sessions from a single speaker on the Java EE track. He spoke to us about his accepted session at JavaOne 2015 (click here if you can't see the embedded video).

The following are the sessions we talked about:

  • Advanced PrimeFaces: This informal after-hours BoF is a deep dive into the popular PrimeFaces library. If you are using PrimeFaces this is a great session to really understand how PrimeFaces works.
  • Tuning JavaServer Faces: In this extended tutorial style session Kito offers his deep insight to effectively tuning JSF applications in the real world. I would say this is a must attend for any JSF user.
  • Building Professional JavaServer Faces UI Components: As Kito explains building reusable components is a key value proposition for JSF. In this informal after-hours BoF Kito will cover best practices for effectively building JSF components for real world applications.
  • Modern Web Apps with HTML5 Web Components, Polymer, and Java EE MVC 1.0: This is a very advanced technical session covering a number of very forward-looking topics. HTML5 web components are a key emerging standard for building JSF style components in vanilla HTML. Polymer is an important open source library for HTML 5 web components. In this session Kito shows how Polymer/web components can be used effectively with the upcoming MVC 1.0 standard slated for Java EE 8.

The following sessions are pretty closely related to what Kito is presenting at JavaOne this year:

Besides these sessions, we have a very strong program for the Java EE track and JavaOne overall - just explore the content catalog. If you can't make it, you can be assured that we will make key content available after the conference just as we have always done. If you are coming, do make sure to book your sessions via schedule builder before they fill up.

Friday Oct 02, 2015

Bessem Hmidi on AngularBeans at JavaOne 2015

For the Java EE track at JavaOne 2015 we are highlighting some key sessions and speakers to better inform you of what you can expect, right up until the start of the conference.

To this end we recently interviewed Bessem Hmidi. Bessem is the JUG leader of the ESPRIT JUG Tunisia, an educator, a researcher, an international speaker and a Java EE enthusiast. He spoke to us about his accepted session at JavaOne 2015 on AngularBeans. AngularBeans is a very innovative open source project that marries AngularJS with CDI and Java EE (click here if you can't see the embedded video). We've highlighted AngularBeans on this humble blog in the past.

You can find details on Bessem's session on the JavaOne 2015 content catalog. The following are the other sessions we talked about:

Besides these sessions, we have a very strong program for the Java EE track and JavaOne overall - just explore the content catalog. If you can't make it, you can be assured that we will make key content available after the conference just as we have always done.

Tuesday Aug 25, 2015

Asynchronous Support in JAX-RS 2/Java EE 7

Asynchronous processing, non-blocking I/O, events and messaging are keys to more reactive applications. Fortunately Java EE has long organically provided such features in the platform at pretty much every key API layer including Servlet, CDI, EJB and JMS. These features were strengthened further in Java EE 7 and even more could be done in Java EE 8. Spurred by a real world developer I met at a conference writing a highly reactive IoT application with Java EE, I've actually developed a talk about reactive features in Java EE (click here if you can't see the embedded slide deck):

One such feature added in JAX-RS 2/Java EE 7 gets surprisingly little exposure - asynchronous capabilities added for both server-side REST endpoints as well as clients. Fortunately Sam Sepassi has stepped up nicely to fill the gap with a detailed blog entry that covers both the servers-side and client side capabilities. Bonus points to Sam for demonstrating how nicely JAX-RS 2 asynchronous endpoints and EJB @Asynchronous work together! Sam also shows the Java EE 7 Concurrency Utilities in action and does a nice job explaining the basics/what's going on under the hood.

Monday Aug 24, 2015

Java API for JSON Binding (JSON-B) 1.0 Early Draft Now Available!

The first early draft of the Java API for JSON Binding (JSON-B) 1.0 is now available for you to review: https://jcp.org/aboutJava/communityprocess/edr/jsr367/index.html. As discussed below this is distinct from the Java API for JSON Processing (JSON-P) 1.1, which also recently published it's own first early draft. Like all early drafts for JSRs, the goal is to foster dialog, feedback and participation. Although it is just an early draft the thirty-five page specification document is actually fairly far along so providing useful feedback should be easy.

JSON is increasingly becoming the de-facto data interchange format on the web, be it for mobile, HTML5/JavaScript rich-client or microservices applications. While Jersey, EclipseLink, GlassFish and WebLogic have long provided strong support for JSON via EclipeLink MOXy, it has been a goal in the Java EE platform to make JSON a first class citizen to the degree where it can become just another natural serialization format for Java. Towards that goal Java EE 7 provided simple JSON processing support via JSON-P. That support is being beefed up further in Java EE 8 by supporting more JSON standards in JSON-P such as JSON Pointer, JSON-Patch and the like. As a parallel effort Java EE 8 also plans to provide a much higher level JSON binding API via JSON-B. The idea is to make JSON handling in the platform so ubiquitous and easy-to-use that it is almost invisible akin to JAXB in the XML world.

If these are ideas that interest you, now is the time to get involved with JSON-B and join other folks in the community that are already helping out. The JSON-B early draft gives special thanks to Olena Syrota, Oleg Tsal-Tsalko and the Ukraine JUG for their contributions even at this stage. These folks have helped us with feedback, community building as well as evangelizing.

There are many ways for you to get involved as always. You are always welcome to join the expert group proper via the JCP page for the specification. You can always simply join the discussion by subscribing to the JSON-B specification user alias. If you would rather participate as a group through your JUG you can do that easily via Adopt-a-JSR.

Monday Aug 17, 2015

A Journey from Tapestry to JSF 2.2 and JavaEE 7

After the key Java EE 6 release we have seen a steady stream of folks migrating from various non-standard frameworks to Java EE - all for their own good reasons. One such very recent detailed migration story was shared by Lenny Primak. He successfully migrated from Tapestry to Java EE 7/JSF 2.2 and shared his observations in a series of (eighteen!) blog entries. His candid independent insights with regards to JSF/Java EE are likely very helpful to current and potential adopters.

I do think it is very important to take any such migration story with a grain of salt. All of this is just one person's view about what is right for them while choosing amongst a complicated set of trade-offs. It is never wise to over-generalize from those unique perspectives instead of choosing what is right for a given situation. We certainly should not forget that all non-trivial technology has it's advantages and drawbacks over time. Tapestry is a great technology in the overall ecosystem that standards like JSF do adopt good ideas from (and the opposite is likely to also be true). It is also possible to use Tapestry with Java EE as an alternative to JSF.

You can read Lenny's entire migration story on his personal blog. Although eighteen entries can seem daunting each entry is short/to-the-point and well written. Here are some highlights for the very impatient:

  • In the conclusion Lenny notes "As I looked at the big picture, it turned out to be easier to convert the whole app from T5.3 to JSF and PrimeFaces instead of T5.4, and that’s what I did. This turned out a great decision. Everything is compatible, future JavaEE versions are easily adoptable, all integrations do not require heroic efforts to implement or maintain and even JavaScript and Ajax with JQuery even started to be fun to develop."
  • Lenny opted to use Apache Shiro instead of built-in Java EE application server security such as GlassFish Security or WebLogic Security. He found that Shiro was easy to use with JSF and Java EE - "After the switch to JSF, however, Shiro, with it’s standard configuration, worked as expected, and I was able to build all of the security requirements in the application very quickly."
  • Lenny had some nice things to say about JSF generally and JSF 2.2 in particular - "The JSF way seems to be more flexible and saves code", "writing the same function in JSF and PrimeFaces took only about 10 lines of CoffeeScript code", "...major feature of JSF 2.2 is HTML 5 support, and ability to write JSF applications in standard HTML5 syntax as opposed to JSF tags...this development prompted me to re-evaluate JSF as my tool set".
  • Lenny found contributing to Java EE extremely easy "when trying to contribute to JavaEE, I was welcomed right away. The attitude really shined, and I was able to contribute valuable bug fixes without too much hassle."
  • Lenny found it more sensible to work with standard EJB 3 and JPA features instead of the Tapestry approach to persistence - "I found it better to call EJBs from Tapestry, and let EJBs handle all JPA transactions, thus totally bypassing Tapestry-JPA. This turned out to be the best solution of using JPA with Tapestry."
Do you have a similar interesting Java EE adoption story to share with the community? If so, please do reach out and we will find a way to properly highlight it.

Friday Aug 14, 2015

Submit Now to Win a Duke's Choice Award!

The incredible amount of innovation that uses and builds upon standard Java/EE technologies is one the most important factors that keeps our ecosystem so uniquely strong. The annual Duke's Choice Awards is a small way of recognizing and encouraging such innovation. Every year a panel of judges gives out ten of these awards at JavaOne. Submissions for this year is now open and you should check out the details right now.

Note that while some of the text uses the word "nomination", it simply means submitting (aka "nominating") your own project or work for consideration by the awards committee. There is no problem with doing this whatsoever and that is in fact what the submission form expects in most cases. That being said there is also no problem whatsoever in submitting on behalf of any project or work you think deserves the award even if you are not directly involved with it.

Besides some well-deserved recognition by the Java community, winners get a free JavaOne 2015 conference pass, a super cool Duke award statue and of course the winner's badge. Keep in mind the award isn't just for the framework or product developer types. In the past people using Java in innovative ways for "real world" projects, great educators and thought leaders have won too. Here are some example winners from the past few years for inspiration:

  • Apache TomEE - Innovative fully certified lightweight Java EE application server that is a drop-in replacement to Tomcat.
  • United Nations High Commissioner for Refugees/World Food Program Subsidy Card - A real world Java EE 7 application running on GlassFish that makes a real difference.
  • JCertif - Bringing Java/EE focused IT education to the African continent.
  • JEDI - Bringing Java/EE focused education to the Philippines.
  • DeltaSpike - A very useful CDI toolbox for Java EE developers.
  • Devoxx4Kids - A very cool initiative focused on teaching kid's programming facilitated by one of the largest Java developer conferences.
  • JDuchess - A program to strengthen women in Java.
  • London Java Community - The super active JUG involved in OpenJDK, JCP and Adopt-a-JSR.
  • Parleys.com - The world class e-Learning platform built on Java EE.
  • Arquillian - JUnit for Java EE, need I say more :-)?
  • jHome - An open source home automation platform built on Java EE and GlassFish.

You can check out all the past winners here. Do hurry up - the submission deadline is August 24. The submission form is here.

Tuesday Aug 11, 2015

Maven, Java EE and ... NetBeans

At the beginning, build tools capabilities were relatively simple, i.e. mostly compile and package the compiled sources. But over the years, those capabilities have largely evolved (e.g. complex build processes, dependencies management, documentation generation, testing integration, etc.). And it's probably fair to say that Maven has been, at least in the Java landscape, one of the main actors in that evolution... if not the most important one! Maven is widely used since many years, it's now the de-facto Java build environment. And if you are using another solution (e.g. Graddle), you can't ignore Maven; chances are high that you still have to directly or indirectly use Maven in a way or another (e.g. to integrate a 3rd party framework which uses Maven). 

In his "Truly Unleashing the Power of Maven and Java EE" article, Geertjan Wielenga (NetBeans Product Manager) talks about how well integrated Maven is in the NetBeans IDE. If you haven't used NetBeans and its Maven support, you should read this piece. It's amazing how Maven is supported in NetBeans. It's so nicely integrated that you sometime tend to forget that Maven is used under the hood.

Geertjan then discusses another strength of NetBeans, its Java EE support. He then concludes with "Maven and Java EE are baked into the very essence of what NetBeans IDE is, as its heartbeat, and as its raison d’être". So when you combine NB's deep Maven integration with its outstanding Java EE support, you get a rock-solid (and free!) environment to develop Java EE applications.


Visual representation of a Maven project's depencies in NetBeans

Monday Aug 10, 2015

Help Recognize Java Community Process (JCP) Heroes!

An open standard like Java/EE involves a lot of hard work from a lot of different groups of people. The hard work of these people, largely selflessly, benefit countless developers. For specification leads the work in the JCP is often far beyond just a job. I have seen the same to be true of many vendor experts on a specification. Especially admirable are the independents that contribute to specifications largely on their own time as well as Adopt-a-JSR participants. The annual Java Community Process awards is a small way of recognizing some of these great people and their work. This year's award nominations are now open - you should read the details here. There are four different awards:

  • JCP member or participant of the year
  • Outstanding specification lead
  • Most significant JSR
  • Outstanding Adopt-a-JSR participant

The awards will be presented at JavaOne 2015. These are the nominations I have personally made already:

  • Josh Juneau (for outstanding Adopt-a-JSR participant)
  • Arjan Tijms (for JCP member of the year)
  • Adam Bien (for JCP member of the year)
  • David Blevins (for JCP member of the year)
  • Ivar Grimstad (for JCP member of the year)
  • Antoine Sabot-Durand (for outstanding specification lead)
  • Manfred Riem and Santiago Pericas-Geertsen jointly (for outstanding specification lead)
  • CDI 2 (for most significant JSR)
  • MVC 1.0 (for most significant JSR)
Are there others that deserve nomination this year? If so, please don't hesitate to submit the nomination yourself using the very straightforward form. The form is only open until August 17th, so please do hurry!

Wednesday Aug 05, 2015

JavaOne 2015 Java EE Track Content Finalized (A Detailed Preview)

I am very pleased to share with you that the JavaOne Java EE track content is now finalized. In this brief but detail-rich entry on my personal blog, I want to take this opportunity to tell you a little bit about the track, key content and star speakers this year. The collective passion and dedication of all the folks that submitted helped us construct a very strong offering for the community at large. JavaOne is a key part of the global Java community far beyond the walls of Oracle and all of you are a large part of keeping it successful.

I hope to see you all at JavaOne. In the next coming weeks and months we will be sharing more details on the Java EE track, content and speakers at JavaOne. Lastly having been on the other side of the fence I know as much as you might come to JavaOne, it might not be a practical reality for you for a variety of good reasons. I want to remind you that we make a point to make JavaOne content openly available to all. That being said I want to tell you that you should make the pilgrimage to JavaOne at least once as a Java developer.