Review

[HA93] A Reverse Engineering Approach to Subsystem Structure Identification

• Motivation
  For long-term maintenance of software projects, the source code is often the only reliable means for software engineer to determine how the system should be changed. However, source text is often huge in size and its exhausting and error prone for engineers to figure out the parts to be modified just by looking at the code. Guidelines on reverse engineering methodology and tools are needed for this maintenance process.
   
• Proposed Solution
  The author introduces the concept of Reverse Engineering, which consists of two phases: the extraction of system abstractions and design information; and the identification of the system's components and their interrelationships.
  Extracting the system abstractions reveals the overall structure of the system, which involves the identification of subsystems, the construction of hierarchies and the computation of interfaces among subsystem. Once the role and the interrelationships of these subsystems are identified, the effect of local code modification can be traced. Moreover, identifying subsystems is useful for tasks management as well as system test and integration plan. In order to assist software engineers in such a task, the author introduces a semi-automatic developing environment "Rigi" dedicated to reverse engineering.
   
• Evaluation of the Proposed Solution
  The authors introduce their methodology in subsystem composition, follow by on how "Rigi" support the different stages of composition.
  The stages of subsystem composition are as follows:
  • extraction of relevant system components and dependencies out of system's source code to form resource-flow graphs.
  • composition of subsystem hierarchies using the resource-flow graphs.
  • finding exact interfaces among the constructed subsystem
  • evaluation of the constructed subsystem based on software engineering principle: i. high strength within a component and low coupling among components; and ii. few interfaces
  • visual presentation.
  
  To support the above stages, "Rigi" represents resource-relations (i.e. component node v supplies objects to component node w) and composition-relations (i.e. nodes denote classes, data-type, modules) by (k,2)-partite graphs. The exact interfaces can then be determined by these two types of graphs.
  "Rigi" determines the coupling between two nodes by calculating the intersection of the exact interfaces from v to w and from w to v. By doing so, the degree of coupling between components can be obtained.
  It also finds loosely-coupled but similar components by identifying those that have common clients/suppliers. Combining similar components reduces the number of interfaces, which satisfy the s/w engineering principle of few interfaces among components.
  "Rigi" supports subsystem compositions by the following operations:
  • remove omnipresent nodes (e.g. debugging modules)
  • compose by interconnection strength (i.e. if strongly coupled, put them in same subsystem; else if loosely coupled, separate them into two subsystems)
  • compose by common clients/suppliers
  • compose by centricity (find key components and fringe components and separate them into different subsystem; key/fringe components are determined by sum of weights from all incoming edges)
  • compose by name
  
  The above actions by "Rigi" are illustrated by a case study: a reverse-engineering process of a ray-tracing rendering system written in C.
   
• Comment on the Above Evaluation
  I agree with the author's methodologies on the process of reverse-engineering, given the situation that both domain-experts and accurate documentation are not present. However, there are more than one solution to the final composition of the target system, and the authors had not mentioned the criteria to achieve the "best" solution. to be continued...
   
• Contributions
  "Rigi" certainly provides a fast and relatively reliable reverse-engineering tools that enhance the process of software maintenance.
   
• Future Directions
  under construction
   
• Other Comments/Questions
  I wonder, though, if "Rigi" is applicable to all kinds of s/w patterns. Also, I wonder if the strategies of extracting components that are highly coupled/similar/key/fringe are sufficient enough.
   
• Irrelevant Babbles
  Easy reading; even the formula are intuitive and easy to understand.
  Wish all papers are like that.