JVM Web Frameworks Comparison – reply to JSF scoring

At Devoxx conference last month, Matt Raible compared JVM Web Frameworks and posted this score matrix. Matt also posted posted baed on what the score was calculated. I met Matt for the first time in March 2010 during TheServerSide Java Symposium in Las Vages.

As someone who has been working with JSF and RichFaces for long time, I wanted to review and post feedback with regards to Matt’s grades for JSF. I also want to be upfront and tell you that I didn’t attend his session. I was at the conference but attended a different session. My goal is not to strike a debate or increase any scores for JSF, but just to show an alternative side as well as potential feedback and comments. Here we go.

To make it easier, I used the following format:
Category – score
Score context (copied from this page)
My comments


Developer productivity – 0.5
Score context: 0 if no save/reload functionality, 0.5 if provided by JRebel, 1.0 if built into framework.

JSF Facelets allows you to save/reload in most cases.



Developer perception – 0.0
Score context: 0 if users are unhappy with the framework, 0.5 if there’s some positiveness, 1.0 if they love it.

I know many people who are perfectly happy with JSF. JSF is of course not perfect, but then what is? I’m guessing a large majority of people who are unsatisfied with JSF most likely don’t know how to use it. Just to prove my point further, entire conferences were organized around JSF such JSFDays (now con-fess.com) in Vienna and JSF Summit in the United States. Not to mention other popular conferences with JSF related content such as JavaOne, JAX, WJAX, Jazoon, JBossWorld, TheServerSide Java Symposium, Herbstcampus.


Learning Curve – 0.5
Score context: 0 if difficult to learn, 0.5 if easier, 1.0 if can learn in a day. Struts 2, Spring MVC and others are easy to learn (for me) == 1.0. Wicket, JSF, Tapestry require you know more than just Java web development knowledge == 0.5.

I don’t know what Matt means by “more than just Java web development”. In JSF, as well as Struts 2, Spring MVC you need to know how to use tags, configure objects in XML files (or annotations) and HTML.


Project health – 1.0 (updated from 0.5)
Score context: Releases in 2010, mailing list traffic, books, tagged questions on Stackoverflow.com. Ranked where 1.0 means healthy, 0.5 means OK, but not as good as others, 0 means declining health.

In this file JSF project health has been updated to 1. JSF project health is strong with very active community and 3rd party component eco-system. In general, I’m not sure how fair it is to base project health on a Q&A type site like Stackoverflow.com


Developer Availability – 1.0
Score context: Rating based on number of developers with the framework listed as a skill on their LinkedIn profile.

There is definitely a good supply of developers with JSF skills.


Job Trends – 1.0
Score context: Rating based on number of jobs on Dice.com, as well as job trends from Indeed.com.

With JSF 2 being part of lightweight and upgraded Java EE 6 platform, I’d anticipate the demand for JSF developers should only increase.


Templating – 0.5
Score context: Rating based on the number of UI templating options are available for the framework. For example, a framework that can use JSP, FreeMarker and render in PDF and Excel is much higher than a framework that only does JSP. JSF scores 0.5 because Facelets is only option.

JSF and the community moved away from JSP simply because it wasn’t a good match for JSF. Facelets is an excellent technology. Purely basing this score on the number of supported technologies is probably not the best approach. In theory JSF also supports JSP, but no one is using it. I think it would be better to look at this from the perspective if the particular UI templating technology makes development faster and easier than just numbers. As an additional note, Gracelets could be used with JSF.


Components – 1.0
Score context: Rating based on how easy it is to package UI functionality into components and share them across projects. Component-based frameworks score high, request-based frameworks do not.

JSF is a component-based framework so no surprises here.


Ajax – 0.5
Score context: Rating based on two things: 1) if Ajax functionality is baked in and 2) how well the framework produces and consumes JSON. Hard-coding an Ajax framework reduces the rating as I don’t believe this is a good thing. If Ajax framework is configurable, 1.0 is given vs. 0.5.

I’m guessing JSF only got half a point because there is no JSON support out of the box. In general, you are not even supposed to deal with JSON when working with JSF. The idea is to hide all JavaScript from the developer. JSF 2 now provides basic Ajax support. When you add a rich component framework such as RichFaces with over 100 Ajax and rich components you get everything you need to develop real world Ajax applications. I think very few projects today use only the standard JSF, in most cases it’s JSF + rich component library.


Plugins or Add-Ons – 1.0
Score context: Rating based on if they framework has a plugin architecture and how many plugins are available.

One of the main features in JSF is its extendability and no better way to demonstrate that is by the number of 3rd party component libraries such MyFaces (various extra tag libraries), PrimeFaces, OpenFaces and IceFaces. Many companies are also building their own custom components, validators and converters.


Scalability – 0.5
Score context: Rating based on how much the framework relies on session state for functionality. Frameworks that require the session by default score lower. Also, frameworks like Grails that use Groovy (which is slower than Java) received a lower rating.

There are ways to configure this somewhat in JSF such as recreating the views before restore or keeping components on the client but neither is a perfect solution.


Testing – 0.5
Score context: Rating based on how much support for testing the framework has built-in. Frameworks that rename elements, making it difficult to test with Selenium, score lower.

JSF has a good set of unit testing tools such as JSFUnit and JSF-test (info here and here on this project). Both are outside projects.

Another alternative is SeamTest.


I18n and i10n – 0.5
Score context: Rating based on the framework’s support for internationalization and localization. This includes referencing messages in template code, as well as Java code. For example, JSF doesn’t make it very easy to get your app’s ResourceBundle in Java.

One line of code to get Resource Bundle registered with the application:

ResourceBundle bundle=context.getApplication().getResourceBundle(context,"error");

Validation: 0.5
Score context: Rating based on the framework’s support for both client and server-side validation. Frameworks that don’t have client-side support receive a 0.5.

Standard JSF 2 has a basic server-side validation model which can be easily extended and JSF 2 supports Bean Validation model out-of-the-box. Client-side validation based on Bean Validation will be available in RichFaces 4.


Multi-language support – 1.0
Score context: Rating based on whether you can write core elements (e.g. Controllers, etc.) in more than one language (for example, Groovy and Scala). Frameworks that support Java, Scala and Groovy receive 1.0, ones that support only 2 receive 0.5. I determined languages supported by googling for the framework + the language.

Groovy and possibly Scala.


Quality of documentation – 0.5
Score context: Rating based on how good the documentation is. Tutorial-style documentation is preferred, reference-style is essential.

There is official JSF documentation in Java EE 6 reference documentation from Oracle and literally thousands tutorials, articles and blogs posts on JSF. Kito Mann’s JSFCentral provides a central resource for everything JSF related.


Books published – 1.0
Score context: The more books the better

There are a number of good JSF books available.


REST support – 0.0
Score context: Does the framework have the ability to produce JSON and XML instead of simply returning HTML? Can it consume JSON and XML as well? Lastly, to get a 1.0 rating, the framework needs to have its own REST client support like Spring’s RestTemplate.

JSF 2.0 adds support for REST (bookmarkable URLs). JSF can produce JSON & XML by adding a custom resource producing necessary output.

Update from (Matthias Wessendorf)/@mwessendorf:
bookmarkable URLS! = REST. Real rest is (very) hard w/ JSF
Old, but good post on this topic.


Mobile / iPhone – 1.0
Scorer context: Rating based on whether the framework has mobile support.

This one somewhat surprised me. JSF doesn’t have anything special for mobile support. But I guess as long as components generate standard compliant HTML, mobile support is there.


Degree of risk – 1.0
Score context: This rating is mostly for businesses. If the framework is new, there’s inherently some risk in choosing it for your applications.

Although JSF is not perfect, being the standard technology in Java EE 6 (and 5), with very active community and vibrant components and extensions ecosystem should make it a safe choice.


This is was a tweet that I sent in regards to comparing Java Web Frameworks:

I think the comparison is fun to some degree, it prompted a few folks including myself to a reply. It’s definitely a great topic for a conference. Any time you see vs or comparison in a talk title, developers get excited. My 2 cents: pick 2-3 frameworks, try them for a week or two. Try to build some pages, see if it’s a good fit, covers most of your requirements, developers like it, productivity is good, and it has 3rd party components or extensions (or make it simple to build them in house).

It’s important to point out again that probably very few companies use standalone JSF. I think most projects use JSF with RichFaces, Seam, Spring, where they have a lot extra features and functionality available.

9 thoughts on “JVM Web Frameworks Comparison – reply to JSF scoring

  1. I agree with all of your comments! I also looked at that presentation some days ago and I dislike such a matrix. This matrix does not help, but just starts a flame war (in my opinion).

    I held a presentation with the same context (comparison of JVM web-frameworks) some weeks ago. I tried to give a good overview without starting a flame war. The audience liked the presentation and gave feedback that they listened to a good, neutral overview:

    Just my two cents to two of your comments about JSF:
    – JSFUnit (and thus testing) is not built-in
    – Client-side Validation is also not built-in
    These are important features of a web-framework, and I hope that the next version of JSF will include them.

    Best regards,
    Kai Wähner

  2. @Kai: thanks for your comments. I updated the testing section to make it more clear that both projects are not built into JSF. As for client-side validation, I say it will be available in RichFaces 4.

  3. I agree with all of your comments too ! JSF is great for example for Ajax Injection, there is no simpliest way how to “ajaxize” app like with A4JSF “injection”…and so on ..

  4. great points. I would like to add that in Testing there are more options, in Seam you have SeamTest that allow you to mock whole JSF plus there is also Arquillian.

    I use Seam/Richfaces and I think its the best framework ever. no javascript needed for ajax calls, its fastest framework I have ever developed in.

  5. The main point of JSF or all other templating engine is that they are based on that : templates to produce HTML.

    It’s not with theses framework that you’ll build a word processor, a 3D game, a video player or something like google wave or gmail. JSF will not help at all for this king of stuff.

    We speak about ajax and web 2.0. Or even HTML5. The point is an interractive and responsive rich client that scale.

    Templating system like JSF design is that in reallity, the UI reside in the server side, not the client side. The browser most of the time can validate a basic user entry without making a call to the server.

    This model is the most comon one on the web today, It work great when you do not need or want to much interractivity. But it now show it’s limits.

    And I don’t speak about being able to have several session on differents tabs of the same browser, to be able to handle back/forward in a meaningfull way or things like that.

    Even if you add rich components, you don’t have a real rich client. First theses components will not fit exactly your need. You’ll have to map a generic component to your specific need. Usability will be not so great for your users.

    The component will be very chatty for many thing just because your code is on the server. This will make your webapps only usable in an intranet and on a single geographic location.

    The component, even with CSS will keep a very standard look, meaning that your application will look exactly the same as all other applications made with the sames components. A little like we all recognise the swing desktop app with their inferior UI compared to native Windows or MacOS applications.

    For me JSF is just a bumped web 1.0 framework with little support for a more modern UI thanks to richface, iceface or others. But it’s just that.

    You want a real modern web UI framework ? Go for JQuery and javascript. Go for GWT… But don’t go for JSF.

  6. @raveman:

    “could you make your presentation available in html? google cant translate PDF.”

    What do you mean by that? Shall I save the powerpoint slides as HTML files and commit it to my private website? Or how else is this possible?

    Best regards,
    Kai Wähner

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s