Abstract
Software designs decay as systems, uses, and operational environments evolve. Decay can involve the design patterns used to structure a system. Classes that participate in design pattern realizations accumulate grime—non-pattern-related code. Design pattern realizations can also rot, when changes break the structural or functional integrity of a design pattern. Design pattern rot can prevent a pattern realization from fulfilling its responsibilities, and thus represents a fault. Grime buildup does not break the structural integrity of a pattern but can reduce system testability and adaptability. This research examined the extent to which software designs actually decay, rot, and accumulate grime by studying the aging of design patterns in three successful object-oriented systems. We generated UML models from the three implementations and employed a multiple case study methodology to analyze the evolution of the designs. We found no evidence of design pattern rot in these systems. However, we found considerable evidence of pattern decay due to grime. Dependencies between design pattern components increased without regard for pattern intent, reducing pattern modularity, and decreasing testability and adaptability. The study of decay and grime showed that the grime that builds up around design patterns is mostly due to increases in coupling.
Similar content being viewed by others
References
Altova Umodel. (2006). Altova. http://www.altova.com. Used 2008, 2009.
eXist Database. (2008). http://exist-db.org. Accessed 2008.
JDepends Open Source Software. (2008; 2009). http://www.clarkware.com/software/JDepend.html. Used 2008, 2009.
JRefactory Open Source Software. (2008). http://jrefactory.sourceforge.net. Accessed 2008.
PatternSeeker Tool. (2008). Colorado State University. Accessed 2008.
Semmle Query Technology. (2008; 2009). http://semmle.com. Used 2008, 2009.
ArgoUML. (2008). http://argouml.tigris.org. Accessed 2008.
Arisholm, E. (2006). Empirical assessment of the impact of structural properties on the changeability of object-oriented software. Information and Software Technology, 48(2006), 1046–1055.
Arisholm, E., Briand, L. C., & Foyen, A. (2004). Dynamic coupling measurement for object-oriented software. IEEE Transactions on Software Engineering, 30(8), 491–506.
Arisholm, E., & Sjoberg, D. (2000). Towards a framework for empirical assessment of changeability decay. The Journal of Systems and Software, 53(1), 3–14.
Basili, V. R., Briand, L. C., & Melo, W. L. (1996). A validation of object-oriented design metrics as quality indicators. IEEE Transactions on Software Engineering, 22(10), 751–761.
Baudry, B., & Sunye, G. (2004). Improving the testability of UML CLASS DIAGRAMS. In First international workshop on testability assesment, 2004, IWoTA 2004, proccedings, November 2004, pp. 70–80.
Baudry, B., Traon, Y., & Sunye, G. (2002). Testability analysis of a UML class diagram. In Software metrics symposium, Ottawa, Canada, June 2002, pp. 54–63.
Baudry, B., Traon, Y., Sunye, G., & Jezequel, J. M. (2001). Towards a safe use of design patterns to improve OO software testability. In Proceedings of the 12th international symposium on software reliability engineering, ISSRE’01, p. 324.
Baudry, B., Traon, Y., Sunye, G., & Jezequel, J. M. (2003). Measuring and improving design patterns testability. In 9th international software metrics symposium, September 2003, pp. 50–59.
Belady, L. A., & Lehman, M. M. (1971). Programming system dynamics, or the meta-dynamics of systems in maintenance and growth. Technical Report. IBM Thomas J. Watson Research Center.
Bieman, J. M., Straw, G., Wang, H., Munger, P. W., & Alexander, R. (2003). Design patterns and change proness: An examination of five evolving systems. In Proceedings of ninth international software metrics symposium (metrics 2003), pp. 40–49.
Binder, R. V. (2000). Testing object oriented systems. Models, patterns, and tools. Reading: Addison-Wesley Publishers.
Briand, L. C., Devanbu, P., & Melo, W. (1997). An investigation into coupling measures for C++. In Proceedings of the international conference of software engineering, ICSE’97, Boston, MA.
Briand, L. C., Wust, J., & Lounis, H. (1999). Using coupling measurement for impact analysis in object-oriented systems. In Proceedings of the IEEE international conference on software maintenance, p. 475.
Brown, N., Cai, Y., Guo, Y., Kazman, R., Kin, M., Kruchten, P., Lim, E., MacCormack, A., Nord, R., Ozkaya, I., Sangwan, R., Seaman, C., Sullivan, K., & Zazworka, N. (2010). Managing technical debt in software reliant systems. FoSER 2010, November 7–8, Santa Fe, New Mexico, USA.
Brown, W. J., Malveau, R. C., McCormick, H. W., & Mowbray, T. J. (1998). Anti patterns. Refactoring software, architectures, and projects in crisis. New York: Wiley.
Cain, J. W., & McCrindle, R. J. (2002). An investigation into the effects of code coupling on team dynamics and productivity. In Proceedings of the 26th annual international computer software and applications conference, COMPSAC ‘02.
Chidamber, S. R., & Kemerer, C. F. (1991). Towards a metrics suite for object-oriented design. In Proceedings: OOPSLA 1991, pp. 197–211.
Cunningham, W. (1992). The WyCash portfolio management system. OOPSLA’92 Experience Report, 1992.
Design Pattern Finder (2008; 2009). http://www.codeplex.com/DesignPatternFinder. Used 2008, 2009.
Eick, S. G., Graves, T. L., Karr, A. F., Marron, J. S., & Mockus, A. (2001). Does code decay? Assessing the evidence from change management data. IEEE Transactions on Software Engineering, 27(1), 1–12.
Fenton, N. E., & Pfleeger, S. L. (1996). Software metrics: A rigorous and practical approach. London: PWS, Computer Press.
France, R. B., Kim, D. K., Song, E., & Ghosh S. (2002). Metarole-based modeling language (RBML) specification V1.0.
France, R. B., Kim, D. K, Song, E., & Ghosh, S. (2004). A UML-based pattern specification technique. IEEE Transactions On Software Engineering, 30(3), 193–206.
Freeman, E., & Freeman, E. (2004). Head first design patterns. Sebastopol, CA: O’Reilly Media.
Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1995). Design patterns: Elements of reusable object oriented software. Reading, MA: Addison-Wesley.
Gilb, T. (1988). Principles of software engineering management. England: Addison Wesley.
Godfrey, M. W., & Tu, Q. (2000). Evolution in open source software: A case study. In Proceedings of the 2000 international conference on software maintenance (ICSM 2000). San Jose, California, October 2000.
Guéhéneuc, Y. G., & Albin-Amiot, H. (2001). Using design patterns and constraints to automate the detection and correction of inter-class design defects. In Proceedings of the 39th international conference and exhibition technology of object oriented languages and systems, pp. 296–305.
Guo, Y., Seaman, C., Zazworka, N., & Shull, F. (2010). Domain-specific tailoring of code smells: An empirical study. ICSE’10, May 2–8, Cape-Town, South Africa.
Henry, S., & Kafura, D. (1984). The evaluation of software systems’ structure using quantitative software metrics. Software: Practice and Experience, 14, 561–573. doi:10.1002/spe.4380140606.
Izurieta, C., & Bieman, J. M. (2007). How software designs decay: A pilot study of pattern evolution. In 1st ACM-IEEE international symposium on empirical software engineering and measurement, ESEM’07, Madrid, Spain, September 2007.
Izurieta, C., & Bieman, J. M. (2008). Testing consequences of grime buildup in object oriented design patterns. In 1st ACM-IEEE international conference on software testing, verification and validation, ICST’08, Lillehamer, Norway, April 2008.
JavaNCSS. (2008; 2009). http://www.kclee.de/clemens/java/javancss. Used 2008, 2009.
Khomh, F., Guéhéneuc, Y. G., & Antoniol, G. (2009). Playing roles in design patterns: An empirical descriptive and analytic study. In Proceedings of the 25th IEEE international conference on software maintenance (ICSM), September 20–26, 2009, Edmonton, Alberta, Canada. IEEE Computer Society Press.
Kim, D. K. (2004). A meta-modeling approach to specifying patterns. Colorado State University PhD Dissertation, June 21, 2004.
Kim, D. K., & Shen, W. (2008). Evaluating pattern conformance of UHL models: A divide-and conquer approach and case studies. Software Quality Journal, 16(3), 329–359.
Kouskouras, K. G., Chatzigeorgiou, A., & Stephanides, G. (2008). Facilitating software extension with design patterns and aspect-oriented programming. Journal of Systems and Software, 81, 1725–1737.
Lehman, M. M. (1980). Program life cycles and laws of software evolution. IEEE Special Issue on Software Engineering, 68(9), 1060–1076.
Lehman, M. M., Perry, D. E., & Ramil, J. F. (1998). Implications of evolution metrics on software maintenance. In Proceedings of the 1998 international conference on software maintenance (ICSM’98), November 1998, Bathesda, Maryland.
Li, W., & Henry, S. (1993). Object-oriented metrics that predict maintainability. Journal of Systems and Software, 23, 111–122.
Martin, R. C. (2002). Agile software development, principles, patterns, and practices. Englewood Cliffs, NJ: Prentice Hall.
McNatt, W. B., & Bieman, J. M. (2001). Coupling of design patterns: common practices and their benefits. In Proceedings of the 25th computer software and applications conference. IEEE Computer Society Press, October 2001, pp. 574–579.
Offutt, J., & Amman, P. (2008). Introduction to software testing (p. 27). Cambridge: Cambridge University Press.
Ott, R. L., & Longnecker, M. (2001). An introduction to statistical methods and data analysis (5th ed.). Pacific Grove, CA: Duxbury.
Parnas, D. L. (1994). Software ageing. Invited plenary talk. In 16th international conference (ICSE’94), pp. 279–287, May 1994.
Pree, W. (1994). Meta patterns-a means for capturing the essentials of reusable object oriented design. Lecture Notes in Computer Science, 821, 150–162.
Rombach, H. D. (1990). Design measurement: Some lessons learned. IEEE Software, 7, 17–25.
Schull, F., Melo, W., & Basili, V. (1996). An inductive method for discovering design patterns from object oriented software systems. Technical Report UMCP-CSD CS-TR-3597 or UMIACS-TR-96-10, University of Maryland, Computer Science Department.
Schumacher, J., Zazworka, N., Shull, F., Seaman, C., & Shaw, M. (2010). Building empirical support for automated code smell detection. ESEM’10, September 16–17, 2010, Bolzano-Bozen, Italy.
Van Gurp, J., & Bosch, J. (2002). Design erosion: Problems and causes. Journal of Systems and Software, 61, 105–119.
Yin, R. K. (2003). Case study research: Design & methods (3rd ed.). Thousand Oaks: Sage Books.
Author information
Authors and Affiliations
Corresponding author
Rights and permissions
About this article
Cite this article
Izurieta, C., Bieman, J.M. A multiple case study of design pattern decay, grime, and rot in evolving software systems. Software Qual J 21, 289–323 (2013). https://doi.org/10.1007/s11219-012-9175-x
Published:
Issue Date:
DOI: https://doi.org/10.1007/s11219-012-9175-x