This Article 
   
 Share 
   
 Bibliographic References 
   
 Add to: 
 
Digg
Furl
Spurl
Blink
Simpy
Google
Del.icio.us
Y!MyWeb
 
 Search 
   
An Automatic Class Generation Mechanism by Using Method Integration
May 2000 (vol. 26 no. 5)
pp. 425-440

Abstract—This 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 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] A.V. Aho, R. Sethi, and J.D. Ullman, Compilers, Principles, Techniques and Tools.New York: Addison-Wesley, 1985.
[2] T. Ball, S. Horwitz, and T. Reps, ”Correctness of an Algorithm for Reconstituting a Program from a Dependence Graph,” Technical Report TR-947, Univ. of Wisconsin, Madison, July 1990.
[3] D. Batory and B.J. Geraci, ”Composition Validation and Subjectivity in (GenVoca) Generators,” IEEE Trans. Software Eng., vol. 23, no. 2, pp. 67–82, Feb. 1997.
[4] I.D. Baxter, ”Design Maintenance Systems,” Comm. ACM, vol. 35, no. 4, pp. 73–89, Apr. 1992.
[5] D. Binkley, S. Horwitz, and T. Reps, ”Program Integration for Language with Procedure Calls,” ACM Trans. Software Eng. and Methodology, vol. 4, no. 1, pp. 3–35, Jan. 1995
[6] G. Bracha and W. Cook, ”Mixin-Based Inheritance,” Proc. European Conf. Object-Oriented Programming Conf./Object-Oriented Programming Systems, Languages, and Applications, pp. 303–311, Oct. 1990.
[7] J. Ferrante,K.J. Ottenstein,, and J.D. Warren,“The program dependence graph and its use in optimization,” ACM Trans. Programming Languages and Systems, vol. 9, no. 3, pp. 319-349, June 1987.
[8] E. Gamma et al., Design Patterns: Elements of Object-Oriented Software, Addison-Wesley, Reading, Mass., 1994.
[9] J. Gosling, B. Joy, and G. Steele, The Java Language Specification, Addison-Wesley, Reading, Mass., 1996.
[10] S. Horwitz, T. Reps, and D. Binkley, “Interprocedural Slicing Using Dependence Graphs,” ACM Trans. Programming Languages and Systems. vol. 12, no. 1, pp. 26-60, Jan. 1990.
[11] S. Horwitz, J. Prins, and T. Reps, ”Integrating Noninterfering Versions of Programs,” ACM Trans. Programming Languages and Systems, vol. 11, no. 3, pp. 345–387, July 1989.
[12] S. Horwitz and T. Reps, ”Efficient Comparison of Program Slices,” Acta Informatica, vol. 28, pp. 713–732, June 1991.
[13] R.E. Jonson and B. Foote, ”Designing Reusable Classes,” J. Object-Oriented Programming, vol. 1, no. 2, pp. 22–35, June/July 1988.
[14] J. Lamping, ”Typing the Specialization Interface,” Proc. Conf. Object-Oriented Programming Systems, Languages, and Applications, pp. 201–214, Sept. 1993.
[15] L. Larsen and M.J. Harrold, ”Slicing Object-Oriented Software,” Proc. Int'l Conf. Software Eng., pp. 495–505, Mar. 1996.
[16] K.J. Lieberherr and C. Xiao, ”Object-Oriented Software Evolution,” IEEE Trans. Software Eng., vol. 19, no. 4, pp. 313–343, Apr. 1993.
[17] M. Lorenz and J. Kidd, Object-Oriented Software Metrics. Prentice Hall, 1994.
[18] K. Maruyama and K. Shima, ”A Mechanism for Automatically and Dynamically Changing Software Components,” Proc. Symp. Software Reusability, ACM SIGSOFT Software Eng. Notes, vol. 22, no. 3, pp. 169–180, May 1997.
[19] K. Maruyama and N. Takahashi, ”Extracting Reusable Software Components by Using Bounded Program Slicing,” Trans. IPS Japan, vol. 37, no. 4, pp. 520–535, Apr. 1996.
[20] S. Matsuura, H. Kuruma, and S. Honiden, ”EVA: A Flexible Programming Method for Evolving Systems,” IEEE Trans. Software Eng., vol. 23, no. 5, pp. 296–313, May 1997.
[21] B. Meyer,Object-Oriented Software Construction. Englewood Cliffs, NJ: Prentice-Hall, 1988.
[22] W.F. Opdyke, ”Refactoring Object-Oriented Frameworks,” technical report, PhD thesis, Univ. of Illinois at Urbana-Champaign, 1992.
[23] H. Ossher and W. Harrison, ”Combination of Inheritance Hierarchies,” Proc. Conf. Object-Oriented Programming Systems, Languages, and Applications, pp. 25–40, Oct. 1992.
[24] K.J. Ottenstein and L.M. Ottenstein, ”The Program Dependence Graph in a Software Development Environment,” ACM SIGPLAN Notices, vol. 19, no. 5, pp. 177–184, May 1984.
[25] D.L. Parnas, ”On the Design and Development of Program Families,” IEEE Trans. Software Eng., vol. 2, no. 1, pp. 1–9, Mar. 1976.
[26] W. Pree, Design Patterns for Object-Oriented Software Development, Addison-Wesley, Reading, Mass., 1994.
[27] G. Rothermel and M.J. Harrold, ”Selecting Regression Tests for Object-Oriented Software,” Proc. Int'l Conf. Software Maintenance, pp. 14–25, Aug. 1994.
[28] C.L. Chang, R.A. Stachowitz, and J.B. Combs, “Validation of Nonmonotonic Knowledge-Based Systems,” Proc. IEEE Int'l Conf. Tools for Artificial Intelligence, Nov. 1990.
[29] R. Stata and J.V. Guttag, ”Modular Reasoning in the Presence of Subclassing,” Proc. Conf. Object-Oriented Programming Systems, Languages, and Applications, pp. 200–214, Oct. 1995.
[30] P. Steyaert, C. Lucas, K. Mens, and T. D'Hondt, ”Reuse Contracts: Managing the Evolution of Reusable Assets,” Proc. Conf. Object-Oriented Programming Systems, Languages, and Applications, pp. 268–285, Oct. 1996.
[31] C. Szyperski, Component Software: Beyond Object-Oriented Programming. Addison-Wesley, 1997.
[32] F. Tip, J.-D. Chio, J. Field, and G. Ramalingam, ”Slicing Class Hierarchies in C++,” Proc. Conf. Object-Oriented Programming Systems, Languages, and Applications, pp. 179–197, Oct. 1996.
[33] M. VanHilst and D. Notkin, ”Using C++ Templates to Implement Role-Based Designs,” Proc. Int'l. Symp. Object Technologies for Advanced Software, pp. 22–37, Mar. 1996.
[34] M. Weiser, ”Program Slicing,” IEEE Trans. Software Eng., vol. 10, no. 4, pp. 352–357, July 1984.
[35] W. Yang, ”A New Algorithm for Semantics-Based Program Integration,” Technical Report TR-962, PhD thesis, Univ. of Wisconsin, Madison, Aug. 1990.
[36] A.M. Zaremski and J.M. Wing, ”Signature Matching: A Tool for Using Software Libraries,” ACM Trans. Software Eng. and Methodology, vol. 4, no. 2, pp. 146–170, Apr. 1995.
[37] A.M. Zaremski and J.M. Wing, ”Specification Matching of Software Components,” ACM Trans. Software Eng. and Methodology, vol. 6, no. 4, pp. 333–369, Oct. 1997

Index Terms:
Object-oriented programming, inheritance, program integration, program slicing, program transformation, dependency analysis.
Citation:
Katsuhisa Maruyama, Ken-ichi Shima, "An Automatic Class Generation Mechanism by Using Method Integration," IEEE Transactions on Software Engineering, vol. 26, no. 5, pp. 425-440, May 2000, doi:10.1109/32.846300
Usage of this product signifies your acceptance of the Terms of Use.