Clearing Up JSF 1.2 JSF 1.1 and MyFaces Confusion (Updated)

A couple of weeks ago, Rick Hightower asked some pointed questions
and made some interesting assertions about JSF 1.2, JSF 1.1 and MyFaces
in his
href="http://jroller.com/page/RickHigh?entry=confusion_about_jsf_1_2">blog
. This blog entry is a response to that blog.

I'd like to address some of these questions and assertions in light
of Rick's blog.

What's deal with JSF and Open Source? Exactly what was
open sourced on
href="http://weblogs.java.net/blog/rogerk/archive/2005/08/open_javaserver.html">24
August 2005? Why was this done?

I know it sounds like marketing spin and all that, but,
really,
href="http://www.sun.com/emrkt/share/philosophy.jsp">Sun does
understand the value of sharing for its investors,
customers, and employees. It takes a long time to
style="color: black; font-weight: normal ;text-decoration: none"
href="http://www.bushsecrecy.org/">open things up that
have been closed for a while. We started by moving all of our
development and processes out into the open
href="http://weblogs.java.net/blog/edburns/archive/2004/06/welcome_to_the.html">back
in June of 2004. While the process was open, the
licensing for the code was not. Sun followed up by releasing
the source code and processes for developing our Java EE App
Server in
href="http://weblogs.java.net/blog/carlavmott/archive/2005/07/getting_started.html">July
of 2005, and shortly thereafter we relicensed the source
code for Sun's implementation of JSF 1.2 under the OSI
approved CDDL license.

To summarize, Sun's JSF team is using an open developement
process and an open source license for its JSF 1.2
implementation.

What's the status of the JSF 1.2 spec and
implementation? Has it been released yet?

The spec is currently in
href="http://www.jcp.org/en/jsr/detail?id=252">JCP Proposed
Final Draft. Per JCP rules, no one can release afinal product based on a JCP spec until that spec is
final. However, because both the container in which Sun's JSF
1.2 implementation runs,
href="https://glassfish.dev.java.net/">glassfish, and the
JSF implementation itself are developed using an open process
and open source license, there is nothing stopping you from
using a
href="https://glassfish.dev.java.net/public/downloadsindex.html">promoted
build of glassfish to try out JSF 1.2.

Sun's JSF 1.2 implementation in Glassfish implements the
entire JSF 1.2 specification,
href="http://weblogs.java.net/blog/edburns/archive/2005/08/javaserver_face_3.html">is
feature complete, and we'd
href="http://forum.java.sun.com/forum.jsp?forum=427">love to
have your feedback on it on the public forum or
href="https://javaserverfaces.dev.java.net/servlets/ProjectMailingListList">project
mailing lists. Please note that the binary code is
licensed under Sun's
href="https://glassfish.dev.java.net./public/BinariesLicense.html">Binary
License.

Which is "better" MyFaces or Sun's JSF Implementation?

This question sounds like an invitation to a contentious
debate which usually results in no clear winners. Rather than
engage in such a debate I'd like to point out that I'm
delighted that MyFaces exists and has recently passed the JSF
1.1 TCK. This validates the whole JCP process of open
specifications that allow implementations to compte on the
basis of quality and performance. More of that sharing jazz.
Let me follow up by trying to refute some claims I've heard
about Sun's JSF project.

Our
href="https://javaserverfaces.dev.java.net/issues/buglist.cgi?component=javaserverfaces&issue_status=NEW&issue_status=STARTED&issue_status=REOPENED&email1=&emailtype1=exact&emailassigned_to1=1&email2=&emailtype2=exact&emailreporter2=1&issueidtype=include&issue_id=&changedin=&votes=&chfieldfrom=&chfieldto=Now&chfieldvalue=&short_desc=&short_desc_type=substring&long_desc=&long_desc_type=substring&issue_file_loc=&issue_file_loc_type=substring&status_whiteboard=&status_whiteboard_type=substring&field0-0-0=noop&type0-0-0=noop&value0-0-0=&cmdtype=doit&newqueryname=&order=Reuse+same+sort+as+last+time&Submit+query=Submit+query">issue
tracker is totally open. File bugs and they get fixed.
Pretty simple. I've also heard some complaints about the
turnaround time for bug fixes. Of course, your mileage may
vary, but one thing the Sun JSF team does that MyFaces does
not, and can not, is to keep up with the latest spec as it
is being developed by the EG. Fortunately, due to our
open process, the general public can follow along with the
development of the spec by watching what the Sun
implementation is doing. Therefore, during periods of heavy
spec development, the turnaround time can be slower, but we
always make the best effort to fix bugs as soon as possible
after they are filed.

We have a standard process for becoming a committer on
the project, and anyone is welcome to join.

We do have some active external committers. The famousJacob Hookom
provided several bugfixes and the entire EL implementation.
Jacob started as a JSF committer but went on to become an
Expert Group member. Mike Youngstrom is also active in
submitting bugs and patches.

We've fixed over 75 issues since our last release of
JSF, but because we're a JSF 1.2 implementation, people can't
reap the benefits unless they move to JSF 1.2.

Lastly, the general perception in the public is that
reference implementations (RI) are not production quality.
Sun's JSF implementation isn't just an RI, it is product ready
and used in several products right now. Of course, Sun Java
Studio Creator (new version now available in Early Access), and all of its customers, use the Sun JSF
implementation. I'm also told that
href="https://demopaystatements.adp.com/index.jsf">ADP uses
Sun's JSF impl, and I think that FedEx does as well, but I
have to verify that.

JSF and AJAX, synergy or disharmony?

I'm surprised this one is still out there.
href="http://www.ajaxian.com/">Ben and Dion,
href="http://weblogs.java.net/blog/gmurray71/archive/2005/08/ajax_solutions.html">Greg
and
href="http://blogs.sun.com/roller/page/tor/Weblog?catname=%2FAJAX">Tor
and I have stated on numerous occasions that the page author
should not have to write AJAX by hand. Use a framework
instead. As demonstrated at JavaOne, and in the
href="https://bpcatalog.dev.java.net/nonav/ajax/jsf-ajax/frames.html">Java
Blueprints Solutions Catalog, JSF lends itself very well
to developing components that use AJAX.

I hope this clears up the confusion, and I welcome your comments. In
particular, I want to hear why people may choose MyFaces over the Sun
implementation, both to join as a contributor, or as a user.