Reverse Engineered Java Class Diagrams

AgileJ StructureViews is dedicated to supporting agile software development through reverse engineered UML class diagrams with extensive content filtering.

Supporting Agile Methods

We understand and practice agile methods and have built AgileJ StructureViews around the needs of the agile development community and working in harmony with the principles of the agile manifesto. This is why you find no forwards engineering functions and we guarantee to make no alterations to your source code nor demand any changes to your development practices to fit around use of this tool. In short, we simply offer an additional view of the object oriented structure of your code in its current state, honoring your source code as the master copy and keeping additional presentation information to a bare minimum.

Dedicated to Java Reverse Engineered Class Diagrams in Eclipse

In order to provide uncompromising object oriented structure visualization for Java developers most of the typical UML tool functions are excluded. For example, the UML diagram types which serve documentation-only purposes are excluded since customer requirements capture may be an ongoing task with the requirements manifesting as runnable code. Furthermore, forwards engineering is excluded; the complexities of round-trip engineering where source code is manually edited can easily cost more time than it saves as the model and the source code battle for control.

Support for multiple programming languages is also omitted. While there are shared constructs between the most common object oriented programming languages there are also subtle language-specific constructs which warrant pictorial representation too. Since Eclipse does represent Java's synchronized modifier with a clock symbol then we too include the clock symbol on our class diagrams.

Automated Class Diagram Generation

Working code is your and our top priority. Time spent preening UML diagrams has earned tools of this ilk a bad name due to the distraction which creating and maintaining documentation can become. However, class diagrams remain a valuable resource for gaining a high level understanding of the design underlying a Java codebase. AgileJ StructureViews generates the most insightful class diagrams all from one wizard which takes about two minutes to complete. From there on our batch processing engine discovers and assesses candidate class diagrams through package, dependency and inheritance relationships, followed by our custom auto layout which performs an optimizing layout on each diagram.

Highly Scalable

The barriers to scalability of class diagram production we have found are the size of the Java codebase, the available physical memory and the efficiency of the algorithms performing diagram discovery and diagram layout. AgileJ StructureViews has been stress tested against exceptionally large codebases such as JBoss. Please click here for output.

The Industry Leader in Class Diagram Content Filtering

Text book examples of UML class diagrams depict small groups of classes with a few members each. Real-world examples of reverse engineered class diagrams can contain classes with tens of members, and be populated with trees of tens of such classes. The problem in nearly every instance is that the resulting diagram is overwhelmingly complex. Since we hold to keeping down the manual effort in diagram production, our solution is to make AgileJ StructureViews highly configurable, shipping with a large collection of read-to-use filters, but with the option to add your own project specific filtering rules.

Tightly Integrated into Eclipse

The Eclipse Integrated Development Environment is the hub within which Java development happens and it makes sense for a code visualizer to blend in as seamlessly as possible. We integrate not only by following Eclipse's nomenclature, but by deriving all of our diagram information from the same source which drives all other views of the code so that its up-to-dateness can be relied upon. There is no separate project concept in AgileJ StructureViews; each class diagram is a simple stand alone file which can be held under version control along with the other project artifacts and shared within the team.

A Visual Guide to Design Quality

All Java projects have a design regardless whether tools were used to create the design or the programmers wrote their code to directly to reflect a design held in their heads. While agile methods have encouraged the expression of design directly through the production of working code there remains value in reverse engineered diagrams as a means of visually reflecting the merits of sound object oriented design which in turn lead to more maintainable code, more effective testing and improved flexibility to changes in requirements.

Help Getting up to Speed with an Existing Codebase

In an ideal software development world Java programmers would instantly find their way around the existing code as they join a new project or take on maintenance of a legacy project. The reality is that nearly all existing codebases were developed by programmers of mixed abilities with conflicting ideas of good design, left little or no documentation explaining the design, are unavailable for further consultation. Therefore, depending on inherent complexity and the experience of the software developer it can take days or weeks of effort reading source code to gain enough familiarity to start meaningfully contributing to the project. The problem is the effort picking through a monolithic codebase to separate out the concerns. AgileJ StructureViews assists with this task by revealing a high vantage point view showing the relationships vital for making sense of a large codebase.

Clearer Communication of APIs

APIs are the boundaries partitioning software into coarse grained components allowing separations of concerns and are a hallmark of strong design. Without clear APIs every developer needs to understand every software component from the inside. Configuring class diagrams to show API elements allows firstly, the team developing the component to more clearly judge the quality of the API they expose and secondly, other teams (possibly their customers) to gain a more rapid understanding of the API.

A Different Approach to UML Tooling

UML tools have fallen out of favor due to their focus on supporting up-front design and consequently inhibiting adaptive and iterative approaches. However, the need remains to visualize the design underlying the code in its current state. Therefore AgileJ StructureViews class diagrams, while conforming to UML as much as possible for the sake of common understanding, place a higher priority on:

Speed of production of class diagrams with a minimum of manual effort

Expression of all relevant Java constructs found in class member signatures

Conformance to the Eclipse nomenclature

Presenting only a meaningful subset of all the Java information at any one time

In short, AgileJ StructureViews seeks to reflect rather than dictate the design.

A Visual Guide to Project Progress

Monitoring the progress of a Java project can be challenging for the project technical lead; it is difficult to review every commit of new source code to check for conformance to programming standards. AgileJ StructureViews can help by allowing the lead developer to quickly monitor the design through the visual overview of filtered class diagrams which reveal missed opportunities for reuse, the introduction of new dependencies which may go on to hamper re-use, areas which are getting too complex and may benefit from the allocation of time for refactoring and sub-optimal uses of inheritance.

Building Understanding through Growing Diagrams

Exploring the existing codebase is time consuming but necessary for each new team member. AgileJ StructureViews supports what we term 'growing diagrams'. This is where a Java class of interest is added to a new class diagram and its relatives are added, where the relatives may be referents, dependents or inheritance relatives. Class diagrams built this way, like any other, may be stored for future reference but it is often the process of growing these diagrams which builds the greatest insight.

Compositional Design Patterns

Design patterns allow names to be given to commonly occurring design construct for ease of communication. Not all categories of design pattern can be reflected in class diagrams but some can, in particular compositional design patterns. AgileJ StructureViews is configured to highlight the presence of compositional design patterns where they occur.

Legacy Java Projects

Where active development of a Java project was scaled down several years ago due to it having satisfied the needs of the customer and naturally entered its phase of live running, enhancements and modifications may materialize mandating further development. In this scenario where the Java source code is the only reliable artifact then browsing auto-generated class diagrams is the most effective means of judging the effort which will be required to implement the required enhancements and modifications. Without class diagrams to help build an assessment of the complexity of the legacy code the developer can easily be trapped trying to work on an unmaintainable system, or may choose to scrap a large, undocumented project which is otherwise workable when viewed through appropriately filtered class diagrams.