Java web framework tournament

March 14, 2008


Scoring rules

Play-in: Loom over Chrysalis

Round 1

Round 2


Final Four





I had a need to compare Java web frameworks for my personal or professional purposes. How to compare? Here’s an idea. This tournament’s creation was inspired by the workings of “March Madness,” Thirty-three frameworks (The actual NCAA tournament has 65 teams) to go head to head in successive rounds until only one is left standing.


Criteria for selection


A “committee” (me) picked the frameworks to compete, in a way inspired by the way that the NCAA committee picks basketball teams (AKA schools).


They are “Traditional” Java web frameworks, involving a Client <-> Web Page <-> Server interaction, usually Model-View-Controller or Page/View – Controller in design. Pure AJAX frameworks such as GWT or Echo2 were not considered at this time.


They must be open source frameworks. I think pretty much all are anyway.


Like the NCAA tournament, the “powerhouse” teams are of course picked, then a selection of “mid-majors”, teams that don’t compete at the powerhouse level but are considered deserving, then there are the last teams to get in – the “small frameworks” are picked. These are obscure frameworks that will get their shot in a tournament. In the NCAA tournament, these small programs are chosen instead by an earlier round of multiple tournaments.


Of course, there will be frameworks, like NCAA tournament teams, that will get in because of buzz and past reputation.


There will be a “play in” match up, just like in the NCAA tournament. Teams that barely make it in or not make it are known as “bubble” teams. If you don’t make it in, then your bubble burst. There are always complaints that a team was “robbed,” didn’t get selected for the field. There are always controversies. Simple fact is, in a 33 team tournament, only 33 teams (frameworks) can be chosen to compete in the tournament. To help counter criticism, the NCAA allowed one more team to play (making 64 into 65) by adding a “Play-in game.” The two weakest teams in the tournament play two days before the actual First Round, to reduce the field back to 64.


There will be 32 total match ups, each decided by judgment according to criteria that follows.


How the match ups are to be decided?


Good question. I see possibly:


The two frameworks that match up in each round could be judged according to these criteria (of course they are all of the committee’s)


            Ease of use / learning curve

            Maintainability – Code base

            Support available

“Subjective” factors

 Doing a sample application for each match up would be a lot of work!
The Field of 33 

The play-in


8 Loom

vs 9 Chrysalis





2 Struts 2 / WebWork

3 Turbine

4 Stripes

5 Mentawai

6 VRaptor

7 Maverick

Winner of the 8 – 9 play in




1 J(Ruby on Rails)

2 Struts 1


4 Lift

5 Phobos

6 Waffle

7 Click

8 XX


      — Meet in finals




1 Spring MVC

2 Wicket

3 Cocoon

4 Trails

5 RSF (Reasonable Server Faces)

6 jZeno

7 Verge

8 Parancoe




1 Tapestry

2 Grails

3 Shale

4 Expresso

5 Helma

6 Aranea

7 Jucas

8 Roma


Bubbles that burst




Hamlets – from IBM


Tea – Classic templating / servlet framework from Disney in the early 2000s, a pioneer

 Tea was designed for projects run by small teams of developers and technical producers. The developer’s role is the creation of “applications” written in Java and installed into the TeaServlet. A producer creates and maintains the final appearance of dynamic web pages by writing Tea templates that call upon functions provided by the developer’s applications. 

SOFIA – Salmon Open Framework for Internet Applications. An older framework that is still maintained. Did it ever much traction?


Other frameworks












Frameworks that were selected by the committee


Descriptions provided from the “about” pages from the frameworks’ websites.


Majors  – Unquestionably these frameworks belong in the tournament because of usage, reputation, extensive support and books and articles.


JSF – This is the Sun standard, according to the Java EE 5 specification. It is the web framework that is the most supported and written about of all in the field.

 JavaServer Faces technology includes a set of APIs for representing UI components and managing their state, handling events and input validation, defining page navigation, and supporting internationalization and accessibility, and a JavaServer Pages (JSP) custom tag library for expressing a JavaServer Faces interface within a JSP page. Designed to be flexible, JavaServer Faces technology leverages existing, standard UI and web-tier concepts without limiting developers to a particular mark-up language, protocol, or client device. The UI component classes included with JavaServer Faces technology encapsulate the component functionality, not the client-specific presentation, thus enabling JavaServer Faces UI components to be rendered to various client devices. By combining the UI component functionality with custom renderers, which define rendering attributes for a specific UI component, developers can construct custom tags to a particular client device. As a convenience, JavaServer Faces technology provides a custom renderer and a JSP custom tag library for rendering to an HTML client, allowing developers of Java Platform, Enterprise Edition (Java EE) applications to use JavaServer Faces technology in their applications.  Ease-of-use being the primary goal, the JavaServer Faces architecture clearly defines a separation between application logic and presentation while making it easy to connect the presentation layer to the application code. This design enables each member of a web application development team to focus on his or her piece of the development process, and it also provides a simple programming model to link the pieces together. For example, web page developers with no programming expertise can use JavaServer Faces UI component tags to link to application code from within a web page without writing any scripts.  

(Java)Ruby on Rails – major because it is Ruby on Rails, maybe the most talked about framework on Earth. It runs pretty much as is under JRuby, a version of Ruby that runs on the Java virtual machine.

 Rails is a full-stack framework for developing database-backed web applications according to the Model-View-Control pattern. From the Ajax in the view, to the request and response in the controller, to the domain model wrapping the database, Rails gives you a pure-Ruby development environment. To go live, all you need to add is a database and a web server. 

Spring MVC – This is the web framework part of the Spring system of frameworks.

 A flexible MVC web application framework, built on core Spring functionality. This framework is highly configurable via strategy interfaces, and accommodates multiple view technologies like JSP, Velocity, Tiles, iText, and POI. Note that a Spring middle tier can easily be combined with a web tier based on any other web MVC framework, like Struts, WebWork, or Tapestry. 

Tapestry – classic component based framework

 Tapestry is an open-source framework for creating dynamic, robust, highly scalable web applications in Java. Tapestry complements and builds upon the standard Java Servlet API, and so it works in any servlet container or application server. Tapestry divides a web application into a set of pages, each constructed from components. This provides a consistent structure, allowing the Tapestry framework to assume responsibility for key concerns such as URL construction and dispatch, persistent state storage on the client or on the server, user input validation, localization/internationalization, and exception reporting. Developing Tapestry applications involves creating HTML templates using plain HTML, and combining the templates with small amounts of Java code using (optional) XML descriptor files. In Tapestry, you create your application in terms of objects, and the methods and properties of those objects — and specifically not in terms of URLs and query parameters. Tapestry brings true object oriented development to Java web applications.

Struts 2 – successor to Struts 1, based on WebWork


Apache Struts 2 is an elegant, extensible framework for creating enterprise-ready Java web applications. The framework is designed to streamline the full development cycle, from building, to deploying, to maintaining applications over time.

Apache Struts 2 was originally known as WebWork 2. After working independently for several years, the WebWork and Struts communities joined forces to create Struts2. This new version of Struts is simpler to use and closer to how Struts was always meant to be.

Struts 1 – greatest framework in Java history, most used even today

 Apache Struts is a free open-source framework for creating Java web applications. Web applications differ from conventional websites in that web applications can create a dynamic response. Many websites deliver only static pages. A web application can interact with databases and business logic engines to customize a response. Web applications based on JavaServer Pages sometimes commingle database code, page design code, and control flow code. In practice, we find that unless these concerns are separated, larger applications become difficult to maintain. One way to separate concerns in a software application is to use a Model-View-Controller (MVC) architecture. The Model represents the business or database code, the View represents the page design code, and the Controller represents the navigational code. The Struts framework is designed to help developers create web applications that utilize a MVC architecture.  

Midmajors  – Chosen according to levels of publicity, usage, and books that are somewhat below the Majors. Well regarded by certain sectors of the Java development community.


RIFE – strength in being using conventions, continuations and a component model

 RIFE is a full-stack web application framework with tools and APIs to implement most common web features. Each of its toolkits is usable by itself and together they offer powerful integrated features that boost your productivity. RIFE ensures that every declaration and definition is handled in one place in the code. This simplifies the developer’s task by reducing code replication, enforcing consistency, and easing maintenance. 

Grails – gaining popularity, based on Groovy and Rails

 Grails aims to bring the “coding by convention” paradigm to Groovy. It’s an open-source web application framework that leverages the Groovy language and complements Java Web development. You can use Grails as a standalone development environment that hides all configuration details or integrate your Java business logic. Grails aims to make development as simple as possible and hence should appeal to a wide range of developers not just those from the Java community. 

Cocoon – pipeline oriented framework, classic for XML/XSLT processing

 Apache Cocoon is a Spring-based (since version 2.2) framework built around the concepts of separation of concerns and component-based development. Cocoon implements these concepts around the notion of component pipelines, each component on the pipeline specializing on a particular operation. This makes it possible to use a Lego(tm)-like approach in building web solutions, hooking together components into pipelines, often without any required programming. Cocoon used as web framework is “web glue for your web application development needs”. It is a glue that keeps concerns separate and allows parallel evolution of all aspects of a web application, improving development pace and reducing the chance of conflicts. In particular it makes it easy to support multiple output formats, offers continuation based web controller implementations and comes with a JSR-168 compatible Portal implementation. 

Shale – potential successor to Struts 1, JSF based views, MVC

 Shale is a modern web application framework, fundamentally based on JavaServer Faces. Architecturally, Shale is a set of loosely coupled services that can be combined as needed to meet particular application requirements. Shale provides additional functionality such as application event callbacks, dialogs with conversation-scoped state, a view technology called Clay, annotation-based functionality to reduce configuration requirements and support for remoting. Shale also provides integration links for other frameworks, to ease development when combinations of technologies are required. 

Wicket – component based framework, compared to Tapestry, JSF

 In other words, ideally, Wicket is a web UI framework that delegates as many areas of responsibility as possible to other, more focused tools and techniques. It recognizes that Hibernate is good at persistence; that OGNL is good at string formatting; that Java properties files are good for localization; that sub-classing is good for creating component types; that Dreamweaver is good at doing HTML layout; that Beans are good for structuring properties; and so on. 

Turbine – classic, once somewhat popular and a major framework in its day. Was chosen in large part for its past glories.

 Turbine is a servlet based framework that allows experienced Java developers to quickly build web applications. Turbine allows you to use personalize the web sites and to use user logins to restrict access to parts of your application. Turbine is an excellent choice for developing applications that make use of a services-oriented architecture. Some of the functionality provided with Turbine includes a security management system, a scheduling service, XML-defined form validation server, and an XML-RPC service for web services. It is a simple task to create new services particular to your application. The Turbine core is free of any dependency on a presentation layer technology. Both JavaServer Pages (JSP) and Velocity are supported inside Turbine   

Other significant and older frameworks


Stripes – The framework seems too Struts 1 like, albeit with good use of annotations. Much praise from within the user community often preferred to Struts 1 or 2.

 Stripes is a presentation framework for building web applications using the latest Java technologies. The main driver behind Stripes is that web application development in Java is just too much work! It seems like every existing framework requires gobs of configuration. 

Expresso – “The most popular Java architectural framework.” – maybe back in 2001?

Expresso enables rapidly developing web based applications, in a fraction of the time required to develop these applications normally. Most importantly Expresso is highly scalable, robust, portable, stable and secure. Expresso is built around a core of 16 separate, but highly integrated, application framework components for J2EE. Individually, each of these framework components solves complex technical challenges that developers traditionally must solve on their own before writing a given business application. When combined together, they solve innumerable application development challenges, and free a development team from having to write application architecture, allowing the team to focus on writing the applications that support the business at hand.

Maverick – In principle it combines the best features of Struts, WebWork, and Cocoon2

 Maverick is a Model-View-Controller framework for Java web publishing. It offers clean MVC separation, configurable transformation pipelines, an XML sitemap, browser detection, i18n, and support for a wide range of templating and xform technologies. 

Smaller frameworks (mind and market share) – To be selected, small frameworks were chosen for unique features and/or on the basis of adequate documentation existing.


Mentawai – Said to have advantages in configuration.

 We also realized early that for Mentawai to acquire high levels of productivity it must be joyful. It must be fun. It must not be boring. And we have a very good example of a big Java failure that probably sent many people to a different career other than programming: Enterprise Java Beans (EJB). EJB (EJB1 and EJB2) was everything but joyful. I am proud of myself for not having to write a single EJB project in my life. Huge XML deployment descriptors, many different classes to do a single thing, many tricks that you must know or nothing will work, crazy integration with non-sense application servers (some costing thousands per CPU) and you have a recipe for a Rube Goldberg Machine

RSF – This is self-described as the ‘Reasonable’ alternative to JSF. It is well documented.

 Reasonable Server Faces (RSF) is an open source web programming framework written in Java , and built on the Spring framework . It provides for Pure XHTML templating and complete request lifecycle handling. 

Phobos – Javascripting on the server

 Phobos is a lightweight, scripting-friendly, web application environment running on the Java platform.It comes with a set of plugins for the NetBeans IDE that cover the complete development process. These include a fully-featured debugger; wizards to help you get started faster; a palette of Ajax widgets that can be dropped on a page, thanks to jMaki; and the ability to generate a standard web application for deployment on any servlet container or Java EE application server. 

Aranea – OO component based framework that even allows other frameworks to be made into components.

 Aranea is an Open-Source Java MVC Web Framework that provides a common Object-Oriented approach to building the web applications, reusing GUI logic and extending the framework. It comes with out-of-the-box support for nested flows and database-backed query browsing. Additionally it serves as an integration platform, allowing free intermingling of arbitrary frameworks, components and applications. 

jZeno – This framework features an all Java UI development on the server.

 jZeno is an open source java development framework that offers the ability to develop rich web applications. The main architectural goal of jZeno is to allow people to create web applications using pure java development as much as possible. Largely reducing the need to know technologies like javascript, HTML, CSS, database specific SQL, JSP, JSF, etc… Instead of expressing things on a low technical level we not only provide standard components to use, but encourage people to focus on learning more important skills much deeper. We think these skills are a thorough understanding of java, OO development, design patterns and other abstraction techniques.  

Helma – This allows JavaScript to be used on the server side.

 Helma is written in Java and employs Javascript for its server-side scripting environment, removing the need for compilation cycles and reducing development costs while giving you instant access to leverage the whole wealth of Java libraries out there.Helma pioneered the simple and codeless mapping of application objects to database tables. In addition, an embedded object-oriented database performs automatic data persistence of unmapped objects. 

Lift – This is based on Scala, the alternative language for the Java virtual machine that is based on a functional programming paradigm. (This framework was formerly known as Sails)

Lift is an expressive and elegant framework for writing web applications. Lift stresses the importance of security, maintainability, scalability and performance, while allowing for high levels of developer productivity. Lift borrows from the best of existing frameworks, providing Seaside’s highly granular sessions and security, Rails’ fast flash-to-bang, Django’s “more than just CRUD is included” and Wicket’s designer-friendly templating style.

Trails – Tapestry on RAILS

 Trails is a domain driven development framework in the spirit of Ruby on Rails and Naked Objects.The trails project aims to make Java enterprise application development radically simpler by allowing developers to focus on the domain model and having other portions dynamically generated. We will leverage existing technologies such as Spring, Tapestry, and Hibernate rather than reinventing the wheel. 

VRaptor 2 – Uses annotations to connect Java classes with views.

 It is a web mvc and ioc framework which was based on many frameworks and ideas (JBoss Seam, Stripes, Webwork, Hibernate Annotations etc).VRaptor2 makes full use of Java 5 Annotations. The result? A simpler way to deal with web programming. Your business logic classes have no contact with javax.servlet API, and there is less need of configuration than with other web controllers.It favors Convention over Configuration. Why? Because configuration in xml/properties/annotations is always boring, easy to make mistakes and repetitive.  

Waffle – No mandatory XML

Waffle is a Java web framework that makes the process of developing Java based web applications easier. It was built to support enterprise level web-based business applications, but with the least possible number of source lines to achieve that.Click – Click is JSP and MVC Free. The design philosophy behind Click is best summarized in the Swedish word lagom which translates to not too little or too much, but optimal. 

Verge – J2EE toolkit

 Verge is a suite of tools that help developers build J2EE applications by providing a variety of tools and frameworks that developers can use to minimize the up-front overhead of creating those frameworks themselves. Verge also includes other projects such as Savant, an extension to the Ant build system, and a JUnit framework. Verge focus mainly on development of large enterprise systems that use J2EE standards. 

Jucas –  MVC and component UIs

 Jucas is a web-framework which brings together the pull MVC concept with component orientated design GUI programming. Struts (like other Model II frameworks) have brought the separation between View and Model and Controler to the web programming. On the other hand recent frameworks like Java Server Faces (JSF) or ASP.NET try to provide the advantages of object (component) orientated GUI-Design known from ‘fat-client’ apis like Swing or Visual Basic (stateful objects, event-mechanismus). Jucas combines both approaches. Stateful components (JavaBeans) are used to represent the model and the controller and templates use this components to render the view.  

Roma – “The new way to conceive Web Applications”, an MDA application?

 Roma is an Open Source initiative to make Java application development easy. The approach is totally DDD: let’s think to the domain of your application and Roma will make the rest: persistence (database), presentation (HTML + Ajax), logging, user management, sessions, workflow, scheduler, etc. Roma is also a MDA implementation since takes its concepts and philosophy but it’s totally based on POJOs with no need to learn other micro languages and complex standards. 

Loom – “Take back the joy of web development”

 Loom is an open source Java web framework that handle user input validation, web flow and HTML generation for enterprise applications of any size. There are some important features that differentiate Loom from other frameworks:

XX – A configurable, XML/XSL-centric implementation of the MVC development paradigm.

 The XX framework is a configurable, XML/XSL-centric implementation of the MVC development paradigm. The primary goal of the XX Framework is to handle typical application CRUD (create, retrieve, update, delete) with little or no Java programming. Instead of telling the application how to retrieve and how to display the data, we configure what to retrieve (through XML) and what to display (through XSLT).  This approach generally leads to a simpler and more elegant solution than a purely procedural approach. Where the applications needs more than simple CRUD, additional business logic can be easily incorporated into the process. Some additional features of the framework are configurable data caching, thread pooling, and web service integration.  Chrysalis – framework for Java web development supporting data-entry-oriented business applications. Chrysalis is a Java web development framework. It has a different focus from most Model-View-Controller (MVC) web frameworks. Chrysalis controllers resemble normal Java classes with multiple methods. Client request URLs are mapped to each controller method.The typical MVC framework is founded on one basic insight: that Java servlets can be treated as an event handler for the submit button of HTML forms. This makes servlets analogous to the controller in the MVC pattern, equivalent to the Listener classes used in Java GUIs. From this insight, the rest of the pattern follows easily (see Struts for the most popular implementation of this approach). 

Parancoe – Meta-framework integrating Spring, DWR and Hibernate

 Parancoe is a Java meta-framework aggregating in an useful way Hibernate/JPA, Spring 2, Spring MVC and, for the AJAX support, DWR. Parancoe purpose is to give to developers a set of libraries ready to build standard web applications (which in most cases are just crud applications) without worrying of long and harmful configurations files. Parancoe will be composed of a full MVC stack.  

Seeding notes


The # 1’s


JSF received the #1 in the East, making it the top seed in the tournament. This is due to its position as the Sun Java EE standard bearer, its widespread support by major Java vendors, and the plethora of articles and books describing it. It arguably has been the fastest growing framework over the past 3 years.


JRuby on Rails got a #1 because it is essentially Ruby on Rails. One of the most talked about frameworks in Web history, its reputation got it a #1.


Spring MVC – Spring is perhaps the most important general framework for Java in the past 5 years. Spring MVC is a major component of this.


Tapestry got the #1 in the West over Struts 2. Struts 2 and Spring MVC are pretty similar in many ways. Tapestry gets credit for being a pioneering framework in being component based and its has been a rival to JSF over the past 4 years. So Struts 2 fell to a #2 seeding.


Older frameworks in the field


Reputation and/or widespread usage over time got these into the field, with reasonably higher seeds.


Struts 1 is the most popular web framework in Java history. It is also still the most deployed and sought after, even in 2008. It likely would have garnered a #1 seeding, except for its age. It is still an actively maintained project.


Espresso, Maverick, Cocoon and Turbine are as old/older as Struts 1, but have probably not aged quite as well. But both were significant/major frameworks in their day, and are still located (particularly Turbine) in many deployments.


Other seedings notes


Stripes wound up as a #4, comparable to say Lift. It is well documented, has many supporters and is preferred by some very vocal advocates in the java development community. However, its similarity to Struts 1 and other strict MVC variants, and worst of all, no published books, caused it ultimately to not be included in the list of mid-major frameworks.






3 Responses to “Java web framework tournament”

  1. gwynevans Says:

    Hmm – have a strong suspicion that your grouping just leaves you making arbitary choices about the results of comparing oranges & apples.

    I’m afraid that what you really need to decide is what criteria are important to you, then evaluate the webapps in light of that – e.g. “backwards compatability with established sites” might point to Struts 1, “politically correct management” might suggest JSF, while “component based web-app by Java coder(s)” should suggest Wicket (Disclosure:I’m a commiter there). I don’t see, for instance, how you can reasonably compare Tapestry & Grails, or Ruby-on-Rails & Struts without criteria…

  2. […] Read the description and explanation of the […]

  3. […] Java web framework tournament […]

Leave a Reply

Please log in using one of these methods to post your comment: Logo

You are commenting using your 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

%d bloggers like this: