JSF 2.0 Group Blog
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.
Posted at 07:28PM Aug 01, 2008 by Kito D. Mann in JavaServer Faces 2.0 | Comments[1]
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:
| Milestone | Target Date | Hand Off to JCP Date | Completion 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.
Posted at 12:18AM Jul 31, 2008 by Kito D. Mann in JavaServer Faces 2.0 | Comments[2]
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:
- JSR Home Page - Grab the latest draft of the spec
- javaserverfaces-spec-public at java.net - Public issue tracker for the spec itself
- JSF Developer's Forum - JSF 2 Thread - JSF Developer's Forum - JSF 2.0 thread
- Mojarra at java.net - the JSF reference implementation (completely public and open source); this is where you can get early versions of JSF 2
- Ryan Lubke's blog - Info from the Mojarra development lead
- Ed Burns' blog - Info from the JSF co-spec lead
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.
Posted at 10:34PM Jul 15, 2008 by Kito D. Mann in JavaServer Faces 2.0 | Comments[7]
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.
Posted at 12:35AM Jul 03, 2008 by Kito D. Mann in JavaServer Faces 2.0 | Comments[2]
