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.
Similar content being viewed by others
Explore related subjects
Discover the latest articles, news and stories from top researchers in related subjects.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.
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.
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.
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.
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.
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.
Lorenz, M., & Kidd, J. (1994). Object-oriented software metrics: A practical approach. New York: Prentice Hall.
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.
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.
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.
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.
Author information
Authors and Affiliations
Corresponding author
Rights 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
Published:
Issue Date:
DOI: https://doi.org/10.1007/s10515-007-0007-3