Reengineering class hierarchies using concept analysis

The design of a class hierarchy may be imperfect. For example, a class C may contain a member m not accessed in any C-instance, an indication that m could be eliminated, or moved into a derived class. Furthermore, different subsets of C's members may be accessed from different C-instances, indicating that it might be appropriate to split C into multiple classes. We present a framework for detecting and remediating such design problems, which is based on concept analysis. Our method analyzes a class hierarchy along with a set of applications that use it, and constructs a lattice that provides valuable insights into the usage of the class hierarchy in a specific context. We show how a restructured class hierarchy can be generated from the lattice, and how the lattice can serve as a formal basis for interactive tools for redesigning and restructuring class hierarchies.

[1]  Gregor Snelting,et al.  Reengineering of configurations based on mathematical concept analysis , 1996, TSEM.

[2]  Gregor Snelting,et al.  On the inference of configuration structures from source code , 1994, Proceedings of 16th International Conference on Software Engineering.

[3]  Jong-Deok Choi,et al.  Slicing class hierarchies in C++ , 1996, OOPSLA '96.

[4]  Gregor Snelting,et al.  Assessing Modular Structure of Legacy Code Based on Mathematical Concept Analysis , 1997, Proceedings of the (19th) International Conference on Software Engineering.

[5]  David Ungar,et al.  Sifting out the gold: delivering compact applications from an exploratory object-oriented programming environment , 1994, OOPSLA 1994.

[6]  Bjarne Steensgaard,et al.  Points-to analysis in almost linear time , 1996, POPL '96.

[7]  Frank Tip,et al.  Class hierarchy specialization , 2000, Acta Informatica.

[8]  Brian A. Davey,et al.  An Introduction to Lattices and Order , 1989 .

[9]  Jong-Deok Choi,et al.  Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects , 1993, POPL '93.

[10]  Hafedh Mili,et al.  Building and maintaining analysis-level class hierarchies using Galois Lattices , 1993, OOPSLA '93.

[11]  Ralph E. Johnson,et al.  Creating abstract superclasses by refactoring , 1993, CSC '93.

[12]  Ivan Moore,et al.  Automatic inheritance hierarchy restructuring and method refactoring , 1996, OOPSLA '96.

[13]  Frank Tip,et al.  A study of dead data members in C++ applications , 1998, PLDI.

[14]  Bernhard Ganter,et al.  Formale Begriffsanalyse - mathematische Grundlagen , 1996 .

[15]  Thomas W. Reps,et al.  Identifying Modules via Concept Analysis , 1999, IEEE Trans. Software Eng..

[16]  Gregor Snelting,et al.  Concept analysis—a new framework for program understanding , 1998, PASTE '98.

[17]  Susan Horwitz,et al.  Fast and accurate flow-insensitive points-to analysis , 1997, POPL '97.

[18]  Linda M. Ott,et al.  The Relationship Between Slices And Module Cohesion , 1989, 11th International Conference on Software Engineering.

[19]  Jonathan G. Rossie,et al.  An algebraic semantics of subobjects , 1995, OOPSLA.

[20]  G. Ramalingam,et al.  A member lookup algorithm for C++ , 1997, PLDI '97.

[21]  Barbara G. Ryder,et al.  Data-Flow-Based Virtual Function Resolution , 1996, SAS.

[22]  William F. Opdyke,et al.  Refactoring object-oriented frameworks , 1992 .

[23]  Rokia Missaoui,et al.  Design of Class Hierarchies Based on Concept (Galois) Lattices , 1998, Theory Pract. Object Syst..