Advertisement

Software Evolution

  • Miryung KimEmail author
  • Na Meng
  • Tianyi Zhang
Chapter

Abstract

Software evolution plays an ever-increasing role in software development. Programmers rarely build software from scratch but often spend more time in modifying existing software to provide new features to customers and fix defects in existing software. Evolving software systems are often a time-consuming and error-prone process. This chapter overviews key concepts and principles in the area of software evolution and presents the fundamentals of state-of-the art methods, tools, and techniques for evolving software. The chapter first classifies the types of software changes into four types: perfective changes to expand the existing requirements of a system, corrective changes for resolving defects, adaptive changes to accommodate any modifications to the environments, and finally preventive changes to improve the maintainability of software. For each type of changes, the chapter overviews software evolution techniques from the perspective of three kinds of activities: (1) applying changes, (2) inspecting changes, and (3) validating changes. The chapter concludes with the discussion of open problems and research challenges for the future.

Preview

Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.

References

  1. 1.
    Alves, E.L.G., Song, M., Kim, M.: Refdistiller: a refactoring aware code review tool for inspecting manual refactoring edits. In: Proceedings of the 22Nd ACM SIGSOFT International Symposium on Foundations of Software Engineering, FSE 2014, pp. 751–754. ACM, New York (2014)Google Scholar
  2. 2.
    Alves, E.L.G., Song, M., Massoni, T., Machado, P.D.L., Kim, M.: Refactoring inspection support for manual refactoring edits. IEEE Trans. Softw. Eng. PP(99), 1–1 (2017)Google Scholar
  3. 3.
    Apiwattanapong, T., Orso, A., Harrold, M.J.: A differencing algorithm for object-oriented programs. In: ASE ‘04: Proceedings of the 19th IEEE International Conference on Automated Software Engineering, pp. 2–13. IEEE Computer Society, Washington (2004)Google Scholar
  4. 4.
    Apiwattanapong, T., Orso, A., Harrold, M.J.: Efficient and precise dynamic impact analysis using execute-after sequences. In: ICSE ‘05: Proceedings of the 27th International Conference on Software Engineering, pp. 432–441. ACM, New York (2005)Google Scholar
  5. 5.
    Apostolico, A., Galil, Z. (eds.): Pattern Matching Algorithms. Oxford University Press, Oxford (1997). Program differencing LCSGoogle Scholar
  6. 6.
  7. 7.
    Bacchelli, A., Bird, C.: Expectations, outcomes, and challenges of modern code review. In: Proceedings of the 2013 International Conference on Software Engineering, pp. 712–721. IEEE Press, Piscataway (2013)Google Scholar
  8. 8.
    Balazinska, M., Merlo, E., Dagenais, M., Lague, B., Kontogiannis, K.: Partial redesign of java software systems based on clone analysis. In: WCRE ‘99: Proceedings of the Sixth Working Conference on Reverse Engineering, p. 326. IEEE Computer Society, Washington (1999)Google Scholar
  9. 9.
    Balazinska, M., Merlo, E., Dagenais, M., Lague, B., Kontogiannis, K.: Advanced clone-analysis to support object-oriented system refactoring. In: Proceedings Seventh Working Conference on Reverse Engineering, pp. 98–107 (2000)Google Scholar
  10. 10.
    Baldwin, C.Y., Clark, K.B.: Design Rules: The Power of Modularity. MIT Press, Cambridge (1999)Google Scholar
  11. 11.
    Barnett, M., Bird, C., Brunet, J., Lahiri, S.K.: Helping developers help themselves: automatic decomposition of code review changesets. In: Proceedings of the 37th International Conference on Software Engineering-Volume 1, pp. 134–144. IEEE Press, Piscataway (2015)Google Scholar
  12. 12.
    Batory, D., O’Malley, S.: The design and implementation of hierarchical software systems with reusable components. ACM Trans. Softw. Eng. Methodol. 1(4), 355–398 (1992)Google Scholar
  13. 13.
    Belady, L.A., Lehman, M.M.: A model of large program development. IBM Syst. J. 15(3), 225–252 (1976)zbMATHGoogle Scholar
  14. 14.
    Beller, M., Bacchelli, A., Zaidman, A., Juergens, E.: Modern code reviews in open-source projects: which problems do they fix? In: Proceedings of the 11th Working Conference on Mining Software Repositories, pp. 202–211. ACM, New York (2014)Google Scholar
  15. 15.
    Binkley, D., Horwitz, S., Reps, T.: Program integration for languages with procedure calls. ACM Trans. Softw. Eng. Methodol. 4(1), 3–35 (1995)Google Scholar
  16. 16.
    Boshernitsan, M., Graham, S.L., Hearst, M.A.: Aligning development tools with the way programmers think about code changes. In: CHI ‘07: Proceedings of the SIGCHI Conference on Human Factors in Computing Systems, pp. 567–576. ACM, New York (2007)Google Scholar
  17. 17.
    Bosu, A., Greiler, M., Bird, C.: Characteristics of useful code reviews: an empirical study at microsoft. In: 2015 IEEE/ACM 12th Working Conference on Mining Software Repositories (MSR), pp. 146–156. IEEE, Piscataway (2015)Google Scholar
  18. 18.
    Breu, S., Zimmermann, T.: Mining aspects from version history. In: International Conference on Automated Software Engineering, pp. 221–230 (2006)Google Scholar
  19. 19.
    Brown, N., Cai, Y., Guo, Y., Kazman, R., Kim, M., Kruchten, P., Lim, E., MacCormack, A., Nord, R., Ozkaya, I., Sangwan, R., Seaman, C., Sullivan, K., Zazworka, N.: Managing technical debt in software-reliant systems. In: Proceedings of the FSE/SDP Workshop on Future of Software Engineering Research, FoSER ‘10, pp. 47–52. ACM, New York (2010)Google Scholar
  20. 20.
  21. 21.
    Canfora, G., Cerulo, L., Cimitile, M., Di Penta, M.: Social interactions around cross-system bug fixings: the case of freebsd and openbsd. In: Proceeding of the 8th Working Conference on Mining Software Repositories, MSR ‘11, pp. 143–152. ACM, New York (2011)Google Scholar
  22. 22.
    Carriere, J., Kazman, R., Ozkaya, I.: A cost-benefit framework for making architectural decisions in a business context. In: ICSE ‘10: Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering, pp. 149–157. ACM, New York (2010)Google Scholar
  23. 23.
    Chawathe, S.S., Rajaraman, A., Garcia-Molina, H., Widom, J.: Change detection in hierarchically structured information. In: SIGMOD ‘96: Proceedings of the 1996 ACM SIGMOD International Conference on Management of Data, pp. 493–504. ACM, New York (1996)Google Scholar
  24. 24.
    Chou, A., Yang, J., Chelf, B., Hallem, S., Engler, D.: An empirical study of operating systems errors. In: Proceedings of the Eighteenth ACM Symposium on Operating Systems Principles, SOSP ‘01, pp. 73–88. ACM, New York (2001)Google Scholar
  25. 25.
    Chow, K., Notkin, D.: Semi-automatic update of applications in response to library changes. In: ICSM ‘96: Proceedings of the 1996 International Conference on Software Maintenance, p. 359. IEEE Computer Society, Washington (1996)Google Scholar
  26. 26.
    Cordy, J.R.: The txl source transformation language. Sci. Comput. Program. 61(3), 190–210 (2006)MathSciNetzbMATHGoogle Scholar
  27. 27.
    Cordy, J.R.: Exploring large-scale system similarity using incremental clone detection and live scatterplots. In: 2011 IEEE 19th International Conference on Program Comprehension (2011), pp. 151–160Google Scholar
  28. 28.
    Cornélio, M., Cavalcanti, A., Sampaio, A.: Sound refactorings. Sci. Comput. Program. 75(3), 106–133 (2010)MathSciNetzbMATHGoogle Scholar
  29. 29.
    Cossette, B.E., Walker, R.J.: Seeking the ground truth: a retroactive study on the evolution and migration of software libraries. In: FSE ‘12 Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering. ACM, New York (2012)Google Scholar
  30. 30.
    Cottrell, R., Chang, J.J.C., Walker, R.J., Denzinger, J.: Determining detailed structural correspondence for generalization tasks. In: Proceedings of the the 6th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on The Foundations of Software Engineering, ESEC-FSE ‘07, pp. 165–174. ACM, New York (2007)Google Scholar
  31. 31.
    Cunningham, W.: The WyCash portfolio management system. In: OOPSLA ‘92: Addendum to the Proceedings on Object-Oriented Programming Systems, Languages, and Applications (Addendum), pp. 29–30. ACM, New York (1992)Google Scholar
  32. 32.
    Dagenais, B., Robillard, M.P.: Recommending adaptive changes for framework evolution. In: Proceedings of the 30th International Conference on Software Engineering, ICSE ‘08, pp. 481–490. ACM, New York (2008)Google Scholar
  33. 33.
    Dagenais, B., Breu, S., Warr, F.W., Robillard, M.P.: Inferring structural patterns for concern traceability in evolving software. In: ASE ‘07: Proceedings of the Twenty-Second IEEE/ACM International Conference on Automated Software Engineering, pp. 254–263. ACM, New York (2007)Google Scholar
  34. 34.
    Demeyer, S., Ducasse, S., Nierstrasz, O.: Finding refactorings via change metrics. In: OOPSLA ‘00: Proceedings of the 15th ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, pp. 166–177. ACM, New York (2000)Google Scholar
  35. 35.
    Dig, D., Johnson, R.: Automated detection of refactorings in evolving components. In: ECOOP ‘06: Proceedings of European Conference on Object-Oriented Programming, pp. 404–428. Springer, Berlin (2006)Google Scholar
  36. 36.
    Dig, D., Johnson, R.: How do APIs evolve? A story of refactoring. J. Softw. Maint. Evol. Res. Pract. 18(2), 83–107 (2006)Google Scholar
  37. 37.
    Dig, D., Manzoor, K., Johnson, R., Nguyen, T.N.: Refactoring-aware configuration management for object-oriented programs. In: 29th International Conference on Software Engineering, 2007, ICSE 2007, pp. 427–436 (2007)Google Scholar
  38. 38.
    Duley, A., Spandikow, C., Kim, M.: Vdiff: a program differencing algorithm for verilog hardware description language. Autom. Softw. Eng. 19, 459–490 (2012)Google Scholar
  39. 39.
    Dunsmore, A., Roper, M., Wood, M.: Object-oriented inspection in the face of delocalisation. In: ICSE ‘00: Proceedings of the 22nd International Conference on Software Engineering, pp. 467–476. ACM, New York (2000). Code inspection, code review, object-oriented, delocalizedGoogle Scholar
  40. 40.
    Eclipse EMF Compare Project description: http://www.eclipse.org/emft/projects/compare
  41. 41.
    Eick, S.G., Graves, T.L., Karr, A.F., Marron, J.S., Mockus, A.: Does code decay? Assessing the evidence from change management data. IEEE Trans. Softw. Eng. 27(1), 1–12 (2001)Google Scholar
  42. 42.
    EmersonMurphy-Hill, X.S.: Towards refactoring-aware code review. In: CHASE’ 14: 7th International Workshop on Cooperative and Human Aspects of Software Engineering, Co-located with 2014 ACM and IEEE 36th International Conference on Software Engineering (2014)Google Scholar
  43. 43.
    Engelbertink, F.P., Vogt, H.H.: How to save on software maintenance costs. Omnext white paper (2010)Google Scholar
  44. 44.
    Engler, D., Chelf, B., Chou, A., Hallem, S.: Checking system rules using system-specific, programmer-written compiler extensions. In: Proceedings of the 4th Conference on Symposium on Operating System Design & Implementation - Volume 4, OSDI’00. USENIX Association, Berkeley (2000)Google Scholar
  45. 45.
    Engler, D.R., Chen, D.Y., Chou, A.: Bugs as inconsistent behavior: A general approach to inferring errors in systems code. In: Symposium on Operating Systems Principles, pp. 57–72 (2001)Google Scholar
  46. 46.
    Fagan, M.E.: Design and code inspections to reduce errors in program development. IBM Syst. J. 38(2–3), 258–287 (1999). Code inspection, checklistGoogle Scholar
  47. 47.
    Fischer, M., Oberleitner, J., Ratzinger, J., Gall, H.: Mining evolution data of a product family. In: MSR ‘05: Proceedings of the 2005 International Workshop on Mining Software Repositories, pp. 1–5. ACM, New York (2005)Google Scholar
  48. 48.
    Fluri, B., Würsch, M., Pinzger, M., Gall, H.C.: Change distilling—tree differencing for fine-grained source code change extraction. IEEE Trans. Softw. Eng. 33(11), 18 (2007)Google Scholar
  49. 49.
    Garcia, J., Popescu, D., Edwards, G., Medvidovic, N.: Identifying architectural bad smells. In: CSMR ‘09: Proceedings of the 2009 European Conference on Software Maintenance and Reengineering, pp. 255–258. IEEE Computer Society, Washington (2009)Google Scholar
  50. 50.
    Ge, X., Murphy-Hill, E.: Manual refactoring changes with automated refactoring validation. In: 36th International Conference on Software Engineering (ICSE 2014). IEEE, Piscataway (2014)Google Scholar
  51. 51.
    Görg, C., Weißgerber, P.: Error detection by refactoring reconstruction. In: MSR ‘05: Proceedings of the 2005 International Workshop on Mining Software Repositories, pp. 1–5. ACM Press, New York (2005)Google Scholar
  52. 52.
    Griswold, W.G.: Program restructuring as an aid to software maintenance. PhD thesis, Seattle (1992). UMI Order No. GAX92-03258Google Scholar
  53. 53.
    Griswold, W.: Coping with crosscutting software changes using information transparency. In: Reflection 2001: The Third International Conference on Metalevel Architectures and Separation of Crosscutting Concerns, pp. 250–265. Springer, Berlin (2001)Google Scholar
  54. 54.
    Griswold, W.G., Atkinson, D.C., McCurdy, C.: Fast, flexible syntactic pattern matching and processing. In: WPC ‘96: Proceedings of the 4th International Workshop on Program Comprehension, p. 144. IEEE Computer Society, Washington (1996)Google Scholar
  55. 55.
    Grubb, P., Takang, A.A.: Software Maintenance: Concepts and Practice. World Scientific (2003)Google Scholar
  56. 56.
    Guéhéneuc, Y.-G., Albin-Amiot, H.: 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 on Technology of Object-Oriented Languages and Systems (TOOLS39), TOOLS ‘01, p. 296. IEEE Computer Society, Washington (2001)Google Scholar
  57. 57.
    Guo, Y., Seaman, C., Zazworka, N., Shull, F.: Domain-specific tailoring of code smells: an empirical study. In: Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering - Volume 2, ICSE ‘10, pp. 167–170. ACM, New York (2010)Google Scholar
  58. 58.
    Guo, Y., Seaman, C., Gomes, R., Cavalcanti, A., Tonin, G., Da Silva, F.Q.B., Santos, A.L.M., Siebra, C.: Tracking technical debt - an exploratory case study. In: 27th IEEE International Conference on Software Maintenance (ICSM), pp. 528–531 (2011)Google Scholar
  59. 59.
    Harman, M.: The current state and future of search based software engineering. In: International Conference on Software Engineering, pp. 342–357 (2007)Google Scholar
  60. 60.
    Harrison, W., Ossher, H., Sutton, S., Tarr, P.: Concern modeling in the concern manipulation environment. In: Proceedings of the 2005 Workshop on Modeling and Analysis of Concerns in Software, pp. 1–5. ACM Press, New York (2005)Google Scholar
  61. 61.
    Harrold, M.J., Jones, J.A., Li, T., Liang, D., Orso, A., Pennings, M., Sinha, S., Spoon, S.A., Gujarathi, A.: Regression test selection for java software. In: OOPSLA ‘01: Proceedings of the 16th ACM SIGPLAN Conference on Object Oriented Programming, Systems, Languages, and Applications, pp. 312–326. ACM, New York (2001)Google Scholar
  62. 62.
    Henkel, J., Diwan, A.: Catchup!: capturing and replaying refactorings to support API evolution. In: ICSE ‘05: Proceedings of the 27th International Conference on Software Engineering, pp. 274–283. ACM, New York (2005)Google Scholar
  63. 63.
    Herzig, K., Zeller, A.: The impact of tangled code changes. In: 2013 10th IEEE Working Conference on Mining Software Repositories (MSR), pp. 121–130. IEEE, Piscataway (2013)Google Scholar
  64. 64.
    Higo, Y., Kamiya, T., Kusumoto, S., Inoue, K.: Refactoring support based on code clone analysis. In: PROFES ‘04: Proceedings of 5th International Conference on Product Focused Software Process Improvement, Kausai Science City, April 5–8, 2004, pp. 220–233 (2004)Google Scholar
  65. 65.
    Horwitz, S.: Identifying the semantic and textual differences between two versions of a program. In: PLDI ‘90: Proceedings of the ACM SIGPLAN 1990 Conference on Programming Language Design and Implementation, pp. 234–245. ACM, New York (1990)Google Scholar
  66. 66.
    Horwitz, S., Prins, J., Reps, T.: Integrating noninterfering versions of programs. ACM Trans. Program. Lang. Syst. 11(3), 345–387 (1989)Google Scholar
  67. 67.
    Hotta, K., Higo, Y., Kusumoto, S.: Identifying, tailoring, and suggesting form template method refactoring opportunities with program dependence graph. In: 2012 16th European Conference on Software Maintenance and Reengineering (CSMR), pp. 53–62. IEEE, Piscataway (2012)Google Scholar
  68. 68.
    Hou, D., Yao, X.: Exploring the intent behind API evolution: a case study. In: Proceedings of the 2011 18th Working Conference on Reverse Engineering, WCRE ‘11, pp. 131–140. IEEE Computer Society, Washington (2011)Google Scholar
  69. 69.
    Hunt, J.W., Szymanski, T.G.: A fast algorithm for computing longest common subsequences. Commun. ACM 20(5), 350–353 (1977)MathSciNetzbMATHGoogle Scholar
  70. 70.
    ISO/IEC 14764:2006: Software engineering software life cycle processes maintenance. Technical report, ISO/IEC (2006)Google Scholar
  71. 71.
    Izurieta, C., Bieman, J.M.: How software designs decay: a pilot study of pattern evolution. In: First International Symposium on ESEM, pp. 449–451 (2007)Google Scholar
  72. 72.
    Jablonski, P., Hou, D.: CReN: a tool for tracking copy-and-paste code clones and renaming identifiers consistently in the IDE. In: Proceedings of the 2007 OOPSLA Workshop on Eclipse Technology eXchange, eclipse ‘07, pp. 16–20. ACM, New York (2007)Google Scholar
  73. 73.
    Jackson, D., Ladd, D.A.: Semantic diff: a tool for summarizing the effects of modifications. In: ICSM ‘94: Proceedings of the International Conference on Software Maintenance, pp. 243–252. IEEE Computer Society, Washington (1994)Google Scholar
  74. 74.
    Janssen, T., Abreu, R., Gemund, A.: Zoltar: a toolset for automatic fault localization. In: Proc. of ASE, pp. 662–664. IEEE Computer Society, Washington (2009)Google Scholar
  75. 75.
  76. 76.
    Jiang, L., Misherghi, G., Su, Z., Glondu, S.: Deckard: scalable and accurate tree-based detection of code clones. In: ICSE ‘07: Proceedings of the 29th International Conference on Software Engineering, pp. 96–105. IEEE Computer Society, Washington (2007)Google Scholar
  77. 77.
    Jiang, L., Su, Z., Chiu, E.: Context-based detection of clone-related bugs. In: ESEC-FSE ‘07: Proceedings of the the 6th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering, pp. 55–64. ACM, New York (2007)Google Scholar
  78. 78.
    Johnson, P.M.: Reengineering inspection. Commun. ACM 41(2), 49–52 (1998)Google Scholar
  79. 79.
    Johnson, R.: Beyond behavior preservation. Microsoft Faculty Summit 2011, Invited Talk, July 2011Google Scholar
  80. 80.
    Jones, J.A., Harrold, M.J., Stasko, J.: Visualization of test information to assist fault localization. In: Proceedings of the 24th International Conference on Software Engineering, ICSE ‘02, pp. 467–477. ACM, New York (2002)Google Scholar
  81. 81.
    Juergens, E., Deissenboeck, F., Hummel, B., Wagner, S.: Do code clones matter? In: Proceedings of the 31st International Conference on Software Engineering, ICSE ‘09, pp. 485–495. IEEE Computer Society, Washington (2009)Google Scholar
  82. 82.
    Juillerat, N., Hirsbrunner, B.: Toward an implementation of the “form template method” refactoring. In: SCAM 2007. Seventh IEEE International Working Conference on Source Code Analysis and Manipulation, pp. 81–90. IEEE, Piscataway (2007)Google Scholar
  83. 83.
    Kataoka, Y., Notkin, D., Ernst, M.D., Griswold, W.G.: Automated support for program refactoring using invariants. In: Proceedings of the IEEE International Conference on Software Maintenance (ICSM’01), ICSM ‘01, pp. 736. IEEE Computer Society, Washington (2001)Google Scholar
  84. 84.
    Kataoka, Y., Imai, T., Andou, H., Fukaya, T.: A quantitative evaluation of maintainability enhancement by refactoring. In: Proceedings of the International Conference on Software Maintenance (ICSM 2002), pp. 576–585. IEEE Computer Society, Washington (2002)Google Scholar
  85. 85.
    Kawrykow, D., Robillard, M.P.: Non-essential changes in version histories. In: Proceedings of the 33rd International Conference on Software Engineering, ICSE ‘11, pp. 351–360. ACM, New York (2011)Google Scholar
  86. 86.
    Kiczales, G., Hilsdale, E., Hugunin, J., Kersten, M., Palm, J., Griswold, W.G.: An overview of AspectJ. In: Proceedings of the 15th European Conference on Object-Oriented Programming, ECOOP ‘01, pp. 327–353. Springer, London (2001)Google Scholar
  87. 87.
    Kim, M., Notkin, D.: Discovering and representing systematic code changes. In: Proceedings of the 31st International Conference on Software Engineering, ICSE ‘09, pp. 309–319. IEEE Computer Society, Washington (2009)Google Scholar
  88. 88.
    Kim, M., Sazawal, V., Notkin, D., Murphy, G.: An empirical study of code clone genealogies. In: Proceedings of the 10th European Software Engineering Conference Held Jointly with 13th ACM SIGSOFT International Symposium on Foundations of Software Engineering, ESEC/FSE-13, pp. 187–196. ACM, New York (2005)Google Scholar
  89. 89.
    Kim, S., Pan, K., James Whitehead, J.E.: When functions change their names: automatic detection of origin relationships. In: WCRE ‘05: Proceedings of the 12th Working Conference on Reverse Engineering, pp. 143–152. IEEE Computer Society, Washington (2005)Google Scholar
  90. 90.
    Kim, S., Pan, K., Whitehead, E.E.J. Jr.: Memories of bug fixes. In: Proceedings of the 14th ACM SIGSOFT International Symposium on Foundations of Software Engineering, SIGSOFT ‘06/FSE-14, pp. 35–45. ACM, New York (2006)Google Scholar
  91. 91.
    Kim, M., Notkin, D., Grossman, D.: Automatic inference of structural changes for matching across program versions. In: ICSE ‘07: Proceedings of the 29th International Conference on Software Engineering, pp. 333–343. IEEE Computer Society, Washington (2007)Google Scholar
  92. 92.
    Kim, M., Gee, M., Loh, A., Rachatasumrit, N.: Ref-finder: a refactoring reconstruction tool based on logic query templates. In: FSE ‘10: Proceedings of the Eighteenth ACM SIGSOFT International Symposium on Foundations of Software Engineering, pp. 371–372. ACM, New York (2010)Google Scholar
  93. 93.
    Kim, M., Cai, D., Kim, S.: An empirical investigation into the role of refactorings during software evolution. In: ICSE’ 11: Proceedings of the 2011 ACM and IEEE 33rd International Conference on Software Engineering (2011)Google Scholar
  94. 94.
    Kim, M., Zimmermann, T., Nagappan, N.: A field study of refactoring challenges and benefits. In: Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering, FSE ‘12, pp. 50:1–50:11. ACM, New York (2012)Google Scholar
  95. 95.
    Kim, D., Nam, J., Song, J., Kim, S.: Automatic patch generation learned from human-written patches. In: IEEE/ACM International Conference on Software Engineering (2013)Google Scholar
  96. 96.
    Kim, M., Zimmermann, T., Nagappan, N.: An empirical study of refactoring challenges and benefits at microsoft. IEEE Trans. Softw. Eng. 40(7), 633–649 (2014)Google Scholar
  97. 97.
    Kolb, R., Muthig, D., Patzke, T., Yamauchi, K.: Refactoring a legacy component for reuse in a software product line: a case study: practice articles. J. Softw. Maint. Evol. 18, 109–132 (2006)Google Scholar
  98. 98.
    Komondoor, R., Horwitz, S.: Semantics-preserving procedure extraction. In: POPL ‘00: Proceedings of the 27th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pp. 155–169. ACM Press, New York (2000)Google Scholar
  99. 99.
    Komondoor, R., Horwitz, S.: Effective, automatic procedure extraction. In: IWPC ‘03: Proceedings of the 11th IEEE International Workshop on Program Comprehension, p. 33. IEEE Computer Society, Washington (2003)Google Scholar
  100. 100.
    Koni-N’Sapu, G.G.: A scenario based approach for refactoring duplicated code in object-oriented systems. Master’s thesis, University of Bern, June 2001Google Scholar
  101. 101.
    Krishnan, G.P., Tsantalis, N.: Refactoring clones: an optimization problem. In: Proceedings of the ICSM, pp. 360–363 (2013)Google Scholar
  102. 102.
    Ladd, D.A., Ramming, J.C.: A*: a language for implementing language processors. IEEE Trans. Softw. Eng. 21(11), 894–901 (1995)Google Scholar
  103. 103.
    Lammel, R., Saraiva, J., Visser, J. (eds.): Generative and Transformational Techniques in Software Engineering IV, International Summer School, GTTSE 2011, Braga, July 3–9, 2011. Revised Papers. Lecture Notes in Computer Science, vol. 7680. Springer, Berlin (2013)Google Scholar
  104. 104.
    Landauer, J., Hirakawa, M.: Visual AWK: a model for text processing by demonstration. In: Proceedings of the 11th International IEEE Symposium on Visual Languages, VL ‘95, p. 267. IEEE Computer Society, Washington (1995)Google Scholar
  105. 105.
    Laski, J., Szermer, W.: Identification of program modifications and its applications in software maintenance. In: ICSM 1992: Proceedings of International Conference on Software Maintenance (1992)Google Scholar
  106. 106.
    Lau, T., Wolfman, S.A., Domingos, P., Weld, D.S.: Learning Repetitive Text-Editing Procedures with SMARTedit, pp. 209–226. Morgan Kaufmann, San Francisco (2001)Google Scholar
  107. 107.
    Le Goues, C., Dewey-Vogt, M., Forrest, S., Weimer, W.: A systematic study of automated program repair: fixing 55 out of 105 bugs for $8 each. In: International Conference on Software Engineering, pp. 3–13 (2012)Google Scholar
  108. 108.
    Lehman, M.M.: On understanding laws, evolution, and conservation in the large-program life cycle. J. Syst. Softw. 1, 213–221 (1984)Google Scholar
  109. 109.
    Li, Z., Lu, S., Myagmar, S., Zhou, Y.: CP-miner: a tool for finding copy-paste and related bugs in operating system code. In: Proceedings of the 6th Conference on Symposium on Operating Systems Design & Implementation - Volume 6, OSDI’04, pp. 20–20. USENIX Association, Berkeley (2004)Google Scholar
  110. 110.
    Li, Z., Lu, S., Myagmar, S., Zhou, Y.: CP-miner: finding copy-paste and related bugs in large-scale software code. IEEE Trans. Softw. Eng. 32(3), 176–192 (2006)Google Scholar
  111. 111.
    Li, Z., Tan, L., Wang, X., Lu, S., Zhou, Y., Zhai, C.: Have things changed now?: An empirical study of bug characteristics in modern open source software. In: Proceedings of the 1st Workshop on Architectural and System Support for Improving Software Dependability, ASID ‘06, pp. 25–33. ACM, New York (2006)Google Scholar
  112. 112.
    Lo, D., Jiang, L., Budi, A., et al.: Comprehensive evaluation of association measures for fault localization. In: Proceedings of ICSM, pp. 1–10. IEEE, Piscataway (2010)Google Scholar
  113. 113.
    MacCormack, A., Rusnak, J., Baldwin, C.Y.: Exploring the structure of complex software designs: an empirical study of open source and proprietary code. Manag. Sci. 52(7), 1015–1030 (2006)Google Scholar
  114. 114.
    Madhavji, N.H., Ramil, F.J.C., Perry, D.E.: Software Evolution and Feedback: Theory and Practice. Wiley, Hoboken (2006)Google Scholar
  115. 115.
    Malpohl, G., Hunt, J.J., Tichy, W.F.: Renaming detection. Autom. Softw. Eng. 10(2), 183–202 (2000)Google Scholar
  116. 116.
    Marinescu, R.: Detection strategies: metrics-based rules for detecting design flaws. In: Proceedings of the 20th IEEE International Conference on Software Maintenance, pp. 350–359. IEEE Computer Society, Washington (2004)Google Scholar
  117. 117.
    McDonnell, T., Ray, B., Kim, M.: An empirical study of API stability and adoption in the android ecosystem. In: 2013 29th IEEE International Conference on Software Maintenance (ICSM), pp. 70–79 (2013)Google Scholar
  118. 118.
    Meng, N., Kim, M., McKinley, K.S.: Systematic editing: generating program transformations from an example. In: Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI ‘11, pp. 329–342. ACM, New York (2011)Google Scholar
  119. 119.
    Meng, N., Kim, M., McKinley, K.S.: Lase: locating and applying systematic edits by learning from examples. In: Proceedings of the 2013 International Conference on Software Engineering, ICSE ‘13, pp. 502–511. IEEE Press, Piscataway (2013)Google Scholar
  120. 120.
    Meng, N., Hua, L., Kim, M., McKinley, K.S.: Does automated refactoring obviate systematic editing? In: Proceedings of the 37th International Conference on Software Engineering - Volume 1, ICSE ‘15, pp. 392–402. IEEE Press, Piscataway (2015)Google Scholar
  121. 121.
    Mens, T.: A state-of-the-art survey on software merging. IEEE Trans. Softw. Eng. 28(5), 449–462 (2002)Google Scholar
  122. 122.
    Mens, T., Tourwé, T.: A survey of software refactoring. IEEE Trans. Softw. Eng. 30(2), 126–139 (2004)Google Scholar
  123. 123.
    Mens, T., Van Eetvelde, N., Demeyer, S., Janssens, D.: Formalizing refactorings with graph transformations. J. Softw. Maint. Evol. Res. Pract. 17(4), 247–276 (2005)Google Scholar
  124. 124.
    Miller, R.C., Myers, B.A.: Interactive simultaneous editing of multiple text regions. In: Proceedings of the General Track: 2002 USENIX Annual Technical Conference, pp. 161–174. USENIX Association, Berkeley (2001)Google Scholar
  125. 125.
    Moha, N., Guéhéneuc, Y.-G., Meur, A.-F.L., Duchien, L.: A domain analysis to specify design defects and generate detection algorithms. In: Fiadeiro, J.L., Inverardi, P. (eds.) International Conference on FASE, vol. 4961. Lecture Notes in Computer Science, pp. 276–291. Springer, Berlin (2008)Google Scholar
  126. 126.
    Moser, R., Sillitti, A., Abrahamsson, P., Succi, G.: Does refactoring improve reusability? In: Proceedings of ICSR, pp. 287–297 (2006)Google Scholar
  127. 127.
    Mossienko, M.: Automated Cobol to Java recycling. In: Proceedings Seventh European Conference on Software Maintenance and Reengineering (2003)Google Scholar
  128. 128.
    Muchnick, S.S.: Advanced Compiler Design and Implementation. Morgan Kaufmann, San Francisco (1997)Google Scholar
  129. 129.
    Murphy, G.C., Kersten, M., Findlater, L.: How are Java Software Developers Using the Eclipse IDE? vol. 23, pp. 76–83. IEEE Computer Society Press, Los Alamitos (2006)Google Scholar
  130. 130.
    Murphy-Hill, E., Parnin, C., Black, A.P.: How we refactor, and how we know it. IEEE Trans. Softw. Eng. 38(1), 5–18 (2012)Google Scholar
  131. 131.
    Nagappan, N., Ball, T.: Use of relative code churn measures to predict system defect density. In: ICSE ‘05: Proceedings of the 27th International Conference on Software Engineering, pp. 284–292. ACM, New York (2005)Google Scholar
  132. 132.
    Naish, L., Lee, H., Ramamohanarao, K.: A model for spectra-based software diagnosis. ACM TOSEM 20(3), 11 (2011)Google Scholar
  133. 133.
    Nguyen, T.T., Nguyen, H.A., Pham, N.H., Al-Kofahi, J.M., Nguyen, T.N.: Graph-based mining of multiple object usage patterns. In: ESEC/FSE ‘09: Proceedings of the the 7th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering, pp. 383–392. ACM, New York (2009)Google Scholar
  134. 134.
    Nguyen, H.A., Nguyen, T.T., Wilson, G. Jr., Nguyen, A.T., Kim, M., Nguyen, T.N.: A graph-based approach to API usage adaptation. In: Proceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications, OOPSLA ‘10, pp. 302–321. ACM, New York (2010)Google Scholar
  135. 135.
    Nguyen, A.T., Nguyen, H.A., Nguyen, T.T., Nguyen, T.N.: Statistical learning approach for mining API usage mappings for code migration. In: Proceedings of the 29th ACM/IEEE International Conference on Automated Software Engineering, pp. 457–468. ACM, New York (2014)Google Scholar
  136. 136.
    Nguyen, A.T., Nguyen, T.T., Nguyen, T.N.: Divide-and-conquer approach for multi-phase statistical migration for source code (t). In: 2015 30th IEEE/ACM International Conference on Automated Software Engineering (ASE) (2015)Google Scholar
  137. 137.
    Nguyen, T.D., Nguyen, A.T., Phan, H.D., Nguyen, T.N.: Exploring API embedding for API usages and applications. In: Proceedings of the 39th International Conference on Software Engineering, ICSE ‘17, pp. 438–449. IEEE Press, Piscataway (2017)Google Scholar
  138. 138.
    Nix, R.: Editing by example. In: Proceedings of the 11th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages, POPL ‘84, pp. 186–195. ACM, New York (1984)Google Scholar
  139. 139.
    Ohst, D., Welle, M., Kelter, U.: Difference tools for analysis and design documents. In: International Conference on ICSM ‘03, p. 13. IEEE Computer Society, Washington (2003)Google Scholar
  140. 140.
    Opdyke, W.F.: Refactoring object-oriented frameworks. PhD thesis, Champaign (1992). UMI Order No. GAX93-05645Google Scholar
  141. 141.
    Orso, A., Shi, N., Harrold, M.J.: Scaling regression testing to large software systems. In: SIGSOFT ‘04/FSE-12: Proceedings of the 12th ACM SIGSOFT Twelfth International Symposium on Foundations of Software Engineering, pp. 241–251. ACM, New York (2004)Google Scholar
  142. 142.
    Overbey, J.L., Fotzler, M.J., Kasza, A.J., Johnson, R.E.: A collection of refactoring specifications for fortran 95. In: ACM SIGPLAN Fortran Forum, vol. 29, pp. 11–25. ACM, New York (2010)Google Scholar
  143. 143.
    Padioleau, Y., Lawall, J.L., Muller, G.: Understanding collateral evolution in linux device drivers. In: Proceedings of the 1st ACM SIGOPS/EuroSys European Conference on Computer Systems 2006, EuroSys ‘06, pp. 59–71. ACM, New York (2006)Google Scholar
  144. 144.
    Padioleau, Y., Lawall, J., Hansen, R.R., Muller, G.: Documenting and automating collateral evolutions in linux device drivers. In: Proceedings of the 3rd ACM SIGOPS/EuroSys European Conference on Computer Systems 2008, Eurosys ‘08, pp. 247–260. ACM, New York (2008)Google Scholar
  145. 145.
    Perry, D.E., Siy, H.P., Votta, L.G.: Parallel changes in large-scale software development: an observational case study. ACM Trans. Softw. Eng. Methodol. 10(3), 308–337 (2001)Google Scholar
  146. 146.
  147. 147.
    Prete, K., Rachatasumrit, N., Sudan, N., Kim, M.: Template-based reconstruction of complex refactorings. In: 2010 IEEE International Conference on Software Maintenance (ICSM), pp. 1–10. IEEE Press, Piscataway (2010)Google Scholar
  148. 148.
    Purushothaman, R., Perry, D.E.: Toward understanding the rhetoric of small source code changes. IEEE Trans. Softw. Eng. 31(6), 511–526 (2005)Google Scholar
  149. 149.
    Rachatasumrit, N., Kim, M.: An empirical investigation into the impact of refactoring on regression testing. In: ICSM ‘12: the 28th IEEE International Conference on Software Maintenance, p. 10. IEEE Society, Washington (2012)Google Scholar
  150. 150.
    Ratzinger, J., Fischer, M., Gall, H.: Improving evolvability through refactoring. In: MSR ’05 Proceedings of the 2005 International Workshop on Mining Software Repositories, pp. 1–5 (2005)Google Scholar
  151. 151.
    Ratzinger, J., Sigmund, T., Gall, H.C.: On the relation of refactorings and software defect prediction. In: MSR ‘08: Proceedings of the 2008 International Working Conference on Mining Software Repositories, pp. 35–38. ACM, New York (2008)Google Scholar
  152. 152.
    Ray, B., Kim, M.: A case study of cross-system porting in forked projects. In: Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering, FSE ‘12, pp. 53:1–53:11. ACM, New York (2012)Google Scholar
  153. 153.
    Ray, B., Kim, M., Person, S., Rungta, N.: Detecting and characterizing semantic inconsistencies in ported code. In: 2013 IEEE/ACM 28th International Conference on Automated Software Engineering (ASE), pp. 367–377 (2013)Google Scholar
  154. 154.
    Ren, X., Shah, F., Tip, F., Ryder, B.G., Chesley, O.: Chianti: a tool for change impact analysis of java programs. In: OOPSLA ‘04: Proceedings of the 19th annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, pp. 432–448. ACM, New York (2004)Google Scholar
  155. 155.
    Rigby, P.C., Bird, C.: Convergent contemporary software peer review practices. In: Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering, pp. 202–212. ACM, New York (2013)Google Scholar
  156. 156.
    Rigby, P.C., German, D.M., Storey, M.-A.: Open source software peer review practices: a case study of the apache server. In: ICSE ‘08: Proceedings of the 30th International Conference on Software Engineering, pp. 541–550. ACM, New York (2008)Google Scholar
  157. 157.
    Robbes, R., Lanza, M.: Spyware: a change-aware development toolset. In: ICSE ‘08: Proceedings of the 30th International Conference on Software Engineering, pp. 847–850. ACM, New York (2008)Google Scholar
  158. 158.
    Robbes, R., Lungu, M., Röthlisberger, D.: How do developers react to API deprecation?: The case of a smalltalk ecosystem. In: Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering, FSE ‘12, pp. 56:1–56:11. ACM, New York (2012)Google Scholar
  159. 159.
    Roberts, D., Opdyke, W., Beck, K., Fowler, M., Brant, J.: Refactoring: Improving the Design of Existing Code. Addison-Wesley Longman Publishing Co., Inc., Boston (1999)Google Scholar
  160. 160.
    Robillard, M.P., Murphy, G.C.: Feat: a tool for locating, describing, and analyzing concerns in source code. In: ICSE ‘03: Proceedings of the 25th International Conference on Software Engineering, pp. 822–823. IEEE Computer Society, Washington (2003)Google Scholar
  161. 161.
    Rolim, R., Soares, G., D’Antoni, L., Polozov, O., Gulwani, S., Gheyi, R., Suzuki, R., Hartmann, B.: Learning syntactic program transformations from examples. In: Proceedings of the 39th International Conference on Software Engineering, ICSE ‘17, pp. 404–415. IEEE Press, Piscataway (2017)Google Scholar
  162. 162.
    Rothermel, G., Harrold, M.J.: A safe, efficient regression test selection technique. ACM Trans. Softw. Eng. Methodol. 6(2), 173–210 (1997)Google Scholar
  163. 163.
    Schaefer, M., de Moor, O.: Specifying and implementing refactorings. In: Proceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications, OOPSLA ‘10, pp. 286–301. ACM, New York (2010)Google Scholar
  164. 164.
    Schmidt, M., Gloetzner, T.: Constructing difference tools for models using the sidiff framework. In: ICSE Companion ‘08: Companion of the 30th International Conference on Software Engineering, pp. 947–948. ACM, New York (2008)Google Scholar
  165. 165.
    Shao, D., Khurshid, S., Perry, D.: Evaluation of semantic interference detection in parallel changes: an exploratory experiment. In: ICSM 2007. IEEE International Conference on Software Maintenance, pp. 74–83 (2007)Google Scholar
  166. 166.
    Shepherd, D., Fry, Z.P., Hill, E., Pollock, L., Vijay-Shanker, K.: Using natural language program analysis to locate and understand action-oriented concerns. In: AOSD ‘07: Proceedings of the 6th International Conference on Aspect-Oriented Software Development, pp. 212–224. ACM, New York (2007)Google Scholar
  167. 167.
    Sidiroglou, S., Ioannidis, S., Keromytis, A.D.: Band-aid patching. In: Proceedings of the 3rd Workshop on on Hot Topics in System Dependability, HotDep’07. USENIX Association, Berkeley (2007)Google Scholar
  168. 168.
    Silva, D., Tsantalis, N., Valente, M.T.: Why we refactor? confessions of Github contributors. In: Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering, FSE 2016, pp. 858–870. ACM, New York (2016)Google Scholar
  169. 169.
    Śliwerski, J., Zimmermann, T., Zeller, A.: When do changes induce fixes? In: Proceedings of the 2005 International Workshop on Mining Software Repositories, MSR ‘05, pp. 1–5. ACM, New York (2005)Google Scholar
  170. 170.
    Sneed, H.M.: Migrating from COBOL to Java. In: Proceedings of the 2010 IEEE International Conference on Software Maintenance (2010)Google Scholar
  171. 171.
    Soares, G.: Making program refactoring safer. In: Proceedings of the 32Nd ACM/IEEE International Conference on Software Engineering - Volume 2, ICSE ‘10, pp. 521–522 (2010)Google Scholar
  172. 172.
    Software Maintenance and Computers (IEEE Computer Society Press Tutorial). IEEE Computer Society, Los Alamitos (1990)Google Scholar
  173. 173.
    Son, S., McKinley, K.S., Shmatikov, V.: Fix me up: repairing access-control bugs in web applications. In: NDSS Symposium (2013)Google Scholar
  174. 174.
    Soto, M., Münch, J.: Process Model Difference Analysis for Supporting Process Evolution. Lecture Notes in Computer Science, vol. 4257, pp. 123–134. Springer, Berlin (2006)Google Scholar
  175. 175.
    Sullivan, K., Chalasani, P., Sazawal, V.: Software design as an investment activity: a real options perspective. Technical report (1998)Google Scholar
  176. 176.
    Swanson, E.B.: The dimensions of maintenance. In: Proceedings of the 2Nd International Conference on Software Engineering, ICSE ‘76, pp. 492–497. IEEE Computer Society Press, Los Alamitos (1976)Google Scholar
  177. 177.
    Tahvildari, L., Kontogiannis, K.: A metric-based approach to enhance design quality through meta-pattern transformations. In: Proceedings of the Seventh European Conference on Software Maintenance and Reengineering, CSMR ‘03, p. 183. IEEE Computer Society, Washington (2003)Google Scholar
  178. 178.
    Tairas, R., Gray, J.: Increasing clone maintenance support by unifying clone detection and refactoring activities. Inf. Softw. Technol. 54(12), 1297–1307 (2012)Google Scholar
  179. 179.
    Tao, Y., Kim, S.: Partitioning composite code changes to facilitate code review. In: 2015 IEEE/ACM 12th Working Conference on Mining Software Repositories (MSR), pp. 180–190. IEEE, Piscataway (2015)Google Scholar
  180. 180.
    Tarr, P., Ossher, H., Harrison, W., Sutton, JSM.: N degrees of separation: multi-dimensional separation of concerns. In: ICSE ‘99: Proceedings of the 21st International Conference on Software Engineering, pp. 107–119. IEEE Computer Society Press, Los Alamitos (1999)Google Scholar
  181. 181.
    The AspectJ Project. https://eclipse.org/aspectj/
  182. 182.
    The Guided Tour of TXL. https://www.txl.ca/tour/tour1.html
  183. 183.
    Tichy, W.F.: The string-to-string correction problem with block moves. ACM Trans. Comput. Syst. 2(4), 309–321 (1984)Google Scholar
  184. 184.
    Toomim, M., Begel, A., Graham, S.L.: Managing duplicated code with linked editing. In: VLHCC ‘04: Proceedings of the 2004 IEEE Symposium on Visual Languages - Human Centric Computing, pp. 173–180. IEEE Computer Society, Washington (2004)Google Scholar
  185. 185.
    Treude, C., Berlik, S., Wenzel, S., Kelter, U.: Difference computation of large models. In: Proceedings of the the 6th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering, ESEC-FSE ‘07, pp. 295–304. ACM, New York (2007)Google Scholar
  186. 186.
    Tsantalis, N., Chatzigeorgiou, A.: Identification of extract method refactoring opportunities. In: CSMR ‘09: Proceedings of the 2009 European Conference on Software Maintenance and Reengineering, pp. 119–128. IEEE Computer Society, Washington (2009)Google Scholar
  187. 187.
    Tsantalis, N., Chatzigeorgiou, A.: Identification of move method refactoring opportunities. IEEE Trans. Softw. Eng. 35(3), 347–367 (2009)Google Scholar
  188. 188.
    Tsantalis, N., Chatzigeorgiou, A.: Identification of extract method refactoring opportunities for the decomposition of methods. J. Syst. Softw. 84(10), 1757–1782 (2011)Google Scholar
  189. 189.
    Tsantalis, N., Chatzigeorgiou, A.: Ranking refactoring suggestions based on historical volatility. In: 2011 15th European Conference on Software Maintenance and Reengineering, pp. 25–34 (2011)Google Scholar
  190. 190.
    Tsantalis, N., Chaikalis, T., Chatzigeorgiou, A.: Jdeodorant: identification and removal of type-checking bad smells. In: CSMR ‘08: Proceedings of the 2008 12th European Conference on Software Maintenance and Reengineering, pp. 329–331. IEEE Computer Society, Washington (2008)Google Scholar
  191. 191.
    Vakilian, M., Chen, N., Negara, S., Rajkumar, B.A., Bailey, B.P., Johnson, R.E.: Use, disuse, and misuse of automated refactorings. In: 2012 34th International Conference on Software Engineering (ICSE), pp. 233–243 (2012)Google Scholar
  192. 192.
    van Engelen, R.: On the use of clone detection for identifying crosscutting concern code. IEEE Trans. Softw. Eng. 31(10), 804–818 (2005). Student Member-Magiel Bruntink and Member-Arie van Deursen and Member-Tom TourweGoogle Scholar
  193. 193.
    Visser, E.: Program transformation with Stratego/XT: rules, strategies, tools, and systems in StrategoXT-0.9. Domain-Specific Program Generation 3016, 216–238 (2004)Google Scholar
  194. 194.
    Wang, W., Godfrey, M.W.: Recommending clones for refactoring using design, context, and history. In: 2014 IEEE International Conference on Software Maintenance and Evolution, pp. 331–340 (2014)Google Scholar
  195. 195.
    Wei, Y., Pei, Y., Furia, C.A., Silva, L.S., Buchholz, S., Meyer, B., Zeller, A.: Automated fixing of programs with contracts. In: Proceedings of the 19th International Symposium on Software Testing and Analysis, ISSTA ‘10, pp. 61–72. ACM, New York (2010)Google Scholar
  196. 196.
    Weißgerber, P., Diehl, S.: Are refactorings less error-prone than other changes? In: MSR ‘06: Proceedings of the 2006 International Workshop on Mining Software Repositories, pp. 112–118. ACM, New York (2006)Google Scholar
  197. 197.
    Weißgerber, P., Diehl, S.: Identifying refactorings from source-code changes. In: ASE ‘06: Proceedings of the 21st IEEE/ACM International Conference on Automated Software Engineering, pp. 231–240. IEEE Computer Society, Washington (2006)Google Scholar
  198. 198.
    Weimer, W., Nguyen, T., Le Goues, C., Forrest, S.: Automatically finding patches using genetic programming. In: Proceedings of the 31st International Conference on Software Engineering, ICSE ‘09, pp. 364–374. IEEE Computer Society, Washington (2009)Google Scholar
  199. 199.
    Wikipedia. Comparison of BSD operating systems — Wikipedia, the free encyclopedia (2012)Google Scholar
  200. 200.
    Wong, S., Cai, Y., Kim, M., Dalton, M.: Detecting software modularity violations. In: ICSE’ 11: Proceedings of the 2011 ACM and IEEE 33rd International Conference on Software Engineering (2011)Google Scholar
  201. 201.
    Xing, Z., Stroulia, E.: UMLDiff: an algorithm for object-oriented design differencing. In: ASE ‘05: Proceedings of the 20th IEEE/ACM International Conference on Automated Software Engineering, pp. 54–65. ACM, New York (2005)Google Scholar
  202. 202.
    Xing, Z., Stroulia, E.: Refactoring detection based on UMLDiff change-facts queries. In: WCRE ‘06: Proceedings of the 13th Working Conference on Reverse Engineering, pp. 263–274. IEEE Computer Society, Washington (2006)Google Scholar
  203. 203.
    Xing, Z., Stroulia, E.: Refactoring practice: how it is and how it should be supported - an eclipse case study. In: ICSM ‘06: Proceedings of the 22nd IEEE International Conference on Software Maintenance, pp. 458–468. IEEE Computer Society, Washington (2006)Google Scholar
  204. 204.
    Xing, Z., Stroulia, E.: API-evolution support with diff-catchup. IEEE Trans. Softw. Eng. 33(12), 818–836 (2007)Google Scholar
  205. 205.
    Yamamoto, T., Matsushita, M., Kamiya, T., Inoue, K.: Measuring similarity of large software systems based on source code correspondence. In: Proceedings of 2005 Product Focused Software Process Improvement, pp. 530–544 (2005)Google Scholar
  206. 206.
    Yang, W.: Identifying syntactic differences between two programs. Softw. Pract. Experience 21(7), 739–755 (1991)Google Scholar
  207. 207.
    Yang, W., Horwitz, S., Reps, T.: Detecting program components with equivalent behaviors. Technical Report CS-TR-1989-840, University of Wisconsin, Madison (1989)Google Scholar
  208. 208.
    Yasumatsu, K., Doi, N.: SPiCE: a system for translating Smalltalk programs into a C environment. IEEE Trans. Softw. Eng. 21(11), 902–912 (1995)Google Scholar
  209. 209.
    Yin, Z., Yuan, D., Zhou, Y., Pasupathy, S., Bairavasundaram, L.: How do fixes become bugs? In: Proceedings of the 19th ACM SIGSOFT Symposium and the 13th European Conference on Foundations of Software Engineering, ESEC/FSE ‘11, pp. 26–36. ACM, New York (2011)Google Scholar
  210. 210.
    Yokomori, R., Siy, H.P., Noro, M., Inoue, K.: Assessing the impact of framework changes using component ranking. In: Proceedings of ICSM, pp. 189–198. IEEE, Piscataway (2009)Google Scholar
  211. 211.
    Zeller, A.: Yesterday, my program worked. today, it does not. Why? In: ESEC/FSE-7: Proceedings of the 7th European Software Engineering Conference Held Jointly with the 7th ACM SIGSOFT International Symposium on Foundations of Software Engineering, pp. 253–267. Springer, London (1999)Google Scholar
  212. 212.
    Zeller, A.: Automated debugging: are we close? IEEE Comput. 34(11), 26–31 (2001)Google Scholar
  213. 213.
    Zhang, L., Kim, M., Khurshid, S.: Localizing failure-inducing program edits based on spectrum information. In: Proceedings of ICSM, pp. 23–32. IEEE, Piscataway (2011)Google Scholar
  214. 214.
    Zhang, T., Song, M., Pinedo, J., Kim, M.: Interactive code review for systematic changes. In: Proceedings of the 37th International Conference on Software Engineering-Volume 1, pp. 111–122. IEEE Press, Piscataway (2015)Google Scholar
  215. 215.
    Zhong, H., Thummalapenta, S., Xie, T., Zhang, L., Wang, Q.: Mining API mapping for language migration. In: Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering-Volume 1, pp. 195–204. ACM, New York (2010)Google Scholar
  216. 216.
    Zou, L., Godfrey, M.W.: Using origin analysis to detect merging and splitting of source code entities. IEEE Trans. Softw. Eng. 31(2), 166–181 (2005)Google Scholar

Copyright information

© Springer Nature Switzerland AG 2019

Authors and Affiliations

  1. 1.University of CaliforniaLos AngelesUSA
  2. 2.Virginia TechBlacksburgUSA

Personalised recommendations