Vanward beefs up Java project tracking

Convergence adds source-metric, test-tracking muscle to Maven-based projects

Vanward’s Convergence adds yet another layer of capability to Maven, the already capable and powerful project-management system. Java developers are attracted to Maven because it enforces a structure on a development project’s directory organization -- making a large project easier to comprehend and maintain -- without forcing them to reinvent the wheel every time they begin a project.

Convergence hooks into your project’s Maven build and testing scripts, gathers data from the activity of those scripts, and feeds that data into a monitoring system that allows you to track the progress of not only the project code but also the associated unit-testing code. Convergence’s real power is its organization of project source-code metrics and test results in a fashion that allows you to dig into that data to locate meaningful trends.

Are you working on a large Java project and wanting to track the source code’s growth and testing progress from build to build? Pay attention to Convergence.

Structure and form

Convergence is a clever mixture of software know-how and open-source technologies. Its pillars are Java, MySQL, and various Apache technologies; therefore it works on Linux, Solaris, Unix, and Windows.

A triad of components make up Convergence, two of which operate in the background. The first component is a set of Ant and Jelly scripts that gather data from the build process, shepherd the unit testing after each build, and gather the test results.

These scripts then organize the build and testing data and feed it into the second component, a MySQL-hosted database. That database becomes the repository of all the information Convergence gathers from each build and from the subsequent battery of unit tests during the project’s lifetime.

The third component is a “dashboard” application that dips into the database and displays a hierarchical and navigable view of the sea of data Convergence pours into its repository from build to build. This dashboard is actually a Java-based Web app delivered by Apache Tomcat. It is also where Convergence users will spend the most time exploring, analyzing, and stepping backward in time to gauge progress.

When you log in to the dashboard, you enter Convergence at the topmost level. From this vantage point, you can see high-level information for the most recent builds of each project.

Beneath each project’s name are links that take you to either a table of the packages in the application source, or packages within the unit-testing source. Select the “packages within application” link and you’re taken to a page that not only shows all the packages but also lists for each package the percentage of coverage achieved by the most recent unit tests, the number of classes, and the number of lines of Java code.

More links are available from this page, too. For example, a click on a package’s dependency link opens a page of various code metrics and package-dependency metrics. The latter includes afferent coupling (a rating of the number of packages that depend on this package) and efferent coupling (a rating of the number of other packages this package depends on). You can click on them and explore the dependencies.

This information would be of mere academic interest if it weren’t for the fact that Convergence shows the data’s history from build to build. Thus, you can observe the change in afferent coupling as builds progress and analyze the changing importance of a given package’s role within the application.

You may also view profiles of individual classes. The profile screen includes a link to graphical information that plots class size (source code lines) against build number, revealing how the class has grown across time. It also shows coverage percentages achieved by tests associated with the class, showing how well the unit tests’ coverage has kept up with the growth of the class’ source.

If you descend into data related to the associated unit-testing code by clicking the “test packages” link beneath a project name, Convergence brings you to a page that lists all the application’s test packages.

Here, Convergence presents a summary of test successes and failures for each package from the most recent build. You can drill down along two branches. Click the test package name to view a list of classes within the package and see each class’s test successes and failures. Click the historical-information icon to view the package’s successes and failures for all past builds.

Initially complex

Because Convergence relies on several technologies, its installation is actually a combination of installations. I doubt, however, that anyone who has used Maven will have any difficulty setting up MySQL, Tomcat, or Convergence. Installing Convergence’s dashboard requires no more effort than moving a WAR file into Tomcat’s application-deployment directory.

Although the version I tested was for Java only, Convergence also supports C# and C++ .Net, although the feature set is not as robust as it is with Java. However, Convergence engineers say the .Net capabilities should be on par with Java by mid-to-late 2005.

Initially, Convergence can be a bit daunting. There are so many ways to explore the captured data that new users will likely find themselves groping. The documentation could use some work, too; its scattered organization left me wondering if the document writers weren’t groping as well.

However, Convergence organizes enough data in enough ways so that almost any Java developer will find it a worthwhile project-tracking adjunct to Maven. You just need to spend some time getting familiar with the lay of the land -- it will be worth it.

InfoWorld Scorecard
Interoperability (15.0%)
Value (10.0%)
Setup (15.0%)
Scalability (20.0%)
Documentation (20.0%)
Ease of use (20.0%)
Overall Score (100%)
Vanward Convergence 9.0 8.0 8.0 9.0 6.0 9.0 8.2