Abstract
Refactorings are behavior-preserving program transformations that automate design evolution in object-oriented applications. Three kinds of design evolution are: schema transformations, design pattern microarchitectures, and the hot-spot-driven-approach. This research shows that all three are automatable with refactorings. A comprehensive list of refactorings for design evolution is provided and an analysis of supported schema transformations, design patterns, and hot-spot meta patterns is presented. Further, we evaluate whether refactoring technology can be transferred to the mainstream by restructuring non-trivial C++ applications. The applications that we examine were evolved manually by software engineers. We show that an equivalent evolution could be reproduced significantly faster and cheaper by applying a handful of general-purpose refactorings. In one application, over 14K lines of code were transformed automatically that otherwise would have been coded by hand. Our experiments identify benefits, limitations, and topics of further research related to the transfer of refactoring technology to a production environment.
This is a preview of subscription content, log in via an institution to check access.
Similar content being viewed by others
References
Banerjee, J. and Kim, W. 1987. Semantics and implementation of schema evolution in object-oriented databases. In Proceedings of the ACM SIGMOD Conference.
Batory, D. et al. 1998. JTS: Tools for implementing domainspecific languages. In 5th International Conference on Software Reuse, Victoria, Canada. June 1998.
Baxter, I. and Pidgeon, C. 1997. Software change through design maintenance. In Proceedings of the International Conference on Software Maintenance '97, IEEE Press.
Bergstein, P. 1991. Object-Preserving class transformations. In Proceedings of OOPSLA '91.
Berstein, P. 1991. Object-preserving class transformations. In Proceedings of OOPSLA '91.
Budinsky, F.J. et al. 1996. Automatic code generation from design patterns. IBM Systems Journal, 35(2).
Ellis, M. and Stroustrup, B. 1990. The Annotated C++ Reference Manual. Reading, Massachusetts: Addison-Wesley.
Florijn, G., Meijers, M., and van Winsen, P. 1997. Tool support for object-oriented patterns. In Proceedings, ECOOP '97, Sprinter-Verlag, Berlin, pp. 472-495.
Gamma, E. et al. 1993. Design patterns: Abstraction and reuse of object-oriented design. In Proceedings, ECOOP '93, Springer-Verlag, Berlin, pp. 406-421.
Gamma, E. et al. 1995. Design Patterns Elements of Reusable Object-Oriented Software. Reading, Massachusetts, Addison-Wesley.
Gamma, E. et al. 1996. TUTORIAL 29: Design patterns applied. In OOPSLA '96 Tutorial.
Goldberg, A. 1984. Smalltalk-80: The Interactive Programming Environment. Reading, Massachusetts, Addison-Wesley.
Griswold, W. 1991. Program Restructuring as an Aid to Software Maintenance. Ph.D. thesis, University of Washington.
Johnson, R. and Foote, B. 1988. Designing reusable classes, Journal of Object-Oriented Programming, pp. 22-35.
Krasner, G.E. and Pope, S.T. 1988. A cookbook for using the model-view-controller user interface paradigm in Smalltalk-80. Journal of Object-Oriented Programming, pp. 26-49, August 1988.
Kim, J. and Benner, K. 1996. An experience using design patterns: lessons learned and tool support. Theory and Practice of Object System, 2(1):61-74.
Lieberherr, K., Hursch, W., and Xiao, C. 1991. Object-extending class transformations. Technical report, College of Computer Science, Northeastern University, 360 Huntington Ave., Boston, Massachusetts.
Lieberherr, K., Hursch, W., and Xiao, C. 1991. Object-extending class transformations. Technical report, College of Computer Science, Northeastern University, 360 Huntington Ave., Boston, Massachusetts.
Linton, M. 1992. Encapsulating a C++ library. In Proceedings of the 1992 USENIX C++ Conference, Portland, Oregon, pp. 57-66.
Maydany, P. et al. 1989. A class hierarchy for building stream-oriented file systems. In Proceedings of ECOOP '89, Nottingham, UK.
McGuire, P. 1997. Lessons learned in the C++ reference development of the SEMATECH computer-integrated manufacturing (CIM) applications framework. In SPIE Proceedings, 2913: pp. 326-344.
Morris, J.H. et al. 1986. Andrew: A distributed personal computing environment. Communications of the ACM.
Opdyke, W.F. 1992. Refactoring object-oriented-frameworks. Ph.D. thesis, University of Illinois.
Opdyke, W.F. and Johnson, R.E. 1993. Creating abstract susperclasses by refactoring. In ACM 1993 Computer Science Conference, Feb. 1993.
Parnas, D.L. 1979. Designing software for ease of extension and contraction. IEEE Transactions on Software Engineering, 5(2):128-138.
Pree, W. 1994. Meta Patterns—A Means for capturing the essentials of reusable object-oriented design. In Proceedings, ECOOP '94, Springer-Verlag, Berlin.
Pree, W. and Sikora, H. 1995. Application of Design Patterns in Commercial Domains. OOPSLA '95 Tutorial 11, Austin, Texas.
Pressman, R. 1992. Software Engineering A Practitioner's Approach. New York: McGraw Hill.
Roberts, D., Brant, J., Johnson, R. 1997. A refactoring tool for smalltalk. In Theory and Practice of Object Systems, 3(4).
Scherlis, W. 1998. Systematic change of data representation: program manipulations and case study. In Proceedings of ESOP, '98.
Schulz, B. et al. 1998. On the computer aided introduction of design patterns into object-oriented systems. In Proceedings of the 27th TOOLS Conference, IEEE CS Press.
Simonyi, C. 1995. The death of computer languages, the birth of intentional programming. NATO Science Commitee Conference.
Stewart, S. 1995. Roadmap for the Computer-Integrated Manufacturing Application Framework. NISTIR 5697.
Tokuda, L. and Batory, D. 1995. Automated software evolution via design pattern transformations. In Proceedings of the 3rd International Symposium on Applied Corporate Computing, Monterrey, Mexico, Oct. 1995.
Tokuda, L. and Batory, D. 1999. Automating three modes of object-oriented software evolution. In Proceedings, COOTS '99.
Tokuda, L. and Batory, D. 1999. Evolving object-oriented designs with refactorings. Technical Report TR99-09, Department of Computer Science, University of Texas.
Tokuda, L. 1999. Design evolution with refactorings. Ph.D. thesis, University of Texas.
Weinand A., Gamma E., and Marty R. 1988. ET++—An Object-Oriented application framework in C++. In Object-Oriented Programming Systems, Languages, and Applications Conference, San Diego, California, pp. 46-57, Sept. 1988.
Winsen, P.V. 1996. (Re)engineering with object-oriented design patterns. Master's Thesis, Utrecht University, INF-SCR-96-43.
Yourdon, E. and Constantine, L. 1979. Structured Design. Englewood cliffs, New Jersey: Prentice Hall.
Author information
Authors and Affiliations
Rights and permissions
About this article
Cite this article
Tokuda, L., Batory, D. Evolving Object-Oriented Designs with Refactorings. Automated Software Engineering 8, 89–120 (2001). https://doi.org/10.1023/A:1008715808855
Issue Date:
DOI: https://doi.org/10.1023/A:1008715808855