Home > java > Reply to Comparing Java Web Frameworks

Reply to Comparing Java Web Frameworks

Last week Shaun Abram wrote an interesting blog about the talk Rickard Pack gave on JavaOne titled “Choosing Your Java Web Framework”

It basically said Grails, Tapestry, Wicket and GWT were 4 of the most popular web frameworks. JSF was left out because Richard didn’t have a very high opinion of it. Shaun mentioned Peter Thomas and Bruno Borgers agreed with that.

I initially posted a reply on Shaun’s blog, but because it became a bit longer than intended and didn’t seem to come through correctly, I’ll repost it on my blog here.

There are a few remarks I would like to make about Shaun’s post and Richard’s presentation. First of all, on what statistic is it based that Tapestry is among the 4 most popular web frameworks?

If you look at the poll held by zeroturnaround in 2011 year, Tapestry ends last:


(source: Java EE Productivity Report 2011)

Another zeroturnaround poll in 2011 held specifically for developers in India shows the same thing:


(source: Java Productivity Report 2011: India vs Rest of World)

In 2012, the zeroturnaround poll wasn’t that different, and again Tapestry ends last:

  • Spring MVC (30%)
  • JSF (23%)
  • Struts (17%)
  • GWT (14%)
  • Play! (8%)
  • Wicket (7%)
  • Grails (7%)
  • Vaadin (7%)
  • Stripes (2%)
  • Tapestry (2%)

Participants: 1100+
(source: Java EE Productivity Report 2012)

And in 2014, the zeroturnaround poll didn’t even list Tapestry directly anymore:

  • Spring MVC (40%)
  • JSF (21%)
  • Vaadin (16%)
  • GWT (10%)
  • Grails (7%)
  • Play 2 (6.5%)
  • Struts 2 (6%)
  • Struts 1 (4.5%)
  • Other (Wicket, Seam, Tapestry, Play 1, ZK, VRaptor, 40 others) (18.5%)

Participants: 2164
(source: Java Tools and Technologies Landscape for 2014)

If you take a look at the poll recently held by the German JAXenter, then Tapestry is at number 13, with again only a meager 1% of the votes:

Welches ist Ihr präferiertes Webframework?

    • Vaadin (18%)
    • JSF (16%)
    • Grails (15%)
    • Play! (10%)
    • Wicket (8%)
    • ZK (7%)
    • Spring MVC (6%)
    • GWT (5%)
    • Ruby on Rails (3%)
    • Lift (2%)
    • JAX-RS (Jersey) (2%)
    • Struts (1%)
    • Tapestry (1%)
    • Flex (1%)
    • Stripes (1%)
    • Spring Roo (0%)
    • Roma (0%)
    • JavaFX (0%)
    • Click (0%)
    • Anderes (4%)

Teilnehmer: 1463
(source: Und das populärste Webframework ist…)

In a survey by OIO, published in April 2012, Tapestry is not even present. JSF is the clear winner there, with second place Spring MVC a good deal behind:

Employed Web Framework
(source: OIO Compass: Java web frameworks)

Via a rather informal (to say the least) survey hold on Devoxx ’12, about the preferred way to build the UI of a business app with, nobody even bothered to mention Tapestry:

  • JavaScript/HTML 5 (43)
  • Vaadin (22)
  • JSF (17)
  • JSP/SpringMVC/Struts (17)
  • GWT (17)
  • JavaFX (11)
  • Wicket (10)
  • Swing (8)
  • RCP (7)
  • Angular (6)
  • ZK (5)
  • Grails (4)
  • OmniFaces (3)
  • Play! (3)
  • DART (2)
  • Flex (2)
  • Java Applet (1)
  • AWT (1)
  • India (1)
  • REST + JS (1)
  • SAP v15 (1)

(source: Devoxx ’12 whiteboard)

And just compare the jobs offered for e.g. JSF vs Tapestry:

In absolute numbers JSF dwarfs Tapestry. Now many smaller frameworks can claim some popularity based on relative growth (since it’s often easier to go from 1 to 2 jobs, than from 100000 to 200000), but even there Tapestry shows no growth and is dwarfed by JSF:

Relatively Tapestry is completely obliterated by GWT:

On StackOverflow JSF is also clearly much more popular than Tapestry:

stackoverflow_webframeworks
(source: Stack Overflow tag trends)

According to the above graph, on StackOverflow JSF, Grails and GWT are the biggest ones, while Tapestry is one of the smallest. JSF in particular is even more popular on StackOverflow than the above graph suggest, since a lot of questions use the “JSF-2″ tag instead of “JSF” and tags at StackOverflow are not hierarchical. JSF + JSF-2 is much bigger than just JSF.

When looking at just JSF and Tapestry, the difference becomes even more clear:

stackoverflow_jsf_tapestry

(source: Stack Overflow tag trends)

If I play with the numbers using various other sources (forums, amazon books, postings on dzone, etc etc) they all show the same thing: Tapestry does not seem to be very popular.

So again, I wonder why Richard came to the conclusion that Tapestry is among the top 4? I personally don’t think Tapestry is bad or anything, but I just don’t see it being so popular.

Then specifically about JSF, citing Peter Thomas and Bruno Borges about not liking JSF is questionable at best. Both these two are very much hardcore Wicket evangelists, who seem to have a hard time accepting JSF is apparently more popular than their favorite Wicket. Look at Bruno’s comments on the outcome of the zeroturnaround poll where JSF scored high, and where he tries to downplay the outcome by using the “JSF is not a free choice” card (but the other polls and the amount of open source projects based on JSF prove this is nonsense).

A lot of anti-JSF feelings are based on the older 1.x series (especially 1.0 and 1.1), which indeed wasn’t so good. But from 2.0 onwards, JSF is really a very good web framework and it’s hard to find a lot of concrete faults with it.

For instance, JAXEnter did a direct and in-depth comparison between Wicket and JSF 2.0 and there is no mention at all of the supposed facts that Wicket is so much superior to JSF and that JSF has so many faults. Instead, the article explains both frameworks have strong points and neither is fundamentally ‘bad’.

If you look at the blog of Peter Thomas, all the things he cites are for JSF 1.x. Among his latest additions are that the JSF EG had disbanded after 2.0 with no people to continue it (obviously nonsense, since 2.1 has been released since and 2.2 is in progress, see What’s new in JSF 2.2?), and that James Gosling said he hated JSF (this was nonsense; it’s well known he meant to say JSP).

Shaun mentioned the following in his blog:

[I] have heard enough negative comments on JSF to not want to touch it.

I think Shaun should really give the latest JSF 2.1 release a try. It’s absolutely really good and a completely different experience compared to the old 1.x releases. See  Minimal 3-tier Java EE app, without any XML config for a very simple introduction and JSF 2.0 tutorial with Eclipse and Glassfish  plus Communication in JSF 2.0 for a more elaborate introduction.

JSF being the standard from Java EE and Oracle just naturally attracts more negative comments since it’s well, just popular to bash all things Oracle (and before Sun). I’ve seen people screaming how bad EJB is without ever once having tried it :( Anyway, there are also plenty of negative comments about the other web frameworks (note that I don’t necessarily agree with all of them). E.g.

Play:
Play! Framework Un-features That Really Irk My Inner Geek
Why I’m Moving Away from the Play Framework
Play Framework 2.1: The Bloom is Off The Rose

GWT:
Why Google Web Toolkit Rots Your Brain
Google Web Toolkit Follow-up
I hate GWT
When not to use Google Web Toolkit?
Why I give up using SmartGWT (not GWT itself, but popular extension)
Addressing Misconceptions about Google Web Toolkit
GWT – Common Problems with Solutions
Extra comment for the above link
GWT is cool, but not complete
The disadvantages of the Google Web Toolkit

Tapestry:
Tapestry 5, and how not to treat HTML
tapestry sucks

Wicket:
What I hate about Wicket Framework
Apache Wicket
GWT critics

About these ads
Categories: java Tags: , , , , , ,
  1. October 13, 2011 at 3:52 am

    Looks like the level of this year Richard’s presentation is regrettably low. Not only about Tapestry. Too bad for JavaOne.

  2. October 14, 2011 at 9:48 am

    I thought about writing a blog post with almost the same content.

    How can you compare the most important Java web-frameworks and exclude JSF? I am not a JSF advocate, I also like Play, Wicket and others. Nevertheless, not including JSF in a JavaOne talk is embarrassing!

    Besides: I do not think that the JAXenter survey is representative, because there is a huge difference between “choosing a web-framework” and “liking a web-framework”!

    I would say that JSF and GWT are used in 80 percent of all new enterprise Java projects – and I think most developers are happy with JSF 2.x and GWT 2.x!
    I really like frameworks such as Grails or Play a lot, but in real enterprise projects, I would choose JSF or GWT due to many reasons…

    Best regards,
    Kai Wähner (Twitter: @KaiWaehner)

  3. October 19, 2011 at 2:11 am

    Frankly, I don’t know much about the current state of JSF, but as in my opinion it had such a weak basis to start from, I find it hard to imagine that it would be a framework I would like now.

    In general though, I think Play is one of the few frameworks that “gets” where things have been moving the last two years. Not sure if I would be ready to buy into the whole stack idea, but they certainly try to make development easier and scalable for their users. This has also always been Wicket focus. The scalable part is important. It’s one thing to have a framework that supports creating a HelloWorld example with minimal effort, quite another thing to let it support a medium to large team on a long running project.

    It really puzzles me how both JSF and GWT are the ‘market leaders’ they are. It certainly has little to do with concrete benefits for developers if you ask me. GWT is fancy when it comes to the technical implementation, but my experience doing two substantial projects with it has been horrendous. So much plumbing code, difficulties debugging, tracking down production issues, problems with browser versions (I know, the theory is that that shouldn’t be the case), etc. It seems to me that JSF has the position because of it’s official status and backing, and GWT, well, I guess it attracts to some engineers because it’s from Google and because it is ambitious and complicated.

    I’m really fed up with most frameworks and in particular with doing the bulk of the web UI work in Java. There are so many good JavaScript frameworks out there, and with Jaxrs/ Jersey creating services has gotten so easy, that I see little benefit for most Java web frameworks. I use Wicket because I know it well, and it’s the framework of choice in my company, but I only use it for routing and basic templating and do all the logic directly using jQuery/ Ajax/ JaxRS. With fantastic results so far (though YMMV, you may want to use a JavaScript framework that will do more for you, like data binding).

    My 2c.

    • October 20, 2011 at 9:24 pm

      Eelco, I agree that JSF had a shameful start. You maybe wouldn’t believe it, but I hated the first versions of JSF (and EJB to be honest). But both EJB and JSF have so massively been improved that they’re almost different frameworks now. (I’m planning on writing a separate article about this exact point)

      >but they [Play] certainly try to make development easier and scalable for their users.

      I think scalability is exactly a point where Play! suffers and which is something that is promised to be improved in the future. Look e.g. at the link I posted about Play! http://zeroturnaround.com/blog/play-framework-unfeatures-that-irk-my-inner-geek/

      >It seems to me that JSF has the position because of it’s official status and backing,

      It’s an interesting statement. What makes a framework to actually succeed? The point I made in my post is that JSF is actually hated because of its official status, yet others claim it got where it is because of it.

      I personally think the fact it’s so extendable made it a lasting winner in the end. JSF provided a core to build on, and community innovations like Facelets, PrettyFaces and Seam have been building upon that foundation. Great component libraries like RichFaces and PrimeFaces did the rest (which on their turn stand on the shoulders of the fabulous work being done by jQuery).

      Then, the JSF team did an excellent job by actually *listening* to the community. No ivory tower or design by committee, which I think is applaudable for such a formal standard as JSF.

      >There are so many good JavaScript frameworks out there, and with Jaxrs/ Jersey creating services has gotten so easy, that I see little benefit for most Java web frameworks.

      JAX-RS is absolutely great and super easy to use for services indeed (we use it for Android and iPhone backends), but currently there isn’t any elaborate support for validating data that comes from the client. For the server this is really essential and JSF shines here.

      Purely for the UI I simply like the templating (Facelets), that let’s me easily re-use chunks of the UI and gives my screens a consistent look by using master templates.

  4. October 20, 2011 at 9:40 pm

    > Then, the JSF team did an excellent job by actually *listening* to the community. No ivory tower or design by committee, which I think is applaudable for such a formal standard as JSF.

    That I do agree with. I was actually informally invited to join the expert committee, even though I was involved in a competitor, and in general have found their developers to be very open to discussion and understanding of differences in approaches amongst the frameworks. Every framework comes with it’s own core of cheerleaders of course, and there were quite a few of them for JSF I violently disagree(d) with, but you can hardly fault the developers for that.

    > JAX-RS is absolutely great and super easy to use for services indeed (we use it for Android and iPhone backends), but currently there isn’t any elaborate support for validating data that comes from the client. For the server this is really essential and JSF shines here.

    Well, it’s more manual. You can do a lot of the type casting etc automatically (e.g. by letting it be converted to objects from JSON) and then the validation beyond that is something you’ll have to explicitly define somewhere anyway. In my experience, this is pretty easy and straightforward to do. The only con is that you’ll probably end up with some duplication if you want good user feedback. Not a big deal imho though.

    > Purely for the UI I simply like the templating (Facelets), that let’s me easily re-use chunks of the UI and gives my screens a consistent look by using master templates.

    A framework like Wicket provides this as well, and that and general page to page routing is pretty much the last thing left that I’ll use Java (or whatever server side framework) for still.

    • October 21, 2011 at 1:55 am

      “A framework like Wicket provides this as well” – There is no web framework that does not let “easily re-use chunks of the UI”. Or at least not claiming doing so. And they do it pretty differently. Oracle/JSF team has adopted Facelets. Maybe because it mirrors the latest achievement of Microsoft – ASP.NET MVC 3/Razor? Big players think that they compete to each other.

      I do not think though that Facelets is the best solution for presentation layer suggested – HybridJava is much more handy.

  1. October 31, 2011 at 10:12 pm
  2. November 21, 2012 at 7:49 pm
  3. January 15, 2013 at 3:25 am

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 )

Twitter picture

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

Facebook photo

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

Google+ photo

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

Connecting to %s

Follow

Get every new post delivered to your Inbox.

%d bloggers like this: