The advent of the World Wide Web (WWW) has provided researchers with a wealth of new techniques for sharing, displaying, navigating and indexing information. Portable and highly intuitive user interfaces can be easily built using HTML and the Java language.
The field of Software Engineering has much to gain from the the WWW. Many of the goals of the field can be achieved in a better way by utilizing the facilities provided by the web. Providing access by the developers, for example, is greatly facilitated by the familiar user interface of well-known web browsers. Architectural diagrams of software systems can "come alive" with the use of clickable maps.
In this paper, we present a web-based approach to visualizing and navigating the architecture of software systems, using a large legacy system as an example. The structure of the rest of the paper is as follows. Section 2 provides a brief background on Software Architecture and explains the views in which we are interested. Section 3 presents an example system and its architecture as shown through our approach. Section 4 describes the web technology used in our approach and explains its advantages. Section 5 shows how our approach, combined with the web facilities, can provide up-to-date information on a software system. Finally, section 6 concludes the paper.
In their "Introduction to Software Architecture", Garlan and Shaw [G&S] have considered a number of common architectural styles in an effort to create a taxonomy of architectural paradigms. Since then, the field of Software Architecture has evolved significantly through research conducted with the goal of devising theories that model the architectures of software systems.
One of the most common ways to think of the architecture of software systems is to hierarchically decompose them into subsystems. These subsystems, in turn, can be decomposed again. This process iterates for successively smaller components of the software system, possibly ending when the file, module, or even the procedure level has been reached. The decomposition is usually represented by a tree structure, called the containment tree, where dependencies between the various entities of the system (such as procedure calls or data references) are represented as relations between the nodes of the tree. A lot of research has been conducted on imposing constraints on the way entities can interact with each other, in order to enforce a certain architectural style [Mancoridis1].
Many tools have been developed to aid software architects with the task of manipulating large amounts of data [Muller, Ramamoorthy]. One approach is the metaphor provided by the Landscape tool [Mancoridis2].
The Landscape tool provides facilities to help perform the software decomposition in order to create the containment hierarchy. The user navigates through this hierarchic structure by "diving" into subsystems in order to examine their structure in detail.
The CSER project has developed the Software Bookshelf, a web-based approach for reengineering the architecture of legacy systems. The Software Bookshelf enhances the concepts introduced by Landscape by associating nodes of the containment tree with HTML documents and providing other links to other associated material, such as software metrics. The next section presents an example system and its architecture as presented by the Software Bookshelf.
Recovering and visualizing the structure of existing software systems is a typical reengineering task that has been performed in the past; see for example, [Carmichael,Holt]. The use of the WWW will greatly facilitate these efforts in the future.
The example system we will use to illustrate our web-based approach to this task is a large, mission critical, legacy system written in a proprietary programming language. The system is more than 10 years old and consists of about 250,000 lines of code. Development is still going on for it, with 12 developers currently employed on the project.
As can be seen on figure 1, the system is composed of four major subsystems, that contain 70 basic subsystems, that in turn contain the files of the system, numbering more than a thousand.
The user of the Software Bookshelf can then "dive" into any of the 70 basic subsystems by clicking on the subsystem's box or on the subsystem's link on the left. This clicking brings up a view of the selected subsystem, as in figure 2.
As shown in figure 2, the user sees a visualization of the structure of the subsystem, which in this case is called "DS", along with a description for the subsystem and each of its components. In this figure, each innermost box represents a source code file, and clicking it brings up a window containing the source code. Red arrows indicate procedure calls and green ones data references. Also, the links on the left provide access to useful information on such subjects such as algorithms and data structures used by the subsystem.
There are a lot of reasons why web technology has undergone such an impressive growth in the past few years.
One of the main reasons is the fact that developing software for the web is a standardized procedure, in that it uses common notations and tools, such as HTML, Java and CGI scripts. This in turn makes the software easier to develop and more portable. Also, the standardized user interface makes web software easier to access. Other reasons include the fact that no installation is required (other than a standard web browser), as well as the hot links between documents that make it easier to acquire a better overview of the subject of interest. (Our earlier Landscape tools were based on X-Windows libraries, and we were happy to abandon that approach in favour of a web-based approach.)
Our project benefitted from all these factors, which helped in approaching the developers and getting feedback on how to improve our display of architectural information.
We utilized web technology in three key ways in our approach:
In order for a tool that describes the structure of a software system to be useful, the description has to be up-to-date. This implies that a system that is continuously under development poses an additional problem, that of capturing the evolution of the system's structure. The Software Bookshelf deals with this problem by always providing the most up-to-date snapshot of the system's structure and by incorporating visualizations of the evolving process.
This facility is achieved through an updating process that is described in figure 3. Every time the software system is "built", relevant facts (such as procedure calls and data references) are extracted from it. By comparing the previous facts to the new ones, newly introduced files, called "orphans", are detected. An algorithm that automatically assigns them to a subsystem is then run, as well as a layout adjuster that provides layout information for the orphans, and also updates the layout of the architectural diagrams in order to accommodate changes such as introduction of new edges.
This visualization of the evolution of software is of critical importance for the developers.
We presented a web-based approach to visualizing and navigating the architecture of software systems. We have taken advantage of a number of factors inherent in web-based software development, including standardized tools, notations and interfaces, with their implied portability and accessibility. The result is that we have been able to produce, install and make accessable a set of bettter tools in less time than was possible with previous technology.
[Carmichael] "Design Maintenance : Unexpected Architectural Interactions", by Carmichael I., Tzerpos V. and Holt R.C., IEEE Proceedings of the International Conference on Software Maintenance, Nice, France, October 1995, pp. 134-137.
[G&S] "An Introduction to Software Architecture", by D. Garlan and M.
Shaw, Advances in Software Engineering and Knowledge Engineering, Volume
I, World Scientific Publishing Company, 1993.
[Holt] "GASE: Visualizing Software Evolution-in-the-Large",
by R. C. Holt and J. Pak. WCRE 96: Working Conference
on Reverse Engineering, Monterey, Nov 96.
[Mancoridis1] "Recovering the Structure of Software Systems Using Tube
Graph Interconnection Clustering", by S. Mancoridis and R. C.
Holt, IEEE Proceedings of the 1996 International Conference
on Software Maintenance, Monterey, California, USA, November 1996.
[Mancoridis2] "Tool Support for Software Engineering Education",
by S. Mancoridis, R. C. Holt, and M. W. Godfrey. In
Proceedings of the ICSE-16 Workshop on Software
Engineering
Engineering Education , Sorrento, Italy, May 1994.
Also published as Imperial College Technical Report,
Number TR 94/6, June, 1994.
[Muller] ``Rigi: A System for Programming- in-the-Large'', by Muller,
Hausi A. and Klashinsky, Karl, Proceedings of the 10th International
Conference on Software Engineering, Singapore, April 11-15, 1988. Rigi
home page :
http://tara.uvic.ca