Advertisement

Automated Software Engineering

, Volume 8, Issue 1, pp 89–120 | Cite as

Evolving Object-Oriented Designs with Refactorings

  • Lance Tokuda
  • Don Batory
Article

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.

refactorings oo design patterns program transformations refactoring tools 

Preview

Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.

References

  1. Banerjee, J. and Kim, W. 1987. Semantics and implementation of schema evolution in object-oriented databases. In Proceedings of the ACM SIGMOD Conference.Google Scholar
  2. Batory, D. et al. 1998. JTS: Tools for implementing domainspecific languages. In 5th International Conference on Software Reuse, Victoria, Canada. June 1998.Google Scholar
  3. Baxter, I. and Pidgeon, C. 1997. Software change through design maintenance. In Proceedings of the International Conference on Software Maintenance '97, IEEE Press.Google Scholar
  4. Bergstein, P. 1991. Object-Preserving class transformations. In Proceedings of OOPSLA '91.Google Scholar
  5. Berstein, P. 1991. Object-preserving class transformations. In Proceedings of OOPSLA '91.Google Scholar
  6. Budinsky, F.J. et al. 1996. Automatic code generation from design patterns. IBM Systems Journal, 35(2).Google Scholar
  7. Ellis, M. and Stroustrup, B. 1990. The Annotated C++ Reference Manual. Reading, Massachusetts: Addison-Wesley.Google Scholar
  8. 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.Google Scholar
  9. Gamma, E. et al. 1993. Design patterns: Abstraction and reuse of object-oriented design. In Proceedings, ECOOP '93, Springer-Verlag, Berlin, pp. 406-421.Google Scholar
  10. Gamma, E. et al. 1995. Design Patterns Elements of Reusable Object-Oriented Software. Reading, Massachusetts, Addison-Wesley.Google Scholar
  11. Gamma, E. et al. 1996. TUTORIAL 29: Design patterns applied. In OOPSLA '96 Tutorial.Google Scholar
  12. Goldberg, A. 1984. Smalltalk-80: The Interactive Programming Environment. Reading, Massachusetts, Addison-Wesley.Google Scholar
  13. Griswold, W. 1991. Program Restructuring as an Aid to Software Maintenance. Ph.D. thesis, University of Washington.Google Scholar
  14. Johnson, R. and Foote, B. 1988. Designing reusable classes, Journal of Object-Oriented Programming, pp. 22-35.Google Scholar
  15. 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.Google Scholar
  16. 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.Google Scholar
  17. 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.Google Scholar
  18. 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.Google Scholar
  19. Linton, M. 1992. Encapsulating a C++ library. In Proceedings of the 1992 USENIX C++ Conference, Portland, Oregon, pp. 57-66.Google Scholar
  20. Maydany, P. et al. 1989. A class hierarchy for building stream-oriented file systems. In Proceedings of ECOOP '89, Nottingham, UK.Google Scholar
  21. 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.Google Scholar
  22. Morris, J.H. et al. 1986. Andrew: A distributed personal computing environment. Communications of the ACM.Google Scholar
  23. Opdyke, W.F. 1992. Refactoring object-oriented-frameworks. Ph.D. thesis, University of Illinois.Google Scholar
  24. Opdyke, W.F. and Johnson, R.E. 1993. Creating abstract susperclasses by refactoring. In ACM 1993 Computer Science Conference, Feb. 1993.Google Scholar
  25. Parnas, D.L. 1979. Designing software for ease of extension and contraction. IEEE Transactions on Software Engineering, 5(2):128-138.Google Scholar
  26. Pree, W. 1994. Meta Patterns—A Means for capturing the essentials of reusable object-oriented design. In Proceedings, ECOOP '94, Springer-Verlag, Berlin.Google Scholar
  27. Pree, W. and Sikora, H. 1995. Application of Design Patterns in Commercial Domains. OOPSLA '95 Tutorial 11, Austin, Texas.Google Scholar
  28. Pressman, R. 1992. Software Engineering A Practitioner's Approach. New York: McGraw Hill.Google Scholar
  29. Roberts, D., Brant, J., Johnson, R. 1997. A refactoring tool for smalltalk. In Theory and Practice of Object Systems, 3(4).Google Scholar
  30. Scherlis, W. 1998. Systematic change of data representation: program manipulations and case study. In Proceedings of ESOP, '98.Google Scholar
  31. 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.Google Scholar
  32. Simonyi, C. 1995. The death of computer languages, the birth of intentional programming. NATO Science Commitee Conference.Google Scholar
  33. Stewart, S. 1995. Roadmap for the Computer-Integrated Manufacturing Application Framework. NISTIR 5697.Google Scholar
  34. 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.Google Scholar
  35. Tokuda, L. and Batory, D. 1999. Automating three modes of object-oriented software evolution. In Proceedings, COOTS '99.Google Scholar
  36. Tokuda, L. and Batory, D. 1999. Evolving object-oriented designs with refactorings. Technical Report TR99-09, Department of Computer Science, University of Texas.Google Scholar
  37. Tokuda, L. 1999. Design evolution with refactorings. Ph.D. thesis, University of Texas.Google Scholar
  38. 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.Google Scholar
  39. Winsen, P.V. 1996. (Re)engineering with object-oriented design patterns. Master's Thesis, Utrecht University, INF-SCR-96-43.Google Scholar
  40. Yourdon, E. and Constantine, L. 1979. Structured Design. Englewood cliffs, New Jersey: Prentice Hall.Google Scholar

Copyright information

© Kluwer Academic Publishers 2001

Authors and Affiliations

  • Lance Tokuda
    • 1
  • Don Batory
    • 1
  1. 1.Department of Computer SciencesUniversity of TexasAustin

Personalised recommendations