Composing subsystem structures using (k,2)-partite graphs

@article{Mller1990ComposingSS,
  title={Composing subsystem structures using (k,2)-partite graphs},
  author={Hausi A. M{\"u}ller and James S. Uhl},
  journal={Proceedings. Conference on Software Maintenance 1990},
  year={1990},
  pages={12-19}
}
  • H. Müller, James S. Uhl
  • Published 26 November 1990
  • Computer Science
  • Proceedings. Conference on Software Maintenance 1990
The authors describe a clustering method that uses equivalence relations for identifying subsystem structures. The relations are intended to embody the software engineering principles that concern module interactions, such as low coupling, high strength, small interfaces, and few interfaces. The resulting compositions are (k,2)-partite graphs (a class of layered graphs) rather than strict tree hierarchies. The method is supported by an interactive graph editor.<<ETX>> 

Figures from this paper

Clustering algorithms in PBS
TLDR
This paper constructs an abstract model for this problem and presents some algorithms for the above problem from the literature and the algorithm which I have chosen for my project is the combination of two algorithms from the Literature.
A framework for the comparison of nested software decompositions
TLDR
A framework called END is introduced that reuses comparison methods for flat decomposition in order to compare nested decompositions without loss of information and is presented using several existing methods as plugins that demonstrate its usefulness.
Mining Co-Change Clusters from Version Repositories
TLDR
This paper defines the co-change graph as a simple but powerful model of common changes of software artifacts, and describes how to extract the graph from version control repositories, and introduces an energy model for computing force-directed layouts of co- change graphs.
Clustering software artifacts based on frequent common changes
  • Dirk Beyer, A. Noack
  • Computer Science
    13th International Workshop on Program Comprehension (IWPC'05)
  • 2005
TLDR
This work introduces a two-step method for identifying clusters of artifacts that are frequently changed together, and derives requirements for such layouts, and introduces an energy model for producing layouts that fulfill these requirements.
ACCD: an algorithm for comprehension-driven clustering
TLDR
This work presents an algorithm that subscribes to a philosophy targeted towards program comprehension and based on subsystem patterns and discusses the algorithm's implementation and describes experiments that demonstrate its usefulness.
Clustering Using Dynamic Analysis and Static Dependencies
TLDR
This paper presents a novel software clustering approach that combines dynamic and static analysis to identify component clusters and introduces a two-phase clustering technique that combines software features to build a core skeleton decomposition with structural information to further refine these clusters.
Lossless Comparison of Nested Software Decompositions
TLDR
This paper introduces UpMoJo, a novel comparison method for software decompositions that can be applied to both nested and flat decomposition, and compares it to the END framework, the only other existing method for nested decomposition comparison.
Software Clustering Using Dynamic Analysis and Static Dependencies
TLDR
This paper presents a novel software clustering approach that combines dynamic and static analysis to identify component clusters and introduces a two-phase clustering technique that combines software features to build a core skeleton decomposition with structural information to further refine these clusters.
A visual representation model for software subsystem decomposition
  • C. M. D. Oca, D. Carver
  • Computer Science
    Proceedings Fifth Working Conference on Reverse Engineering (Cat. No.98TB100261)
  • 1998
TLDR
A visual representation model (RM) is defined to graphically present the information produced by ISA to provide a graphical view of the recovered subsystem decomposition, the subsystems components, and the relationships among the subsystemS.
Using version information in architectural clustering - a case study
TLDR
A case study that uses clustering to group classes of an existing object-oriented system of significant size into subsystems and shows that dependency relations are vital to achieve good clusterings.
...
...

References

SHOWING 1-10 OF 22 REFERENCES
Rigi: a system for programming-in-the-large
  • H. Müller, K. Klashinsky
  • Computer Science
    Proceedings. [1989] 11th International Conference on Software Engineering
  • 1988
TLDR
Randi was designed to address three of the most difficult problems in the area of programming-in-the-large: the mastery of the structural complexity of large software systems, the effective presentation of development information, and the definition of procedures for checking and maintaining the completeness, consistency, and traceability of system descriptions.
Edge concentration: a method for clustering directed graphs
TLDR
This paper proposes the elimination of some edges by replacing sets of edges that have the same set of source and target nodes by a special node called an edge concentration node.
Extracting and restructuring the design of large systems
TLDR
The approach used is to map the resource exchange among modules and then derive a hierarchical design description using a system-restructuring algorithm, using a module interconnection language, NuMIL.
System Structure Analysis: Clustering with Data Bindings
TLDR
It appears that the clustering of data bindings provides a meaningful view of system modularization.
System partitioning and its measure
Software interconnection models
TLDR
The semantic interconnection model is introduced, which incorporates the advantages of the unit and syntactic interconnection models and provides extremely useful extensions to them and provides tools that are knowledgeable about the process of system construction and evolution and that work in symbiosis with the system builders to construct and evolve large software systems.
Cross references are features
When a software system is developed by a large team of programmers, and has matured’ for several years, changes to the code may introduce unexpected interactions between diverse parts of the system.
Presentation Of Software Development Information In K2
TLDR
The K2 environment is an integrated collection of tools that allows the members of a complex software project to organize development information by manipulating system description documents of various types and by establishing links between those documents.
Error localization during software maintenance: generating hierarchical system descriptions from the source code alone
  • R. Selby, V. Basili
  • Computer Science
    Proceedings. Conference on Software Maintenance, 1988.
  • 1988
An empirical study is presented that investigates hierarchical software system descriptions that are based on measures of cohesion and coupling. The study evaluates the effectiveness of the
Change management for very large software systems
  • Y.S. Maarek, G. Kaiser
  • Computer Science
    Seventh Annual International Phoenix Conference on Computers an Communications. 1988 Conference Proceedings
  • 1988
TLDR
The authors present the algorithm which INFUSE uses to automatically build and maintain a hierarchy of experimental databases and some results of the application of INFUSE are given.
...
...