JSF 2.0 Group Blog

Friday Aug 01, 2008

Early Draft Review 1: Recap

Just in case you didn't notice, we released the Early Draft Review Draft (ERD) 1 of the JavaServer Faces 2.0 specification back in June. If you didn't have the time or inclination to read the spec, here are the key features it includes (links point to Ryan Lubke's well-written detailed blog entries):

Feature Description
Development stages Allows you to keep track of whether your project is in development, production, and other stages. For example, you can display stack traces and re-load artifacts in development mode, but not in production mode. Similar to the RoR RAILS_ENV environment variable.
Resource handling Resources are style sheets, JavaScripts, images, and related artifacts. This feature adds integrated support for packaging and retrieving resources (versioning, I8LN, libraries, the ability to load resources from JARs). This helps improve component suite compatibility, simplify component development, and also make it easier to dynamically include resources in your JSF pages.
Resource re-location New components for head, body, and resources, plus the ability to specify whether resources should be rendered in the head or body. This was necessary in order to allow custom components and JSF pages to render resource references in the proper location -- you don't want your CSS file reference showing up at the end of the page, even if that's where you declared the component.
System events A new application-wide publish/subscribe event system. UI components and the Application object (which is a singleton) can receive system events. This is used internally for the resource re-location feature, but it can also be used with backing beans or other objects.
New scopes We've added a view scope, a component scope (for the component currently being processed), and an attribute map for facesContext. These are very useful for component developers, but they're also useful for storing state in a context that's more in-step with JSF's processing.

You can expect to see more scopes, such as conversation scope, supported either via WebBeans or in JSF at a later date.

Standard disclaimer: these features are subject to change.

Note that you can download Mojarra 2.0 EDR1 to take these new features for a test drive. And hey, it's open source, so you can see the code, too.

EDR1 was primarily about laying the foundation for some of the key features we're working on for JSF 2.0. EDR2 will give you more toys to play with, and should be out in September; see the JSF 2 Schedule for more info.

Wednesday Jul 30, 2008

JSF 2 Schedule

So, when is JSF 2 supposed to be released? The simple answer is "when Java EE 6 is released." But, for those who want a little more detail, here is the current schedule:

MilestoneTarget DateHand Off to JCP DateCompletion Date
Spec EDR1 21 Apr 2008 24 Apr 2008 3 Jun 2008
Spec EDR2 31 Aug 2008  
Spec Public Review 26 Sept 2008   
Spec Proposed Final Draft 12 Dec 2008   

For EDR2, you can expect simplified component development -- you'll be able to write a JSF component with a single artifact, much like Facelet compositions. If you're working with JSF, I highly encourage you to grab Mojarra as soon as it complies to EDR2 (if you're not going to download Mojarra EDR1, that is).

As usual, this schedule is subject to change. And, although the proposed final draft date is the 12th of December, it could be longer before it is approved by the JCP and posted on the site. Also, Mojarra may be out later. It is, however, closely tracking the spec, and it should run on any Java EE 5 web container (i.e Tomcat 6 or Glassfish).

Even after Mojarra is released, it will probably be a while before Java EE vendors other than Sun include the newest release...hopefully, they'll release Java EE 6 implementations faster than they released Java EE 5 implementations, though.

There is a more complete description of the schedule, with milestones, in the Mojarra FAQ.

Tuesday Jul 15, 2008

JSF 2 Orientation

Let me get this blog started by answering a simple question:

What is JavaServer Faces 2.0, and why should I care?

JavaServer Faces is the standard web application framework for the Java platform. JSF 2.0 is the first major update of the specification since its initial release back in 2004 (yep, JSF is four years old now). JSF 1.2, which came out in 2006, focused on fixing major incompatibility problems with JSP, and also lots of other issues. But JSF 2.0 is the first chance for us to take a step back, analyze what we've learned, and come up with some great new features and enhancements.

You may have noticed that there were two years between JSF 1.1 and 1.2. For better or worse, this is average for JSRs. When JSF 2 comes out, more than two years will have passed since 1.2 was released. Two years is a lot of time in the web development space. It's inevitable that there will be new some trend, feature, or technology during that time frame. Fortunately, innovation doesn't stand still, and dozens of excellent libraries, tools, and UI components have been built on top of JSF. These extensions, made possible by JSF's powerful architecture, have filled in missing functionality and solved common pain points.

So, here's a more concrete answer:

JSF 2 will include all of the key improvements developers have wanted over the past few years.

Why? Because those of us on the Expert Group have paid attention to the community, both in terms of looking at existing solutions and gathering common issues. Ed Burns, the JSF 2 co-spec lead handled this in a pretty methodical manner, as explained in his JSF 2 One Pager.

The other key thing is that the JSF 2 Java Specification Request is very broad. This keeps us from being constrained (as we were with JSF 1.2), but it does mean that everything mentioned in the JSR may not necessarily be in the final release. There are, however, four key focus areas of focus: Ease of Development, New Features, Runtime Performance and Scalability, and Adoption.

Here's the list of major items we're currently tackling:

  • Resource management (stylesheet, images, etc.)
  • Ajax component interoperability
  • Simplified component development
  • Integration of Facelets (with ideas from JSFTemplating)
  • Bookmarkable URLs
  • Zero deployment time
  • Additional scopes
  • Improved error reporting

Now, don't get me wrong -- we're considering other items. These are just the big ones.

These big ticket items have some subtle implications. For example, Ajax component interoperability implies a thin JavaScript layer provided by a JSF implementation. Zero deployment time implies auto-loading of JSF artifacts, and also support for scripting languages such as Groovy. This has already been implemented in the reference implementation and is also being implemented in MyFaces, although it's not yet in the spec). Simplified component development means you'll be able to write a JSF component with a single file.

If you want to keep up with the progress of JSF 2.0, there are few key places you should know about:

And of course, keep your eye on this blog and JSFCentral. Here I'll keep you up to date on the expert group's progress, and also point out resources as they become available.

Wednesday Jul 02, 2008

Welcome to the JavaServer Faces 2.0 Group Blog

A few months ago at JSFDays '08 in Vienna, Austria, Ed Burns, JSF co-spec lead, asked me to put up a blog that would provide updates on our progress with JavaServer Faces 2.0.

Well, that was.. a few months ago.. But, now that the summer has arrived, so has the blog. Here, we'll provide updates on how JSF 2.0 is progressing, and also give you pointers to where you can get more information. I'll be the primary poster, but the blog is also open to other members of the JSF Expert Group.