An Automatic Class Generation Mechanism by Using Method Integration

The paper presents a mechanism for automatically generating new classes from classes existing in a library by using their modification histories. To generate classes that are likely to meet a programmer's requirements and that are consistent with the existing classes, we propose three actors: a Specifier, a Finder, and an integrator. The Specifier records the history of modifications between methods with the same interface of a parent class and its heir. If the required method is not defined in the existing class which a programmer is referring to, the Finder retrieves classes similar to the referenced class and the Integrator applies the past modifications of similar classes to the referenced class. Classes are determined to be similar, based on their positions in a class hierarchy tree. Both the Specifier and Integrator are achieved by using a method integration algorithm based on object oriented bounded program slicing and class dependence graph matching. This mechanism enables programmers to reuse classes with little or no modification, and thus, easily create object oriented programs.

[1]  Joe D. Warren,et al.  The program dependence graph and its use in optimization , 1984, TOPL.

[2]  Gregg Rothermel,et al.  Selecting regression tests for object-oriented software , 1994, Proceedings 1994 International Conference on Software Maintenance.

[3]  Thomas W. Reps,et al.  Integrating noninterfering versions of programs , 1989, TOPL.

[4]  簡聰富,et al.  物件導向軟體之架構(Object-Oriented Software Construction)探討 , 1989 .

[5]  Kim Mens,et al.  Vrije Universiteit Brussel Faculteit Wetenschappen Reuse Contracts: Managing the Evolution of Reusable Assets Reuse Contracts: Managing the Evolution of Reusable Assets , 2022 .

[6]  Wolfgang Pree,et al.  Design Patterns for Object-Oriented Software Development , 1994, Proceedings of the (19th) International Conference on Software Engineering.

[7]  Brian Foote,et al.  Designing Reusable Classes , 2001 .

[8]  David W. Binkley,et al.  Interprocedural slicing using dependence graphs , 1990, TOPL.

[9]  Joe D. Warren,et al.  The program dependence graph and its use in optimization , 1987, TOPL.

[10]  William R. Cook,et al.  Mixin-based inheritance , 1990, OOPSLA/ECOOP '90.

[11]  David W. Binkley,et al.  Program integration for languages with procedure calls , 1995, TSEM.

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

[13]  Ira D. Baxter,et al.  Design maintenance systems , 1991, CACM.

[14]  Jeannette M. Wing,et al.  Signature matching: a tool for using software libraries , 1995, TSEM.

[15]  William E. Lorensen,et al.  Object-Oriented Modeling and Design , 1991, TOOLS.

[16]  David Notkin,et al.  Using C++ Templates to Implement Role-Based Designs , 1996, ISOTAS.

[17]  Karl J. Lieberherr,et al.  Object-Oriented Software Evolution , 1993, IEEE Trans. Software Eng..

[18]  Katsuhisa Maruyama,et al.  A mechanism for automatically and dynamically changing software components , 1997, SSR '97.

[19]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[20]  Karl J. Ottenstein,et al.  The program dependence graph in a software development environment , 1984 .

[21]  Mary Jean Harrold,et al.  Slicing object-oriented software , 1996, Proceedings of IEEE 18th International Conference on Software Engineering.

[22]  Harold Ossher,et al.  Combination of Inheritance Hierarchies , 1992, OOPSLA.

[23]  Thomas Reps,et al.  Correctness of an Algorithm for Reconstituting a Program From a Dependence Graph , 1990 .

[24]  Jeannette M. Wing,et al.  Specification matching of software components , 1997 .

[25]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools , 1986, Addison-Wesley series in computer science / World student series edition.

[26]  Guy L. Steele,et al.  The Java Language Specification , 1996 .

[27]  Raymie Stata,et al.  Modular reasoning in the presence of subclassing , 1995, OOPSLA.

[28]  Shinichi Honiden,et al.  EVA: a flexible programming method for evolving systems , 1997, IEEE Transactions on Software Engineering.

[29]  Mark Lorenz Object-Oriented Software Metrics , 1994 .

[30]  하수철,et al.  [서평]「Component Software」 - Beyond Object-Oriented Programming - , 2000 .

[31]  Harold Ossher,et al.  Combination of inheritance hierarchies , 1992, OOPSLA '92.

[32]  Don S. Batory,et al.  Composition Validation and Subjectivity in GenVoca Generators , 1997, IEEE Trans. Software Eng..

[33]  Wuu Yang,et al.  A new algorithm for semantics-based program integration , 1990 .

[34]  David Lorge Parnas,et al.  On the Design and Development of Program Families , 2001, IEEE Transactions on Software Engineering.

[35]  John Lamping,et al.  Typing the specialization interface , 1993, OOPSLA '93.

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

[37]  Mark Weiser,et al.  Program Slicing , 1981, IEEE Transactions on Software Engineering.