Skip to main content
Log in

Differencing logical UML models

  • Published:
Automated Software Engineering Aims and scope Submit manuscript

Abstract

UMLDiff is a heuristic algorithm for automatically detecting the changes that the logical design of an object-oriented software system has gone through, as the subject system evolved from one version to the next. UMLDiff requires as input two models of the logical design of the system, corresponding to two of its versions. It produces as output a set of change facts, reporting the differences between the two logical-design versions in terms of (a) additions, removals, moves, renamings of model elements, i.e., subsystems, packages, classes, interfaces, attributes and operations, (b) changes to their attributes, and (c) changes to the relations among these model elements. In this paper, we detail the underlying metamodel, the UMLDiff algorithm and its heuristics for establishing lexical and structural similarity. We report on our experimental evaluation of the correctness and robustness of UMLDiff through a real-world case study.

This is a preview of subscription content, log in via an institution to check access.

Access this article

Price excludes VAT (USA)
Tax calculation will be finalised during checkout.

Instant access to the full article PDF.

Similar content being viewed by others

References

  • Apiwattanapong, T., Orso, A., & Harrold, M. J. (2004). A differencing algorithm for object-oriented programs. In Proceedings of the 19th international conference on automated software engineering (pp. 2–13).

  • Demeyer, S., Ducasse, S., & Nierstrasz, O. (2000). Finding refactorings via change metrics. ACM SIGPLAN Notices, 35(10), 166–177.

    Article  Google Scholar 

  • Egyed, A. (2001). Scalable consistency checking between diagrams—the ViewIntegra approach. In Proceedings of the 16th international conference on automated software engineering.

  • Eick, S. G., Steffen, J. L., & Sumner, E. E. (1992). SeeSoft—A tool for visualizing line-oriented software statistics. IEEE Transactions on Software Engineering, 18(11), 957–968.

    Article  Google Scholar 

  • 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.

    Article  Google Scholar 

  • Fischer, M., Pinzger, M., & Gall, H. (2003). Populating a release history database from version control and bug tracking systems. In Proceedings of the 19th international conference on software maintenance (pp. 23–32), September 2003.

  • Fowler, M. (1999). Refactoring: Improving the design of existing code. Reading: Addison–Wesley.

    Google Scholar 

  • Godfrey, M., & Zou, L. (2005). Using origin analysis to detect merging and splitting of source code entities. IEEE Transactions on Software Engineering, 31(2), 166–181.

    Article  Google Scholar 

  • Horwitz, S. (1990). Identifying the semantic and textual differences between two versions of a program. In Proceedings of the ACM SIGPLAN’90 conference on programming language design and implementation (pp. 234–246), June 1990.

  • Jackson, D., & Ladd, D. A. (1994). Semantic diff: A tool for summarizing the effects of modifications. In Proceedings of 9th international conference on software maintenance (pp. 243–252), September 1994.

  • Lanza, M. (2001). The evolution matrix: Recovering software evolution using software visualization techniques. In Proceedings of the 4th international workshop on principles of software evolution (pp. 37–42).

  • Lehman, M. M., & Belady, L. A. (1985). Program evolution-processes of software change. London: Academic Press, p. 538.

    Google Scholar 

  • Lorenz, M., & Kidd, J. (1994). Object-oriented software metrics: A practical approach. New York: Prentice Hall.

    Google Scholar 

  • OMG (2003). Unified Modeling Language Specification. formal/03-03-01, Version 1.5, http//www.omg.org.

  • Ohst, D., Welle, M., & Kelter, U. (2003). Difference tools for analysis and design documents. In Proceedings of the 19th international conference on software maintenance (pp. 13–22), September 2003.

  • Ryder, B. G., & Tip, F. (2001). Change impact analysis for object-oriented programs. In Proceedings of the 2001 ACM SIGPLAN-SIGSOFT workshop on program analysis for software tools and engineering (pp. 46–53).

  • Rysselberghe, F. V., & Demeyer, S. (2003). Reconstruction of successful software evolution using clone detection. In Proceedings of the international workshop on principles of software evolution (pp. 126–130), September 2003.

  • Schofield, C., Tansey, B., Xing, Z., & Stroulia, E. (2006). Digging the development dust for refactorings. In Proceedings of the 14th international conference on program comprehension (pp. 23–34), June 2006.

  • Simon, K. (1986). An improved algorithm for transitive closure on acyclic digraphs. In Theoretical computer science: Vol. 58, Automata, languages and programming (pp. 376–386).

  • Spanoudakis, G., & Kim, H. (2001). Reconciliation of object interaction models. In Proceedings of the 7th international conference on object oriented information systems (pp. 47–58), August 2001.

  • Tu, Q., & Godfrey, M. W. (2002). An integrated approach for studying architectural evolution. In Proceedings of the 10th international workshop on program comprehension (pp. 127–136).

  • Wagner, R. A., & Fischer, M. J. (1974). The string-to-string correction problem. Journal of the ACM, 21(1), 168–173.

    Article  MATH  Google Scholar 

  • Xing, Z., & Stroulia, E. (2004a). Understanding class evolution in object-oriented software. In Proceedings of the 12th international workshop on program comprehension (pp. 34–43), June 2004.

  • Xing, Z., & Stroulia, E. (2004b). Design mentoring based on design evolution analysis. In Proceedings of eclipse technology exchange workshop, OOPSLA 2004, Vancouver BC, Canada.

  • Xing, Z., & Stroulia, E. (2005a). Towards mentoring object-oriented evolutionary development. In Proceedings of the 21st international conference on software maintenance (pp. 621–624), September 2005.

  • Xing, Z., & Stroulia, E. (2005b). UMLDiff: An algorithm for object-oriented design differencing. In Proceedings of the 20th international conference on automated software engineering (pp. 54–65), November 2005.

  • Xing, Z., & Stroulia, E. (2005c). Analyzing the evolutionary history of the logical design of object-oriented software. IEEE Transactions on Software Engineering, 31(10), 850–868.

    Article  Google Scholar 

  • Xing, Z., & Stroulia, E. (2006a). Understanding the evolution and co-evolution of classes in object-oriented systems. International Journal of Software Engineering and Knowledge Engineering, 16(1), 23–52.

    Article  Google Scholar 

  • Xing, Z., & Stroulia, E. (2006b). Refactoring practice: How it is and how it should be supported—an eclipse case study. In Proceddings of the 22nd international conference on software maintenance (pp. 458–468), September 2006.

  • Xing, Z., & Stroulia, E. (2006c). Refactoring detection based on UMLDiff change-facts queries. In Proceedings of the 13th working conference on reverse engineering (pp. 263–274), October 2006.

  • Yang, W. (1991). Identifying syntactic differences between two programs. Software—Practice and Experience, 21(7), 739–755.

    Article  Google Scholar 

Download references

Author information

Authors and Affiliations

Authors

Corresponding author

Correspondence to Zhenchang Xing.

Rights and permissions

Reprints and permissions

About this article

Cite this article

Xing, Z., Stroulia, E. Differencing logical UML models. Autom Softw Eng 14, 215–259 (2007). https://doi.org/10.1007/s10515-007-0007-3

Download citation

  • Published:

  • Issue Date:

  • DOI: https://doi.org/10.1007/s10515-007-0007-3

Keywords

Navigation