home | agility | comics | kids' books | about

Concept: Continuous Software Construction Snapshot

In my opinion, the Unified Modeling Language (UML) is best suited for physical/detailed modeling of a system (i.e. blueprint style; for conceptual modeling, I prefer something along the lines of Agile Draw). I believe UML particuarly shines for reverse engineering diagrams for an existing system, such as the UML package and class diagrams. Recently, I have been thinking of a concept I call Continuous Software Construction Snapshot. This concept is closely tied (and highly complementary) to the Continuous Integration concept described by Martin Fowler and Matthew Foemmel at http://www.martinfowler.com/articles/continuousIntegration.html. This new concept is described next.

UML diagrams can be reverse engineered typically using a UML diagramming tool such as Rational Rose, Borland Together, Poseidon, OmniGraffle, or a variety of other tools -- this is done manually by a person. However, in the past I have used a tool that generated UML diagrams automatically (e.g. on the server side). In the late 90s, I had launched a site called isavix.net (now developerhub.com), which grew to over 100,000 registered Java developers and won several awards. This site focused on providing free and unique tools versus content. Among other things, we provided a tool called "My UML Diagrams". This tool enabled users to upload .java and/or .jar files and automatically generated a class diagram on the server side using these file(s) as input.

Given the manual and automatic server-side UML diagram generation I just described, leads us to the notion of Continuous Software Construction Snapshot. The idea behind this is to show people (e.g. project leads, developers) continuous progress of a software being constructed (developed); it also allows developers to see where their piece fits into the big picture. Similar to how one can see a building or home being constructed, we should be able to get a view of the software under construction. This can be done as follows.

Each time a build (continuous integration) happens, a package diagram and class diagrams are also generated.
Alternatively, these diagrams can be generated at the time they are needed (e.g. when goes to a web site to see the state of a software application).

For example, these generated diagrams could be viewed via a web browser. The first view (presumably after some sort of a welcome screen) a person would see is a package diagram, as shown next.

From the package diagram, the user could drill down into a specific package (e.g. web in above diagram) to see a class diagram (shown next) for the classes within that package.

Note: It is important to keep the level of detail in the generated diagrams to a minimum, in order to make this concept useful.

The next level of detail could be the source code (e.g. actual code, revisions, unit test coverage), perhaps using web-based view of a CVS repository, as shown next.

Some benefits of this continuous snapshot approach could include:

Ability for developers to get a "big picture" view of the entire application being coded by multiple developers.
Getting a birds eye view of how much of the coding (construction) has been completed.
Determining average lines of code produced per developer (e.g. to determine Mythical Man-Month type stuff).
Measuring percentage of unit test coverage by comparing unit test code to actual code.
Comparing project velocity to lines of code coded for each iteration.

In summary, Continuous Software Construction Snapshot can give a project lead, developer or other, a high level view of the application, while enabling them to drill down to details - using this combination of a big picture and low-level details can provide an in-depth understanding of the status and overview of a software application... as it is being built.