Wazi » Comparisons

Comparing Open Source Agile Project Management Tools

Brad Swanson — Mon, 21 Sep 2009 19:03:14 +0000

There are a large number of project management tools designed to support Agile methodologies such as Scrum and eXtreme Programming (XP), including several open source options. This article compares the most compelling open source options on the following criteria:

Feature set
Usability
Viability
Suitability for large projects and products

Background

Agile development methods, including Scrum, XP, Crystal, FDD, and DSDM, have gained widespread adoption and acceptance in recent years. IBM’s Rational Unified Process (RUP) has been tailored to create the Agile Unified Process (AUP). The agile approach has gained traction even in large organizations with complex projects and geographically distributed teams, including IBM. While the Agile Manifesto favors “individuals and interactions over process and tools”, a well-crafted tool for managing agile projects has clear advantages, and is essential as agile teams and organizations grow to geographically distributed locations and enterprise scale.

Agile software and open source have enjoyed a tight relationship through the years, with several open source projects being inspired by and integral to the agile movement.

Unit testing: XUnit (JUnit, NUnit, etc.), various Mock Objects frameworks
Acceptance testing: Fit and FitNesse, HttpUnit, etc.
Integration tools: Cruise Control, Hudson
Behavior driven development tools…

The market for agile project management tools is now mature and saturated, with dozens of offerings from both small and large vendors, and more products hitting the market regularly. Market leading commercial offerings include Rally, VersionOne, Thoughtworks Mingle, and Danube ScrumWorks. A few open source tools have been around for some time, and several have emerged more recently. Compared to the open source offerings, the leading commercial tools offer better features for large organizations and large scale products and projects. They also tend to offer more integrations with third-party applications. Those extras come at a price, of course.

Contenders

This article compares only open source agile project management tools, and (with one exception) only considers projects under active development that have demonstrated significant usage (measured by a combination of download volume, discussion activity, and volume of internet references to the tool).

*It’s true that XPlanner is no longer actively developed, but it gained widespread usage years ago, with over 45,000 downloads of the latest version (0.7b) alone. We included it in this comparison because it provides a good baseline to determine how the tools have matured in the past few years.

Some open tools that didn’t quite make the cut due to lack of apparent usage include Agilito, Scrinch, and FireScrum.

Comparison Summary

This section provides a high level comparison of the five contenders. A deeper discussion of each tool follows this section.

Legend:

√ Feature is included

X Feature is not included

√¹Superscript number: see notes below the table for more information

* 1 star rating: poor

** 2 star rating: acceptable

*** 3 star rating: good

*** 4 star rating: excellent

	Agilefant	IceScrum	Agilo	eXPlainPMT	XPlanner
Version reviewed	1.6.2	2#13	1.0.2 Pro	? (online demo)	0.7 beta
License	MIT	GPL	Apache License 2.0	GPL	LGPL
Platform	Java 6, Tomcat 5.5, MySQL	Java 1.5, Servlet engine, HSQLDB (or other RDBMS)	Python,Trac open source ticket system, RDBMS (SQLite, MySQL, PostgreSQL)	Ruby, RDMBS (MySQL, PostgreSQL, or SQLite)	Java 1.5, Tomcat 5.0 (not 5.5), Servlet 2.3, MySQL (or other RDMBS)
Backlog absolute ranking vs. prioritization	Priority, 1-5 scale.	Ranking, drag and drop.	Ranking, drag and drop.	Ranking, not drag and drop.	Ranking, not drag and drop.
Story points	X	√	√¹	√	X
Task hours	√	√	√	X	√
Task board view	X	√	√	X	X
Iteration burn down chart	√	√²	√³	X⁴	√
Epics (hierarchy of backlog items)	X	√	√⁵	√⁶	X
Releases	√	√	√⁷	X	X
Roadmap (multiple releases)	√	√	√⁸	X	X
Multiple products/ projects	√	√	√	√	√
Portfolio planning	√	X	X	X	X
Acceptance tests	X	√	X	√	X
Impediment tracking	X	√	√	X	X
Defects as backlog item type	X	√	√⁹	X	√
Story Themes	√	X	X	X	X
Teams of users	√	X	√	√	X
User roles	None	PO, SM, Team Member, Stakeholder, plus custom roles.	SM, PO, Team Member.	None	Viewer, Editor, Admin, Super Admin.
Reports	* Timesheets only.	X	*** Can save customized reports.	X	*** Extensive built-in reports, but no custom reporting.
Integration & API(s)	None	None	SVN, trac, mylyn	None	SOAP, notation for URL linking.
Dev. status	Active; V2 due “soon”	Active; R3 late 2009	Active; last release Feb. 2010	? Last commit Nov 2008	Dormant; last release May 2006
Support	Email, forums.	Email	Commercial (8 € per month per user).	None	Forums, but inactive.
Forums	**	**	**** 2 topics per day.	None	* 2 topics per month average, few replies.
Installation guide	***	* French only	***	None	**
User docs	**	**	**	None	*
Usability	***	** Not always intuitive.	** Not always intuitive; lots of clicks.	*** Intuitive	***
Suitability for large projects.	*** Portfolio planning with project ranking. Teams.	* Only 1 release and 1 sprint can be active. Can’t have overlapping sprints. Hard to prioritize large backlog in Notes view.	**	* Only 1 iteration at a time.	* No releases.
Pros	Rich feature set. Timesheet feature.	Rich feature set. Good task board view. Planning poker feature.	Great whiteboard view.	Intuitive.	Intuitive. Rich charts and reports built in.
Cons	No task board view.	Not always intuitive. Not suitable for large projects.	Some common actions require lots of clicks.	No support or forums. Status uncertain. No hours for tasks. No sprint burndown.	Inactive and Not supported. Not suitable for large projects. Doesn’t directly support releases/roadmaps.

Notes:

Agile allows only pseudo-Fibonacci numbers for story points.
IceScrum’s iteration burndown chart is flawed; the horizontal axis shows only days elapsed so far in the sprint rather than full time range of the sprint.
Agilo’s iteration burndown chart is flawed in the online demo version; the vertical axis scale is off.
eXplainPMT has a burndown chart for the whole project, not for each iteration.
Agilo’s backlog hierarchy is not easy to use; it requires associating items by item number.
eXplainPMT has “initiatives” that are similar to epics, but they are only an attribute of a story.
Agile uses the term “milestones” in place of “releases”.
Agilo’s roadmap feature shows all sprints and a lot of scrolling is required to see all releases.
Agilo has a separate bug backlog.

Agilefant

URL: http://www.agilefant.org/

Version reviewed: 1.6.2 [Note: Version 2.0 is promised “soon”.]

Technology: Tomcat 5.5, MySQL, Java 1.6

License: MIT

Concepts

Products are the highest level construct, and each deployment may have multiple products. Each product may have one or more projects, which are essentially releases. Each project may have one or more iterations. Each product, project (think “release”), and iteration has its own backlog, which contains stories. Stories can be moved to any other backlog, for example from the product backlog to an iteration backlog. Stories may consist of zero or more tasks. Projects can be prioritized in the Portfolio view.

The tool supports multiple concurrent iterations, which allows larger organizations to use the tool effectively.

Agilefant supports multiple users and users can be grouped into teams. However, it does not support any user roles; a user is a user, with no differences in permissions or access to features. Teams can be assigned to specific iterations.

Version 1.6.2 does not include the concept of higher-level features or epics, although this feature is promised in version 2.0 which is supposed to be released soon. It does support the concept of themes, which are an attribute of stories, and this does provide a simplistic way to associate a group of stories.

Viability, Support & Documentation

The product documentation is adequate but not excellent. The product is intuitive enough that not much user documentation is necessary. The installation documentation is sufficient. Forums and email support appear to be fairly good. Development is active with version 2.0 supposed to be released soon, although no particular date for the release has been published.

Usability

Agilefant is intuitive. We were able to figure out how to use all features without relying on documentation. It lacks “drag and drop” features, but it otherwise makes good use of client-side features that make the user interface more responsive.

Strengths

Rich feature set.
Suitable for larger organizations and projects, except for the lack of “epics” or story hierarchies. (Version 2.0 should fix that shortcoming.)
Reasonably intuitive and easy to use.
Portfolio planning feature.
Timesheet feature.

Weaknesses

Stories can be estimated in hours only, not points.
Stories cannot be ranked absolutely; they can only be prioritized on a scale of 1 to 5.
No “drag and drop” re-ordering of stories.
No “epics” or hierarchy of stories. Note that a story hierarchy is promised for version 2.0.
No “task board” or “whiteboard” view.
No differentiation between user roles.

Overall Rating

Agilefant is a very capable tool with a rich feature set and a few weaknesses. It is better suited for large projects and large organizations than any of the other tools reviewed in this article, but the lack of a hierarchy of story/requirement levels (a.k.a. “epics”) is a significant drawback for large projects. The lack of epics or a hierarchy of stories, however, is a big weakness to overcome for large scale projects.

Screenshots

Above: Tree-style navigation in Agilefant.

Above: Objects that a user can create in Agilefant.

Above: The Iteration Details view in Agilefant.

Above: The list of stories and tasks within an iteration in Agilefant.

Above: The Iteration Burndown chart in Agilefant.

Above: The Daily Work view in Agilefant.

Above: The Product view in Agilefant.

Above: Agilefant’s Development Porfolio view allows projects (releases) to be ranked.

Above: Agilefant’s Timesheets feature provides a report of how users have spent their time.

IceScrum

URL: http://www.icescrum.org/

Version reviewed: 2#13

Technology: Java 1.5 with servlet engine (e.g. Tomcat). Bundled with HSQLDB, but can be configured to work with other DBMs such as MySQL.

License: GPL

Concepts

Products (also called projects in some places) are the highest level construct, and each deployment may have multiple products. Each product has a single backlog and a roadmap. A backlog contains features (similar to epics), user stories, defects and technical stories. A roadmap contains multiple releases, each of which has a single release plan. A release plan consists of multiple sprints. Each sprint contains stories, which in turn contain tasks and acceptance tests. Impediments can be tracked for each product.

Unlike Agilefant, IceScrum includes a task board/whiteboard view of the iteration, allowing tasks to be dragged and dropped. It also allows drag and drop ranking of user stories in the backlog. Many options are available only from a right-click context menu, which isn’t obvious at first but is easy to use once you notice it.

IceScrum is the only product reviewed that has a planning poker feature. This feature allows a distributed team to play planning poker for estimating features and user stories.

IceScrum allows only a single release and single sprint to be active at one time (for a particular product), making it unsuitable for larger organizations that need multiple concurrent sprints with multiple teams running in parallel for a single product.

IceScrum users may have any of the Scrum roles (Product Owner, Scrum Master, Team Member, Stakeholder) plus custom roles may be created. It does not allow users to be grouped into teams.

Beyond a burndown chart, IceScrum does not have any reports or reporting API.

Viability, Support & Documentation

The product documentation is adequate but not excellent. The installation guide is written only in French. Forums and email support appear to be fairly good. Development is active.

Usability

Some features are available only from right-click context menus. This is fine once you discover it, but it’s not obvious to new users. It has a relatively rich user interface with drag and drop capability in several places.

Strengths

Rich feature set.
The Sprint Backlog view resembles a physical task board quite effectively.
The Roadmap, Release Plan and Sprint Plan views support multiple levels of planning.
Acceptance tests can be recorded for each story. A BDD-inspired template for acceptance tests is available.
Includes a planning poker feature.
Supports absolute ranking of stories by drag and drop, and estimates in story points.

Weaknesses

The story card layout would make it difficult to rank a large product backlog.
Some features are not intuitive. Drag and drop works in some places but not in others, even though the mouse cursor make it seem that drag and drop should work. The right-click context menu is not obvious, but it’s easy to use once you discover it.
IceScrum is not suitable for large projects with multiple teams working on a single product; only a single release and single sprint can be active at one time.

Overall Rating

IceScrum is a very capable tool with a rich feature set and a few weaknesses. Although it supports multiple products (projects), it is suitable only for small projects with a single team working on one sprint at a time per product.

Screenshots

Above: IceScrum’s Feature view. Features are high-level requirements akin to epics.

Above: Creating a user story in IceScrum’s product backlog.

Above: IceScrum’s Product Backlog view. Each story card can be dragged and dropped to change ranking. Features (epics) are associated with a story by dragging the feature from the left side of the page onto the desired story.

Above: Right-clicking on any story card gives a context menu.

Above: IceScrum’s Sprint Backlog view. To add a story from the product backlog to the sprint, drag the story from the left side of the page and drop it in the story area of the sprint.

Above: IceScrum’s Roadmap view shows the timeline of releases and sprints within the release.

Above: IceScrum’s Release Plan view. Product backlog items can be dragged and dropped onto any sprint.

Above: IceScrum’s Sprint Burndown view. The burndown is flawed, showing only the actual days elapsed so far on the horizontal axis rather than the full time range of the sprint. In the screen shot above, the sprint is 14 days, but the burndown shows only the first 2 days.

Agilo

URL: http://www.agile42.com/cms/pages/agilo/

Version reviewed: 1.0.2 Pro (demo instance at https://agilo.agile42.com/login with login: demo/demo)

Technology: Python (2.4, 2.5, or 2.6), SQLite (also PostgreSQL or MySQL). Built on Trac 0.11 (open source ticketing system built on Python).

License: Apache License 2.0

Concepts

Each deployment can have multiple milestones (releases). The backlog contains requirements, user stories and tasks. These three item types support a hierarchy by reference: requirements can reference stories, and stories can reference tasks. This hierarchy is difficult to establish and utilize, however. Agilo has a separate backlog for defects, which makes it difficult to prioritize defects relative to user stories. It also has a separate impediment backlog.

Users can be given the roles of Scrum Master, Product Owner, or Team Member. Users may also be grouped into teams.

Agilo includes an excellent and intuitive task board/whiteboard view of the iteration, allowing tasks to be dragged and dropped. This is by far the best feature of the tool; other features are less untuitive. Perhaps Trac users would find it more friendly?

Agilo has a simple dashboard with a sprint burndown chart, a graph of stories and tasks (total, planned, and closed), and allocation of tasks to team members by percent. In addition, it allows custom queries and reports to be created and saved.

Viability, Support & Documentation

The product documentation is adequate but not excellent. The forums are very active and seem to be a good place for support. The Pro version includes professional support for about €8.50 per month.

Usability

I found some of Agilo’s features to be unintuitive and difficult to use, requiring many clicks and pages to accomplish common tasks. The task board/whiteboard feature, however, is excellent and very easy to use.

Strengths

Excellent task board/whiteboard iteration view with drag and drop functionality.
Supports absolute ranking of stories by drag and drop, and estimates in story points.
Good reporting features, including user-customized reports that can be saved.

Weaknesses

Some features are not intuitive. It feels like Trac didn’t support agile concepts very well so they had to be force-fit into Trac’s model.
When creating a task, it can be associated with a sprint, but not with a story.
Many operations require lots of clicks to complete.

Overall Rating

Although the task board/whiteboard view is intuitive and excellent, other features are less intuitive and often not very easy to use. The sprint burndown in the demo instance was flawed, showing 1200 hours when only 37 hours of tasks were planned.

Screenshots

Above: Agilo’s Product Backlog view.

Above: Agilo’s Sprint Backlog view. This view is confusing because tasks don’t appear underneath their stories. In the example above, 2174 and 2176 are tasks for story 2173. They can be dragged and dropped to an intuitive position, although in some views I was unable to do even that.

Above: Agilo’s Sprint Burndown. This chart was flawed, showing 1200 hours on the vertical axis when only 37 hours of work were planned.

Above: Agilo’s Whiteboard view. This is one of the best features in the tool. It’s quite intuitive, with drag and drop capability. Add a new task to a story by clicking the “+” symbol. Tasks can be edited inline by right-clicking.

Above: Agilo’s Roadmap view. This view shows all milestones (releases) plus a summary of each sprint in each milestone. With multiple sprints per milestone, a lot of scrolling is required to see the big picture, which makes this feature rather ineffective.

Above: Agilo’s Bug Backlog. Bugs are tracked in their own separate backlog, which is a drawback since they can’t be prioritized relative to other product backlog items such as user stories.

Above: Associating requirements (epics) with user stories and stories with tasks in Agilo. This feature is not easy to use since stories must be separately looked up by number, then individually entered on this page.

Above: An Agilo user story showing references to a requirement (a.k.a. epic) and a task.

Above: Agilo’s View Tickets page, which lists built-in and user-defined reports.

Above: A sample report from Agilo – active tickets by milestone.

eXplainPMT

URL: http://github.com/explainpmt/explainpmt/tree/master

Version reviewed: No version specified at demo site: http://github.com/explainpmt/explainpmt/tree/master (login: demo/demo)

Technology: Ruby, RDBMS (SQLite, PostgreSQL or MySQL)

License: GPL

Concepts

The highest level construct is the project, and eXplainPMT supports multiple projects. Each project has one or more releases, and iterations. Note that iterations are associated with projects, not with releases. A project has one backlog, and a backlog contains stories. Stories have tasks and acceptance tests, and can be assigned to a release. Stories may also be associated with an initiative, which is somewhat like an epic, except initiatives cannot be ranked or prioritized. Surprisingly, tasks do not have estimated or actual hours; they have only two states: incomplete or complete.

Users in eXplainPMT do not have specific roles; all users are the same. Users may be grouped into teams.

Viability, Support & Documentation

eXplainPMT has no user guide and only a brief README file for an installation guide. It has no forums, nor any email support. It is unclear whether development is still active; the last update was November 2008.

Usability

The user interface is straightforward and intuitive, but some very basic features are lacking. For example, after creating a story in the backlog, it cannot be moved into an iteration. In addition, eXplainPMT does not support drag and drop nor the richer experience of modern browser applications.

Strengths

Intuitive interface.
Supports the definition of acceptance tests for stories.

Weaknesses

Cannot estimate or track task hours!
No task board/whiteboard view.
No iteration burndown chart.
No releases or roadmap.
Development status is unclear; the last update was November 2008.
Support and documentation are almost non-existent.
Not suitable for large projects since it allows only one iteration to be active at a time.

Overall Rating

eXplainPMT is missing many important features, the development status is uncertain, and support and documentation are almost non-existent. It does not support large teams. Agilefant, IceScrum, Agilo and XPlanner are all likely to be better tools for most agile teams.

Screenshots

Above: eXplainPMT’s Projects view.

Above: eXplainPMT’s Releases view.

Above: eXplainPMT’s Iteration view.

Above: eXplainPMT’s Backlog.

Above: eXplainPMT’s Initiative view. Initiatives are logical groupings of stories.

Above: eXplainPMT’s Story view.

Above: eXplainPMT’s Project Burndown. The burndown, measured in points, is for the whole project only, not for iterations.

XPlanner

XPlanner is included in this comparison because at one time it had a large user base and was the primary tool in this category. Although the project is dormant now, it serves as a good baseline for seeing how tools have changed in the past few years.

URL: http://www.xplanner.org/

Version reviewed: 0.7b (beta)

Technology: Java 1.5, Tomcat 5.0 (not 5.5), MySQL

License: LGPL

Concepts

The highest level construct is the project, and XPlanner supports multiple projects. It does not include releases. Each project has one or more iterations. It does not include a product backlog, but a workaround is to create a special iteration to use as a product backlog. Iterations contain stories, and stories contain tasks. Tasks may be of type feature, debt, defect, ftest (functional test), atest (acceptance test), or overhead. Stories are estimated in hours, and tasks are estimated and tracked in hours.

Users in XPlanner can be assigned four permission levels: Viewer (read only), Editor, Admin., or Super Admin. XPlanner does not have a team construct for grouping users.

Viability, Support & Documentation

The last update to XPlanner was in May 2006, so it’s safe to say the project is dormant. The project does have forums for support that contain lots of useful help but they are inactive now; the forum averages two new topics per month with a few replies each. The installation documentation is sufficient although it’s only a README file in the latest version 0.7b. User documentation is minimal, but the tool is intuitive enough that little documentation is necessary.

Usability

XPlanner’s UI is straightforward and intuitive. However, it lacks most of the client-side (AJAX-based) usability features of most modern browser applications.

Strengths

Intuitive interface.
Rich built-in reports and charts.
SOAP API for integration.
Customizable notation for simple URL linking with external systems such as defect tracking.

Weaknesses

No releases or roadmap.
No task board/whiteboard view.
No story points.
No “epics” or hierarchy of stories/features/requirements.
The project is dormant, with the last update in May 2006.
Support is very limited since the project is dormant.

Overall Rating

Despite its shortcomings, XPlanner is still a good tool for small teams. Since the project is dormant and other tools have better features now, we recommend Agilefant, IceScrum or Agilo over XPlanner, but recommend XPlanner over eXPlainPMT for most teams.

Screenshots

Above: Defining a story in XPlanner.

Above: XPlanner’s Iteration view. Stories are ranked by manually renumbering them. You can move a story to a different iteration with the 3^rd action icon.

Above: XPlanner’s Story view

Above: Recording time spent on a task in XPlanner.

Above: XPlanner’s Iteration Progress chart, showing estimated and actual hours.

Above: XPlanner’s Iteration Burndown, showing hours remaining in the iteration.

Above: A variety of built-in charts in XPlanner’s chart view.

Above: XPlanner’s Metrics view.

Above: XPlanner’s accuracy metrics, showing the accuracy of estimates.

Conclusion

Overall I give high marks to Agilefant, IceScrum and Agilo. XPlanner has significant drawbacks but is a very capable tools the feature sets meet your needs. eXPlainPMT is missing too many key features and its development status is uncertain, so I don’t recommend it. However, each organization should consider its own situation and feature needs before choosing a tool. Particular features may be very important for one organization but not for another.

Survey of Open Source Modeling Tools for Software Development

Grant Smith — Thu, 05 Feb 2009 18:21:55 +0000

Poor planning is one of the top reasons why software projects are delivered late, over budget, or not at all, so it’s important to get organized before you start coding. For decades programmers tried all manner of flow charts, elaborate diagrams, and volumes of specifications in an attempt to fully understand the code they planned to write, but these methods often proved to be ineffective and time consuming. Fortunately, programmers today can choose from a wide range of modeling tools that make it relatively easy to lay out the functionality and use cases for a new project.

In this article we’ll survey some of the modeling tools available to help you streamline the development planning process. All of the modeling tools covered in this survey are open source applications. The modeling tools addressed in this survey are:

Background

As modeling tools have evolved, they’ve blurred the boundaries of traditional software development planning. For example, some modeling tools can analyze and reverse engineer source code in order to produce UML diagrams. Similarly, most modeling tools support model-driven architecture (MDA), which means they can generate code from the models. Whether or not you use those features — and to what extent — is up to you. One option is to use the generated code as a skeleton and add in technology of your choice further down the road.

Most of the modeling tools covered in this survey use the Unified Modeling Language (UML), so you may wish to become proficient in UML to maximize your understanding of these tools. In addition to UML compliance, some of the other factors we’ll examine for these modeling tools include:

Code generation capabilities
Ease of use
Documentation

We’ll start by taking a look at “contenders” that have unique strengths or benefits but lack some of the features we feel are most desirable. Then, we’ll move on to our list of “primary candidates” that offer the strongest combination of capabilities, documentation, and ease of use.

Condenders

AndroMDA

If you’re serious about taking the MDA approach to software development, AndroMDA is candidate worthy of consideration. While it does not have UML diagramming tools of it’s own, AndroMDA integrates with others to do the code generation. What we love about it is that it integrates with Maven, which is quickly becoming the standard build tool for Java development.

Dia

Dia is an application for creating technical diagrams. Its interface and features are loosely patterned after the Windows program Visio, so many users will find it easy to get started. Features of Dia include multiple-page printing, export to many formats (including EPS, SVG, CGM, and PNG), and the ability to use custom shapes created by the user as simple XML descriptions. Dia is useful for drawing UML diagrams, network maps, and flowcharts, but it does not support code generation. It runs on Linux, Unix and Windows and is released under the GPL License.

Fujaba

Fujaba is a UML modeling tool that generates code in Java and vice-versa. Most of the documentation is is German, but there is great tutorial in English that demonstrates how to create a networked game using Fujaba exclusively. It is distinguished from other CASE-Tools by the fact that it performs Story Driven Modeling (SDM). Fujaba seems to be popular among German academic institutions and is used as a teaching aid for software development.

Gaphor

Gaphor is a simple UML 2.0 modeling environment, and simplicity seems to be its primary aim — it is easy to install, use and extend. Gaphor is cross-platform, running on multiple flavors of Unix and Windows. No code generation is supported. However the models can be exported to XMI, and SVG, PNG and PDF format exports are supported for the diagrams.

Kivio

Kivio is the KOffice flowchart and diagram creation tool. It allows you to create accurate scale diagrams by arranging pre-drawn shapes and stencils on a page. The stencils might represent stages of a process, office furniture, or components on an electronic circuit. Kivio comes with a large collection of different stencils, which are grouped into collections — known as stencil sets — by subject area. Kivio features script-able stencils using Python, support for Dia stencils, and a plugin framework for adding more functionality. No code generation is supported.

PyUML

PyUML is described as a fully functional UML-Roundtrip-Tool for Python. It is implemented as an Eclipse plugin based on the plugins PyDev and Eclipse Uml2Tools. Unfortunately, the user guide is only available in German, and as such we were not able to thoroughly evaluate its features. It appears to support code generation for Python only, and as of publication of this survey it did not support the latest version of Eclipse (Ganymede).

StarUML

StarUML is a Windows-only code generator and UML editor. The documentation is reasonably good, but it’s obvious that it was directly translated from Korean or written by a non-native English speaker. Documentation is available in Korean, Russian and Japanese, too. The product itself is very powerful; generation is not limited at all, so you can generate Word documents and spreadsheets as well as source code. Although it is touted as open source, several commercial dependencies are required to build from source.

The last release of StarUML was in 2005, so it seems the product is either completely stable or development has stalled. A recent discussion on the forum page indicates that the project may have been abandoned, and some developers have started a fork called SunUML.

Umbrello

Umbrello is a nice KDE-based UML modeler and code generator with a wealth of code generation options. In fact, it supports more languages out of the box than all of the other generators included in this survey. Most new Linux distributions with KDE4 include Umbrello as part of the kdesdk package. Umbrello is not yet available for Windows, but it looks as though this may soon change — there’s a screenshot of Umbrello running on Windows in an experimental capacity on the project website.

UniMod

One approach to software development is to concentrate on defining and implementing application behavior using SWITCH-technology with the help of Structural Finite State Machines (FSM), and UniMod falls within this methodology. However, UniMod is different from other projects using FSMs for describing application logic in that it uses UML and is not focused on embedded systems. UniMod generates Java code exclusively and is another plugin for the Eclipse platform.

Violet

Violet is a simple UML diagram editor and is not intended as an industrial strength modeling tool. No code generation or reverse engineering capabilities are provided, and it does not support XMI export or perform semantic checking of models (in other words, you can draw contradictory diagrams). Violet can be run as an applet, via Java Web Start or as an Eclipse plugin. Violet’s strength lies in its simplicity and easy of use.

Primary Candidates

ArgoUML

ArgoUML is another mature code generating CASE tool, supporting diagram editing for all 9 UML 1.4 diagrams. It boasts a rich set of features including code generation for Java, C++, C#, PHP4 and PHP5, and it’s platform independent and available in ten languages. Diagrams can be exported in as GIF, PNG, PS, EPS, PGML and SVG. Another nice feature is that it supports reverse engineering with Jar/class file importing. Even though we found the user documentation to be lacking in some areas, the documentation seems to be an active work in progress.

ArgoUML is very easy to install, as it has no dependencies other than Java. In most cases it can be installed with a single click using Java Web Start. ArgiUML supports XMI, which is an XML based exchange format between UML tools, so interchange between XMI-compliant tools should be a snap. Other cool features include to-do lists, design critics, OCL support, checklists and multiple overlapping views.

It’s worth mentioning that there is a commercial product called Poseidon, which uses the ArgoUML code base and presents a more complete, rounded product. Having used both, we can live with some of the rough edges in ArgoUML in order to gain some of the other benefits of using an open source solution.

BOUML

BOUML is a very promising project. Running under Linux, Solaris, MacOS X and Windows, it provides UML diagram editing and code generation for C++, Java, Python, PHP and IDL. The generated code is achieved through what the author calls “plug-outs” (named because they execute outside of the BOUML environment), which can be developed in C++ or Java to support other languages. Considering the author is a non-native English speaker, the documentation is excellent. This is a great example of useful open source.

Netbeans

The popular Netbeans IDE has a great UML plugin, which is easily installed via the Plugin Manager. Designers and analysts design applications using the UML modeling language, then developers generate Java code from the UML model. You can also update the model from changes made in the source code. Generated source code can be saved into new source files or merged into existing source code files, thereby providing full round-trip engineering capability. Your collection types are preserved during Forward and Reverse Engineering and may be set and changed. The Netbeans documentation is very good, and there are tutorial trails covering UML based development. However, code generation is currently Java only.

Papyrus / Acceleo

Another tool based on the Eclipse environment, Papyrus models within UML 2.0 and supports multiple code generation possibilities. It supports the DI (Diagram Interchange) standard, an extensible architecture that allows users to add new diagrams and new code generators as well as profile development support facilities for UML2 profiles, nested profiles, and OCL constraints in profile descriptions. Code generation is supported through interfacing with Acceleo.

Acceleo, built as an Eclipse plugin and utilizing the Eclipse EMF (Eclipse Modeling Framework), is a mature MDA environment. With syntax highlighting, real-time error detection, meta-model and scripts-based completion, and real-time preview of generated code, this is certainly an extremely useful product. Acceleo lets you insert custom coding into the generated code by defining coding zones, which are preserved in future iterations of generation. What this means is that you can use Acceleo throughout your development process and seamlessly evolve your project without losing any customization code. It uses custom templates to generate many commonly used programming artifacts, using wizards and a special syntax defined as a result of many years of experience in code generation. In addition, Acceleo uses “services” to extend templates to implement complex operations — basically allowing unlimited extensibility while keeping the templates clean and easy to read. Acceleo can be used to generate C, Fortran, Java, Smalltalk, XML, VB.Net, and virtually any markup language. This is accomplished by the use of Modules, which are basically groups of several templates that describe the information required to generate source code.

A large number of commercial and open source UML Case tools are compatible with Acceleo, and it runs on any Eclipse-compatible operating system. And if this all sounds way too technical, don’t despair — the online documentation and tutorials are superb. The website features a support forum for both English and French language users. Additionally, there is a wiki, an IRC channel, a mailing list and an RSS feed.

Taylor

Implemented as a set of Eclipse plugins and targeted towards JEE development, Taylor aims to make creating JEE applications as easy as Ruby-on-Rails, but with the power of JEE and UML. We were very pleased to see that Taylor can generate JSF and JBoss Seam code, as well as EJB3 Entity and Session Beans. Equally exciting is the fact it can generate Maven pom.xml files and APT documentation from the UML comments. This merely scratches the surface of its feature list — Java Enterprise developers won’t be disappointed with the direction of this project. The documentation is excellent and includes a cool Flash-based demo.

Conclusion

From the perspective of a reviewer with no specific software development project in mind, the most feature-laden option is the Papyrus / Acceleo combination. If your primary IDE is Eclipse, you will benefit from having your modeling software running in the same environment as your active code editor. For Java programmers using Netbeans, the same can said of its modeling tool. BOUML, while superb in its own right, is the vision of a single author and, as such, enterprise development institutions may be hesitant to adopt it. If you don’t mind breaking away from your IDE, give Taylor a test drive.

As we’ve seen, there are many good open source choices for project conception and planning tools, but the best tool for the job is not easily defined. Your unique programming language requirements, environment, operating system, and IDE will guide your decision making process.

Open Source Database Applications Comparison Matrix

Kimberly McClintock — Wed, 07 Jan 2009 16:15:48 +0000

Use this comparison matrix to learn about the differences between – and relative benefits of – the popular open source databases MySQL, PostgreSQL, Derby and H2 Database Engine (H2DB).

Over the years, offerings in the sphere of Databases available from the open source community have become faster and more reliable and, with that, increasingly popular choices for enterprises globally and across a broad swath of industries. As with a number of other categories of project, open source databases now compete on equal footing with established proprietary offerings such as SQL Server and Oracle. In fact, studies and polls executed in the last few years consistently indicate that MySQL and PostgreSQL both rank in the top ten databases used by enterprises; MySQL frequently appears in the top three along with SQL Server and Oracle.

The following tables represent research completed in the fall of 2007 by OpenLogic. We went to the experts — members of the OpenLogic Expert Community who are committers and expert users of the projects — and asked them to answer a set of questions. Experts in MySQL, PostgreSQL, Derby and H2DB responded. Use the resulting information as a tool to plan your projects.

The five questions we asked the experts appear below. To view the detail on the projects* compared across each question, click the question.

What’s the ’sweet spot’ of your project? For what type of projects should users strongly consider it?
What type of scenarios does your project not fit into as well? Would you recommend another project in this scenario? If so, which one?
Of the projects included here, which have you tried? Of those, which ones did you like or dislike, and why?
What is the future of this project? What’s coming that will ease development?
Are there myths about this project that you’d like to challenge?

For comprehensive information on each project, search the OLEX Open Source Library. For a list of the open source developers we interviewed, click here.

*While no version of the projects is specified, you can assume that the information relates to the latest version in our library at the time of the last update.

Summarized Response

What’s your project’s ’sweet spot’? For what type of projects should users strongly consider it?

This is a summary of the responses. For full detail, click here.

Project	Summarized Response
MySQL	It supports replication of primary-secondary out of the box. It provides good handling of national languages (you can set collation and encoding per database, table, column). It executes simple commands (select/insert/update/delete) quickly. It is multiplatform.
PostgreSQL	It’s great for Web based applications doing either ‘daily chores’ or research projects. It’s fast and easy to use. Updating is easy. Update and replication can be automated with tools. Good documentation.
Derby	Operates in both embedded mode and on a network server. Supports Java based stored procedures, and provides a good deal of flexibility in data manipulation. Tight security features distinguish it from other open source offerings. Good for CDC devices.
H2 Database Engine (H2DB)	A fast SQL database. It’s good in Java unit test scenarios requiring a SQL database and accessing any SQL database with the JDBC API (using the H2 Console tool). Great documentation.

Project	Summarized Response
MySQL	Any scenario requiring logic in the database. Not so good for complicated queries. MySQL is not the best choice if the administrator needs to give hints to internal query planner (basically only USE INDEX). Triggers and stored routines have many restrictions (for example one cannot use transactions inside routines or use statements which returns resultsets).
PostgreSQL	One requiring a full journaling system. Use a lighter database system (like dbm) if all you need are very simple key/data pairs.
Derby	High availability and replication are not supported. It’s not suitable for applications with hundreds of transactions per second or databases larger than 10 gigabytes. Not suitable for any kind of warehousing scenario, or a scenario which involves the manipulation of spatial data.
H2 Database Engine (H2DB)	Applications that need a large database. Scenarios in which many (3 or more) connections concurrently access the same database.

Project	Response
MySQL	PostgreSQL: liked In my opinion Postgresql is most the mature open source database engine. It’s powerful, full-featured, efficient and robust. Of particular note are the following features: Procedural languages: postgresql makes it possible to write database functions in many languages like java, perl, python, php. It’s very useful to explain analyze command, and it shows and measures queries via query planner. A query optimizer with a couple of optimization algorithms. A rich SQL dialect: foreign keys, views, procedures, triggers. Contrib package – extensions which are developed outside postgresql.
PostgreSQL	MySQL: didn’t like I found it cumbersome. It lacks concise documentation. It may be faster than PostgreSQL in some circumstances, but if a developer needs to spend twice the time to make it all work, it is not worth it. From the tests I have seen, MySQL and PostgreSQL are pretty much equal in access speed. (Speed issues may arise depending on how you use the database and all systems have advantages and disadvantages in that area.) Especially annoying in MySQL are the documents that indicate functionality that doesn’t exist or doesn’t work as described. It’s possible that the docs referred to a different version, but the appropriate version was not made clear. This made the docs unusable. Outside of that, the SQL commands are in general similar, though PostgreSQL has more functionality. This allows more granularity in your day to day programming of the database.
Derby	PostgreSQL: liked I vote for PostgreSQL when enterprise level features like clustering and high availability are required. Migration from PostgreSQL to ORACLE is very easy and it makes PostgreSQL a good choice for projects that may need to be ported to an ORACLE database.
H2 Database Engine (H2DB)	MySQL: liked Easy to use, very stable, fast. The licensing could be clearer and it’s not Java. PostgreSQL: liked Easy to use, very stable, quite fast, clear license. Not Java. Derby: disliked Wish it were easier to use. Wish documentation were better. It was not as stable as others I have used and as its reputation led me to believe.

Project	Summarized Response
MySQL	Falcon, a new storage engine.
PostgreSQL	Adherence to SQL standards. Faster queries. Simplified upgrades.
Derby	More efficient replication. Higher availability. Greater support for XML.
H2 Database Engine (H2DB)	Performance enhancements. Better documentation.

Project	Summarized Response
MySQL	That it is dual licensed.
PostgreSQL	Because it is free, it must not be any good.
Derby	That it doesn’t perform as well as other open source alternatives.
H2 Database Engine (H2DB)	That Java is slow. That transactions lack durability.

Project	Response
MySQL	MySQL has the following strengths: It supports primary-secondary replication out of the box. It handles national languages well (you can set collation and encoding per database, table, column). It executes simple commands (select/insert/update/delete) quickly. It is multi-platform. Given these strengths, it’s the best platform for use developing Web sites because these kinds of projects demand a database that can respond quickly. In Web environments, more than half of the operations required of the database involve reading data. Given that MySQL supports database replication out of the box, it makes scaling sites and Web services easier. The primary advantage of multi-platform support is scalability. I’ve worked in environments that began by installing MySQL on a single PC, then two, then a SUN SPARC server followed by several Intel IA-64 (Itanium) servers, and eventually two IBM PowerPCs with AIX; with all of them running MySQL as the database server. Additionally, some of the developers had a local copy of MySQL installed on theirs laptops/desktops. Very convenient.
PostgreSQL	Postgresql is also very well documented, with easy to read chapters, many examples that work, and information properly organized by version (7.4, 8.0, 8.2…).
Derby	Apache Derby is a pure Java RDBMS (Relational Database Management System). It can operate both in embedded mode, and as a network server. Derby supports Java based stored procedures, and provides a good deal of flexibility in data manipulation. The tight security features of Derby make it a unique open source database. In addition to regular SQL grant and revoke mechanisms, Derby allows you to configure several options to a determine connection authentication source (LDAP, Built-in, etc.), and also to utilize database encryption using JCE facilities. Derby supports four common isolation levels, and it operates by default in READ_COMMITED mode. In addition, it supports backup/ restore operations and crash recovery for transactions not committed, if for any reason the database crashes. Derby can be used on any J2ME enabled device with support for CDC/Foundation 1.1. Having different versions and modes makes Derby the most suitable database for many projects. For example: those designed for CDC devices, desktop applications which can use embedded mode, and server side applications with multi gigabytes databases that can utilize network server mode. All of these modes and versions have the same functionality, which makes the development cycle less complex.
H2 Database Engine (H2DB)	H2 Database Engine’s sweet spot is Java applications requiring a fast or embedded (or both) SQL database. Another strength is Java unit test scenarios requiring a SQL database and accessing any SQL database with the JDBC API (using the H2 Console tool). Finally, the terrifc documentation makes it a good choice for developers unfamiliar with SQL.

Project	Response
MySQL	One which demands putting logic into a database (complicated stored procedures, triggers). For this kind of projects PostgreSQL or Oracle are a better fit. As mentioned before, MySQL is good for simple queries, but not so good for complicated ones (for example, a project with joins from many tables, sub-queries, grouping etc). This is especially true when the tables contain a large amount of data. In my opinion, it doesn’t fit in environments like Data Warehouses or Data Mart. Some other MySQL drawbacks include: The administrator can’t give hints to internal query planner (basically only USE INDEX). Triggers and stored routines have many restrictions (for example, one cannot use transactions inside routines or use statements which return resultsets). Higher level languages like plpsql or script languages like Perl or Python can not be used to program logic in a database.
PostgreSQL	Even really large projects can use PostgreSQL without much of a problem. The one thing that Postgresql itself does not offer is a full journaling system. Instead, it relies on your file system to ensure data integrity. This means PostgreSQL needs to run with ext3, NTFS or an equivalent file system. I do not know of a database system that replicates a full working journal. Yet if you need to use ext2, FAT or some other non-journaling file system, you would need such a system. On the other hand, these days you should not be using ext2 or FAT or any similar file system anyway. Again, I would recommend a much lighter database system (like dbm) if all you need are very simple key/data pairs. Thus, very small projects should use their own system.
Derby	The current version of Derby does not support high availability and replication, although in the next major version there will be out of the box support for replication and high availability. Derby is not suitable for applications with hundreds of transactions per second, or for databases larger than 10 gigabytes. Additionally, Derby is not suitable for any kind of warehousing scenario, or for any scenario which involves the manipulation of spatial data. That said, there are workarounds for some of these issues. Using Sequoia can resolve high availability and replication issues, for example. For all of the above scenarios, PostgreSQL is the most suitable project because of its stable engine, enterprise level features like clustering and high availability, and supports for spatial data.
H2 Database Engine (H2DB)	Applications that need a large database or scenarios in which many (3 or more) connections concurrently access the same database. Non-Java applications, of course, and instances when the processing of XML documents is required.

Project	Response
MySQL	PostgreSQL: liked In my opinion, Postgresql is the most mature open source database engine. It’s powerful, full-featured, efficient and robust. Of particular note are the following features: Procedural languages: postgresql makes it possible to write database functions in many languages like java, perl, python, or php. It’s very useful for explaining analyze command, shows and measure query via query planner. A query optimizer with couple optimization algorithms. Rich SQL dialect: foreign keys, views, procedures, triggers. Contrib package – extensions which are developed outside postgresql.
PostgreSQL	MySQL: didn’t like I found it cumbersome. It lacks concise documentation. It may be faster than PostgreSQL in some circumstances, but it’s not worth it if a developer needs to spend twice the time to make it all work. From the tests I have seen, MySQL and PostgreSQL are pretty much equal in access speed. (Speed issues may arise depending on how you use the database, and all systems have advantages and disadvantages in that area.) Especially annoying in MySQL are the documents that indicate functionality that doesn’t exist or doesn’t work as described. It’s possible that the documents referred to a different version, but the appropriate version was not made clear, therefore the documents were unusable. Other than that, the SQL commands are similar, though PostgreSQL has more functionality. This allows more granularity in your day-to-day programming of the database.
Derby	PostgreSQL: liked I vote for PostgreSQL when enterprise level features like clustering and high availability are required. Migration from PostgreSQL to ORACLE is very easy and it makes PostgreSQL a good choice for projects that may need to be ported to an ORACLE database.
H2 Database Engine (H2DB)	MySQL: liked Easy to use, very stable, fast. The licensing could be clearer and it’s not Java. PostgreSQL: liked Easy to use, very stable, quite fast, clear license. Not Java. Derby: disliked Wish it were easier to use. Wish documentation were better. It was not as stable as others I have used, and as its reputation led me to believe it would be.

Project	Response
MySQL	The most significant plans for MySQL involve a new storage engine called Falcon. This engine will likely replace innodb/myisqm. It’s in an early stage of development, but it looks promising. If you’re interested in why such a move is necessary, here’s some background. Currently, MySQL version 5.1 supports several storage engines, or methods of storing data on disc drives. But usually only two types are used: MyISAM and InnoDB. MyISAM is the default engine. It’s fast, architecture independent, and has full text search indexes. However, since it’s not transactional, it’s not ACID compliant. This disqualifies MyISAM in scenarios which demand data consistency. Also, it doesn’t allow foreign keys. Every table in MyISAM is stored in separate files. This issue opens the possibility of data corruption. InnoDB is a transaction safe (ACID compliant) engine. It allows locking data on row level, foreign keys, constraints, etc. Tables and indexes are stored in tablespaces which can be partitioned. But InnoDB has drawbacks. It is slower than the MyISAM engine, it doesn’t have full-text-search indexes, and there are some problems with AUTO_INCREMENT indexes. Possibly the biggest issue, however, is that InnoDB was developed by InnoBase, and InnoBase was acquired in 2005 by Oracle. Needless to say, the future of InnoDB in MySQL was uncertain. Hence the development of Falcon, a new storage engine developed by MySQL AB. The Falcon Storage Engine has been designed with modern database requirements in mind, and particularly for use within high volume Web serving, or other environments that require high performance. It’s still in the alpha stage and still taking shape, but plans are in place for features such as: Optimizations for multiple CPU environments (multithreading). True Multi Version Concurrency Control (reading/storing data with efficient locking). Advanced indexes. Data compression stores. Intelligent tablespaces (disk management). Implicit save points (for keeping data integrity). From a legal and business perspective, MySQL is in no way obligated to Oracle if it switches to the Falcon project.
PostgreSQL	Postgresql is already in use by companies with databases of about 32 Tb with tables having million of rows; and it just works. What else do you need?! Seriously, like any complex system, it still has some gray areas. For instance, the project is investing energy into improving adherence to SQL standards. Another area of focus is the continued improvement of compatibility, and the filling in of holes in functionality. Still another is improvement of the search algorithm in order to speed up queries. Finally, we are working to ameliorate some issues with the update process. Right now it is classic, but cumbersome, particularly for large databases. The user must dump the database, stop the old system, start the new system and then restore the database in the new system. We are working on a tool named pg_update that would “simply” update an existing set of tables to a newer version of PostgreSQL.
Derby	There are several plans for further development of Derby. One of the most important features, which will make it easier to use and more efficient, is primary/secondary replication, and improvements to availability. Another area of development involves working on new XML processing features and enhanced support for XPath and XQuery over Derby XML type. Security enhancements are also on the way, as well as the implementation of more features defined in SQL 2003 mandatory and SQL 99 core. The latter will make it easier to write complex SQL statements for Derby.
H2 Database Engine (H2DB)	Project developers are enhancing Derby and adding new features. Some of these are: Optimization for improved performance in larger databases. Improved concurrency. Various ease-of-use features. Documentation improvements. Improvements to extensibility.

Project	Response
MySQL	People tend to believe that MySQL is dual-licensed because it can be used as GPL software or as commercial software. MySQL is not dual licensed. Additionally, people sometimes misunderstand the GPL, and that frightens them off; but that’s a separate topic.
PostgreSQL	Since PostgreSQL is free software, many people believe that it can’t possibly be reliable, fast, fully featured etc. In fact, PostgreSQL has most of the features you can find in other DBMSs like Oracle and Microsoft SQL. Not only that, it also includes many very useful features that are specific to PostgreSQL, such as user defined types (not just a record… a full user defined type! With functions to execute when operators are used against variables of that type, etc.). In terms of security, Postgresql is one of the best databases I have seen. First of all, it runs as postgresql (not root as some others do). Next, by default, the administrator user is not root or admin, but rather a common user of your choice and postgres. Once chosen, that user can do all the things you need a database administrator to do: create other users, databases, and tables; and assign rights, roles, and groups to other users. The database system is reliable because the entire system is thoroughly tested for at least one month before any given release. As a result, we have only rarely encountered issues with reliability.
Derby	Derby’s performance compared to other open source databases is much discussed, and was the subject of a talk at ApacheCON 2005. Viewing that – available on the project wiki – should put any questions to rest.
H2 Database Engine (H2DB)	That it is slow because Java is slow. That transactions in H2 are less durable than other in databases. In my view, this is not true.

Project	Contributer
MySQL	Krzysztof Krzyzaniak
PostgreSQL	Alexis Wilke
Derby	Masoud Kalali
HQ2DB	Thomas Mueller

Project	Contributer
JSF/MyFaces	Gurkan Erdogdu
JBoss SEAM	Gurkan Erdogdu
Spring MVC	Andres March
Stripes	Dmitri Colebatch
Struts 1	Dmitri Colebatch
Struts 2 (Webwork)	James House
Wicket	Jeremy Thompson
Shale	Mathias Wessendorf
Rails	Internal Expertise

Project	Contributer
Glassfish	Masoud Kalalil
JBoss	Felipe Leme
Jetty	Dmitri Colebatch
Tomcat	Filip Hanik

Project	Summarized Response
MyFaces	Separation of MVC layers reduces developer effort. Framework addresses every complex aspect of Web development. Developers can create new components or use existing ones. Many sources for additional components.
JBoss SEAM	Complex Web applications that need to integrate with other open source projects. Applications that have a long running business context. Complex applications Supports RESTful pages Supports AJAX functionality Uses new EJB 3.0 programming artifacts
Spring MVC	Projects that use – or intend to use – Spring Projects that need to expose business logic as HTTP addressable URLs Projects that must provides multiple view rendering techniques
Stripes	Projects in which developers must get productive fast Sensible defaults reduce the need for configuration Contains all basic components necessary for enterprise Web development tasks; avoids feature bloat Stable code base
Struts 1*	Struts 1 has essentially been replaced by Struts 2 and is not recommended for new projects unless the development team already has expertise
Struts 2* (WebWork)	Projects with developers familiar with Struts 1 Projects using Struts 1 who need productivity increase
Wicket	Projects that must create the typical stateful Web application that must track session state and perform services for the user. Ideal for developers who prefer a very clean separation of concerns and object-oriented programming New projects that need to get up and going fast Projects with teams that have UI members and programmers, working independently Single developer projects Projects requiring mailing list support
Shale*	Projects requiring exceptional JUnit /JMock based testing framework Projects requiring an XML-based alternative to JSP
Rails	Web applications depending on REST and/or AJAX Standalone Web sites

Project	Summarized Response
MyFaces	No native AJAX support No support for REStful pages Standard component set too limited for complex enterprise applications
JBoss SEAM	Stiff learning curve makes it a challenge for projects with junior developers Developers will need knowledge of JSF and some EJB 3.0 framework. Simple CRUD applications.
Spring MVC	Projects with a complex business model
Stripes	Projects that need to run in a context where Java5 is not available Established projects
Struts 1*	Struts 1 has essentially been replaced by Struts 2 and is not recommended for new projects. The following is included for purposes of comparison: Projects that will be deployed to a 1.5 JVM A lot of boilerplate code needs to be written for simple tasks A Struts application will always have more classes than an equivalent application written in a different framework
Struts 2* (WebWork)	Not recommended for any but new projects.
Wicket	Nearly completely static or completely stateless sites should avoid Wicket Projects with existing code
Shale*	Shale is “on-top-of-JSF” so can’t be used outside a JSF-app
Rails	Projects that require lots of enterprise integration

Project	Summarized Response
MyFaces	Seam: didn’t like Steep learning curve for the developer, including JSF + EJB 3.0. Its many libraries make it challenging to successfully deploy.
JBoss SEAM	No information available.
Spring MVC	Struts: liked A simple, mature web framework. Struts 1 is a bit heavy and tedious, but the newest version (Struts 2) blends the robustness of Struts with the benefits of WebWork and many lessons learned from the Rails framework. Webwork: liked A simple, mature, and lightweight framework. Configuration can be arduous. Development has merged with Struts and benefits from the experience and community of that project. Rails: liked Rails favors convention over configuration and goes a long way to making web application development simpler. However, it is still immature and lacks the breadth of features of Java web application frameworks.
Stripes	Spring: MVC: didn’t like Overly complex, too much configuration outside the code. Struts 1: didn’t like Hamstrung by the backward compatibility requirements. WebWork / Struts 2: didn’t like WebWork learned a lot from Struts 1, but still suffers from configuration pain.
Struts 1*	Spring MVC: didn’t like Overly complex, too much configuration outside the code. WebWork / Struts 2: didn’t like WebWork learned a lot from Struts 1, but still suffers from configuration pain. Stripes: liked Excellent framework, clean and simple, it simply keeps out of the way.
Struts 2* (WebWork)	Spring MVC: liked Respectable effort that no one should be ashamed of using. Stripes: liked Very compelling. Either would be a good choice for a project getting a fresh start. Wicket: liked Very compelling. Either would be a good choice for a project getting a fresh start. JSF: didn’t like is the EJB of web frameworks. Cool in theory. Hell in practice.
Wicket	Spring: liked I use it to configure my entire middle-tier, and it allows me to operate many similar sites by overriding pieces of configuration that may be different for that particular site. I’ve also used it for configuring custom back-office applications based on many components that I wrote, and wired together via Spring. Tapestry: didn’t like Worked with it for two years on an enterprise project at work. It had absolutely no transparency as to what was going on underneath the covers. It forced you to do things a certain way – the “HLS” way. Everyone involved with the project seemed religiously addicted to it, and only to doing it the “HLS” way, like he was a deity. It forced tons of configuration on you. Every release is a complete rewrite, and backwards-compatibility is constantly thrown out the window to suit the author’s current whims. The learning curve is extremely steep. I hear that version 4 is better, but I gave it up with version 3. Trails: didn’t like Didn’t try very hard. Couldn’t ever really get it to work well, although with more effort, that would’ve likely changed. Did not like Tapestry, so did not pursue further.
Shale*	Spring MVC: liked Cool, nice glue code, but there is a little overlap in Shale’s dialog and Spring Web-Flow (their JSF-version).
Rails	No information available. TODO

Project	Response
MyFaces	Community is writing the new JSR 314 Artifacts from Shale will probably make it into JSF 2.0
JBoss SEAM	Developers are simplifying this project by separating the add-on parts Project is related to the JSR Web Beans
Spring MVC	Easier configuration and better validation
Stripes	No major architectural changes Community has expanded to ensure response to requests
Struts 1*	Bug fixes
Struts 2* (WebWork)	No information available.
Wicket	Improvements to scalability Better support for stateless applications Full-featured Java 1.5 version planned More tightly-integrated support for Spring Role-based authorization
Shale*	Some artifacts from Shale will probably make it into JSF 2.0
Rails	Rails 2.0 is expected to be released by the end of 2007

Project	Response
MyFaces	The JSF/MyFaces Web Framework reduces developer effort by cleanly separating MVC layers. The framework addresses every complex aspect of Web development, including page flows, model validations, model conversions and page actions. Developers have the freedom to create new components from scratch, or launch development from existing components. Because JSF/MyFaces represents the standard implementation, developers have another resource for components: the many open source solutions available. The list include ICEFaces, Ajax4JSF, Apache Trinidad and Sun Sandbox.
JBoss SEAM	JBoss SEAM allows developers to code many types of complex, multi-window, transactional web applications more easily using EJB 3.0 as M(Model) layer and JSF as VC(View-Controller) layer part of the project. It supports RESTful pages, provides AJAX functionality, and eases the development life cycle by using the Java annotations heavily. It provides new EJB 3.0 programming artifacts easily, so while developers need to learn this functionality, they do not have to be experts to begin. This set of tools works well on projects aspiring to integration with other open source projects. Finally, SEAM extends the classical session, request, and application scope with new defined context. This makes it a good choice for applications that have a long running business context containing more than one request.
Spring MVC	Because the Spring MVC Web application framework is tightly integrated with the Spring application framework, it is best suited for projects that use – or intend to use – Spring as the basis. It provides a simple way of exposing business logic as HTTP addressable URLs and provides multiple view rendering techniques.
Stripes	Stripes, a Java servlet presentation framework, is an ideal fit for many Web based applications, large or small. Stripes offers a clean design with simple concepts that allow developers to get productive fast. Annotation based configuration was designed into the tool, and sensible defaults reduce the need for configuration to be explicitly stated. Finally, a carefully controlled code base keeps the tools from the feature-bloat that makes competitors unwieldy while not compromising on the basic components developers will need to do the classic enterprise Web development tasks.
Struts 1*	Although Struts 1 has essentially been replaced by Struts 2 (also in this list), and is not recommended for projects commencing today, it is still in use and extremely popular with enterprises so we’ve included it here. Struts 1 provided an excellent fit for projects that involved form submission. When Struts was first released developers migrated to it from home grown servlet frameworks. Struts gave the industry a defacto standard for developing browser-based applications. Two notable sites using Struts 1 are http://www.virgin-atlantic.com and https://www.21st.com/.
Struts 2 (WebWork)	Struts 2, WebWork renamed, is an excellent web application framework of the “action controller” family. Due to similarity of paradigm, those tens-of-thousands of developers out there that are familiar with Struts 1 can learn Struts 2/WebWork in a matter of a day, realizing huge productivity increases. At the time my team made that transition about 3 years ago, we estimated about a 40% productivity increase in work on the web application. This is due to the (what was at the time WebWork was built) “next generation” features that WebWork introduced upon the “action controller framework” paradigm. Validation, auto-form handling, type conversion, interceptors, etc. all add up to having a real usable tool set, without having to entirely change the way you “think”. If a team is coming from Struts 1 and looking for a quick worth while change, WebWork/Struts 2 is for you. It vastly improves upon Struts 1, and has features that are quite competitive against the newer frameworks.
Wicket	Wicket, out-of-the-box, provides everything teams need to create the typical stateful Web application that must track session state and perform services for the user. This Web framework is ideal for developers who prefer a very clean separation of concerns and object-oriented programming and need to get going fast. Developers can be productive in Wicket quickly. Teams that have UI members and programmers working independently of each other find Wicket exceptionally friendly. Since the HTML is all regular HTML, with no weird additional syntax, the UI designers can write the HTML / CSS and leave the implementation completely to the programmers. Although it sounds like the opposite of the previous point, Wicket is also great for one-man shops where one developer must program and write her own HTML. The developer can focus on object-oriented programming, and then add the basic HTML once she’s figured the implementation out. Projects that need or desire excellent mailing list support will find that the wicket-users mailing list first rate. If you just want to do object oriented programming and not worry about jumping through hoops to work with “the framework”, Wicket is for you. Once you understand a few basic concepts of how Wicket operates, you can start to figure out most of it on your own.
Shale*	The Shale Web framework offers an exceptional JUnit /JMock based testing framework that provides developers the possibility of testing their JSF-application. Other goodies include the view-controller which follows the common JSF-pattern of one ‘backing bean’ behind the page. For teams that need an XML-based alternative to JSP, Shale provides CLAY.
Rails	The sweet spot for Rails is any web application, especially ones that involve REST and/or AJAX. It should be strongly considered for stand-alone web sites.

Project	Response
MyFaces	If developers need to create an application that requires static pages using HTML+ CSS + JavaScript, then JSF/MyFaces is not the best choice. It does not natively support AJAX functionality and developers will have to use one of the AJAX-enabled JSF components available in the community. JSF/MyFaces does not support REStful pages and the standard component set is probably not enough for implementing complex enterprise applications. Users say, JSF “is the EJB of web frameworks. Cool in theory. Hell in practice.”
JBoss SEAM	Although this project tries to address all the challenges of developing dynamic web projects, the stiff learning curve makes it a challenging set of tools for junior teams. Developers will need some knowledge of the JSF (it uses JSF as view) and some familiarity with the EJB 3.0 framework. Its dependence on libraries makes JBoss SEAM challenging to deploy. Suitable for very complex and transactional dynamic web projects, it should not be used in simple CRUD applications.
Spring MVC	A relatively new framework, Spring MVC is missing some of the features of more mature frameworks. If developers are building a project with an established, complex business model, it is somewhat arduous in Spring MVC to bind request parameters to a complex model. WebWork would be a better choice in this scenario because of its OGNL binding framework.
Stripes	Because Stripes requires Java 5, it will not work in any context where Java 5 is not available. Developers think this would be a great choice for brand new projects, not as good for those with existing code.
Struts 1*	Any projects that will be deployed to a 1.5 JVM should use Stripes instead. One of the biggest complaints about Struts 1.x is the amount of boilerplate code that needs to be written for simple tasks. For instance, there is configuration required in struts-config.xml, possibly a form class to be written, and action class, possibly a Tiles configuration, and the a JSP. None of these things can be changed without introducing backward-compatibility problems with earlier Struts releases and so Struts 1.x is not able to overcome these weaknesses. The lack of annotations can be mitigated with the use of tools such as XDoclet, and smart design can reduce the pain involved with adding new classes. However, the separation of form and action that many of the newer frameworks have avoided can only be handled, can’t be fixed. This means a Struts application will always have more classes than an equivalent application written in one of the other newer frameworks. Given all of this, Struts 1.x makes a poor choice for most projects commencing today, with one exception: if the team is already familiar with Struts 1.
Struts 2* (WebWork)	Not recommended for any but new projects.
Wicket	Nearly completely static or completely stateless sites should avoid Wicket. Wicket does perform well even for this sort of site, but it provides a lot of things that developers will not need in this situation. Wicket is a great choice for brand new projects, not as good for those with existing code.
Shale*	Requires JSF/MyFaces as it provides the runtime environment for Shale. Since Shale is “on-top-of-JSF”, the usage of Shale outside a JSF-application is pretty limited.
Rails	Rails does not particularly excel at projects that require lots of enterprise integration, such as performing a transaction across multiple databases or message queues. In these situations, Java-based Web application frameworks are probably the best choice. This may change in the future, however, as JRuby can already run Rails applications and also use Java’s high-end integration facilities.

Project	Response
MyFaces	The JSF 2.0 community is writing the new JSR 314. Interested parties can find it here: http://jcp.org/en/jsr/detail?id=314. This effort solves a number of the problems addressed in other questions. Some artifacts from Shale will probably make it into JSF 2.0. For instance, there are the Shale-Tiger extensions that allow the usage of annotations to register a managed bean.
JBoss SEAM	Developers are simplifying this project by separating the add-on parts. It is also related to the new JSR Web Beans. For more information, see http://jcp.org/en/jsr/detail?id=299.
Spring MVC	Spring MVC continues to benefit from the improvements made to the core Spring framework. Future improvements include easier configuration and better validation.
Stripes	There has been an expansion of the developer base recently to ensure that Stripes continues to be in a position to respond to the community’s requests. However, the community plans no major architectural changes. Users can adopt Stripes confident in the knowledge that the codebase has stabilized.
Struts 1*	Struts 1.x has a very limited future. Whilst officially new functionality is being added to the 1.x releases if backward compatibility can be maintained, in reality only very minor functionality improvements are being added. Having said this, bugfixes are still released. Thirdparty tools (eg XDoclet, IDE support) are mature and unlikely to offer any significant changes from the functionality offered today.
Struts 2* (WebWork)	No information available.
Wicket	The community plans to improve scalability, and provide better support for stateless applications. A full Java 1.5 version of Wicket is planned (current version works on 1.5, of course, but does not take advantage of 1.5 features so that 1.4 projects can still use it). Additionally, more tightly-integrated support for Spring and role-based authorization is in the works. Manning Early Access Program publishers released a Wicket-in-Action in July 2007.
Shale*	Some artifacts from Shale will probably make it into JSF 2.0. For instance, there are the Shale-Tiger extensions that allow the usage of annotations to register a managed bean.
Rails	Rails 2.0 is expected to be released by the end of 2007. It will make REST-based web application development even easier. It will also provide improvements in these areas: performance, security, formatting content for multiple clients (e.g., iPhone and Atom readers), testing, database schema migrations, XML handling, debugging, plug-in processing, and much more.

Project	Summarized Response
GlassFish	Web services Enterprise level support for clustering Enterprise level administration console (CLI, Web based GUI and JMX) Installation profiles Tight integration with a wide variety of software packages
Tomcat	Extremely configurable and pluggable design Popularity results in large user base
JBoss	Ease of use Development environments
Jetty	Small size

Project	Summarized Response
GlassFish	Any scenario requiring a full Java EE application server or Servlet container is good for GlassFish GlassFish does not fit in a scenario requiring a container embedded
Tomcat	Tomcat does not fit well into fullblown J2EE applications
JBoss	Will fit in any scenario
Jetty	Scenarios requiring J2EE support beyond servlets should be avoided Scenarios requiring business logic to housed in a separate EJB tier

Project	Summarized Response
GlassFish	Tomcat: liked Tomcat is an optimized Servlet container with clustering capability and a very good http/https module implemented using non blocking NIO package. Tomcat is suitable if project is not going to host EJBs. Geronimo:liked Geronimo has all features that GlassFish has except that it does not provide any of those five features mentioned in question one. Although Geronimo has an administration interface, Web service support and very small level of clustering support (using Terracotta), it is far behind what GlassFish provides out of the box. Geronimo fits best in scenarios where there is no need for clustering and cluster management.
Tomcat	CauchoResin: didn’t like Commercial. Poor documentation. Jetty: liked Small and efficient, but has a smaller user base than some of the alternatives. GlassFish: disliked Worst configuration files ever Hard to work with. Geronimo: liked Wraps Tomcat inside a J2EE server. JBoss: liked Same as Geronimo Though I dislike the tyrant community of JBoss.
JBoss	Tomcat: liked Easy to install, although can be tricky to configure in some aspects. Jetty: liked A great option if what you need is a simple web container. It can be embedded (which makes deployment of the project as a whole easier). Very fast startup (useful during development). GlassFish: didn’t like Hard to use, and very slow to start (especially when integrated with NetBeans).
Jetty	Tomcat: liked Excellent community support. Solid Web server In my experience, the development community can be somewhat unhelpful and unfriendly. However, I have seen many many excellent examples of community support in Tomcat, both from users and developers. In particular, I have always found people such as Filip Hanik to be extremely helpful. JBoss: liked Strong community.

Wazi » Comparisons

Comparing Open Source Agile Project Management Tools

Background

Contenders

Comparison Summary

Agilefant

Concepts

Viability, Support & Documentation

Usability

Strengths

Weaknesses

Overall Rating

Screenshots

IceScrum

Concepts

Viability, Support & Documentation

Usability

Strengths

Weaknesses

Overall Rating

Screenshots

Agilo

Concepts

Viability, Support & Documentation

Usability

Strengths

Weaknesses

Overall Rating

Screenshots

eXplainPMT

Concepts

Viability, Support & Documentation

Usability

Strengths

Weaknesses

Overall Rating

Screenshots

XPlanner

Concepts

Viability, Support & Documentation

Usability

Strengths

Weaknesses

Overall Rating

Screenshots

Conclusion

Survey of Open Source Modeling Tools for Software Development

Background

Condenders

AndroMDA

Dia

Fujaba

Gaphor

Kivio

PyUML

StarUML

Umbrello

UniMod

Violet

Primary Candidates

ArgoUML

BOUML

Netbeans

Papyrus / Acceleo

Taylor

Conclusion

Open Source Database Applications Comparison Matrix

Summarized Response

What’s your project’s ’sweet spot’? For what type of projects should users strongly consider it?

What type of scenarios does your project not fit into as well? Would you recommend another project in this scenario? If so, which one?

Of the projects included here, which have you tried? Of those, which ones did you like or dislike, and why?

What is the future of this project? What’s coming that will ease development?

Are there myths about this project that you’d like to challenge?

Complete Responses

What’s your project’s ’sweet spot’?

What scenarios does this project not work as well in?

Of the projects included here, which have you tried? Of those, which ones did you like or dislike, and why?

What is the future of this project? What’s coming that will ease development?

Are there myths about this project that you’d like to challenge?

Acknowledgments

Project	Summarized Response
GlassFish	Support for AIX Faster startup High availability (JMS high availability, in particular) using HADB Enhancements to auto update feature
Tomcat	Faster and more stable
JBoss	No information available.
Jetty	Continuations and Async SSL

Project	Summarized Response
GlassFish	Poor performance.
Tomcat	Tomcat is great for development, but should not be used from production.
JBoss	Lack of support, and an inability to handle mission-critical projects. Neither of these are true.
Jetty	Jetty can only be run as part of JBoss or Geronimo.

Project	Full Response
GlassFish	Web services: It has a well designed and implemented Web service stack which supports the latest WS-* standards like Reliable Messaging, Secure Conversation, Trust, Security, SecurityPolicy, MetadataExchange, Atomic Transaction, Coordination, etc. The GlassFish Web services stack is fully Interoperable with the .Net framework, and has been adopted by some other big players like IBM for its JDK version 6, BEA as Web service stack for BEA application server 10, JBoss WS 2.1.0, etc. Enterprise level support for clustering: GlassFish has a very well designed and implemented clustering and high availability mechanism which distinguishes it as an open source application server. GlassFish supports in-memory replication for http sessions, stateful EJB session states, single sign on states, and container states (Timer…). Although the default replication mechanism between instances is based on JXTA (in-memory replication), it is possible to use HADB (a high performance database optimized for high availability use cases)to achieve 99.99% uptime. Enterprise level administration console (CLI, Web based GUI and JMX): The GlassFish administration console allows full control over application server configuration and behavior from detailed configuration of an ORB listener to monitoring and diagnosis. Web based console can be used to manage and configure a cluster and deploy application or resource to entire cluster. Per-Web service, JDBC resource, web resource, etc monitoring provide detailed statistics about that resource usage. Installation profiles: GlassFish can be installed using one of several profiles: Developer, Cluster or Enterprise. Each profile has special features that make it suitable for a specific purpose.For example, the Developer profile will not carry modules that are required for clustered environments and this allows for faster database stops and starts. The Developer profile also uses an embedded broker to serve JMS requirements. It uses the JKS format rather than the CertDB used by the Enterprise profile. These and other differences between the profiles let each role in an enterprise to have an installation suited for its purpose. GlassFish is tightly integrated with a wide range of software, including: OpenESB – a first class JBI implementation with tens of binding components and service engines. OpenSSO – an open source version of Sun Java Access Manager. OpenDS – an open source version of the Sun Directory Server.
Tomcat	Tomcat’s sweet spot is it’s extremely configurable and pluggable design. This means that every component inside of Tomcat can be exchanged with one you or someone else has developed without changing Tomcat code. This is all managed via the configuration file. This ease of use has contributed to making Tomcat the most popular servlet engine today. This popularity results in a very large user base and access to lots of expertise. Additionally, and it’s easy to find developers with the Tomcat skill set.
JBoss	The biggest advantage of JBoss is ease of use. Installation is as simple as unzipping a file; deploying the application is as simple as copying a WAR/EAR. Support for expanded deployments makes development more productive. JBoss should be considered for any Java EE project. Even if the project officially uses another application server, developers could use JBoss during development to increase productivity.
Jetty	Whilst Jetty is an excellent servlet engine on any measure, it is extremely lightweight and so easy to embed into another application. We have a number of applications that require embedded HTTP servers in which we have used Jetty very successfully. The entire Jetty codebase is only a few hundred KB, and as such it is ideal for environments where memory is a premium. For example, many devices such as routers and modems have Web interfaces for managing the device. Jetty would be an ideal fit for this sort of deployment due to its compact footprint.

Project	Full Response
GlassFish	Generally speaking, GlassFish fits any type of scenario requiring a full Java EE application server or Servlet container. In older versions of GlassFish (Sun Java application servers), it was not suitable to replace a Servlet container like Tomcat or Jetty but the new Grizzly engine used in GlassFish allows it to operate as well as Tomcat and Jetty in place of a Servlet container. In addition, it has a very easy and reliable cluster management and failover recovery which make it a wise choice. The one scenario that current versions of GlassFish does not fit is any embedded use case where a container should be embedding in-process. For this scenario Tomcat fits well.
Tomcat	Any that is no java, of course. And, fullblown J2EE applications, for this you can use JBoss, Geronimo or Glassfish, all of which run a version of Tomcat inside.
JBoss	Technically speaking, I don’t know any scenario into which JBoss would not fit (that doesn’t mean such a scenario doesn’t exist, I’m just not familiar with any).
Jetty	If J2EE support beyond servlets is required, something like JBoss or Geronimo would be a better choice. It should be noted that technically speaking, neither of those are Servlet containers but instead include a Servlet container (typically Tomcat or Jetty) that is used to handle HTTP requests. Given that Jetty is only a servlet container, it does not support EJBs and other J2EE components except servlets. Some applications may require that business logic be housed in a separate EJB tier which Jetty does not support. In these cases something like JBoss or Geronimo would be a better choice. Note that even in this case Jetty would still be an excellent choice for the HTTP/Servlet component of the application. I do not believe there are any projects where Jetty would not be an excellent fit for the HTTP/Servlet layer if Java is a requirement.

Project	Full Response
GlassFish	The GlassFish kernel is slated for redesign in version 3. The new kernel is based on an HK2 module sub-system which makes it possible to start GlassFish in a cell phone or embed it in-process. Other enhancements include some to performance: GlassFish will start within few seconds (less than 5) using a lazy loading mechanism for its module and sub systems. There will be an upgrade for GlassFish in early 2008 which make it possible to use GlassFish on AIX operating system. GlassFish version 3 will support Java EE 6 profiles in addition to support for scripting languages like JRuby, PHP, JavaScript (server side). Support for these languages will be available through containers which are already implemented to some degree. The next version will include improvements for high availability (JMS high availability, in particular) using HADB. GlassFish has an auto update mechanism that allows administrators to create an update center with new or updated application server artifacts and update all server instance from that update center. This feature allows the update of application servers or install of new modules on the server. In next version of GlassFish, it will be possible to update deployed applications using this update center.
Tomcat	Continue along the same path, it is now a commodity software, no revolutions inline but to make it better, more stable and faster. JSR-315 is next on the list, which is servlet 3.0.
JBoss	No information available.
Jetty	Jetty is still under active development and a number of new features are being added to fulfill today’s requirements of a servlet container, including Continuations and Async SSL.

Project	Full Response
GlassFish	The most insidious myths about GlassFish were allayed by SUN’s release of the SpecJ benchmark reports. SpecJ reports debunking myths about GlassFish performance are worth looking at – here and here.
Tomcat	There is one myth, and it was around for a long time: Tomcat is great for development, but should not be used from production. While this may persist in some companies, many have realized the cost benefit of Tomcat, and its maturity.
JBoss	Lack of support, and an inability to handle mission-critical projects. Neither of these are true.
Jetty	One is that Jetty can only be run as part of JBoss or Geronimo. This is not true, the only reason Jetty would need to run as part of JBoss or Geronimo is if EJB support is required. Jetty doesn’t have support for JNDI or LDAP integration. This is not true, JettyPlus (http://jetty.mortbay.org/jetty5/plus/index.html) has support for JTA, JNDI, JAAS and Javamail.