Skip to main content
SpringerLink
Log in

Software Evolution

  • Chapter
  • First Online:
Handbook of Software Engineering

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.

All authors have contributed equally to this chapter.

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

Access this chapter

Log in via an institution
Chapter
USD 29.95
Price excludes VAT (USA)
  • Available as PDF
  • Read on any device
  • Instant download
  • Own it forever
eBook
USD 169.00
Price excludes VAT (USA)
  • Available as PDF
  • Read on any device
  • Instant download
  • Own it forever
Hardcover Book
USD 219.99
Price excludes VAT (USA)
  • Durable hardcover edition
  • Dispatched in 3 to 5 business days
  • Free shipping worldwide - see info

Tax calculation will be finalised at checkout

Purchases are for personal use only

Institutional subscriptions

Preview

Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.

References

  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. 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. 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. 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. Apostolico, A., Galil, Z. (eds.): Pattern Matching Algorithms. Oxford University Press, Oxford (1997). Program differencing LCS

    Google Scholar 

  6. ASM. http://asm.ow2.org

  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. 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. 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. Baldwin, C.Y., Clark, K.B.: Design Rules: The Power of Modularity. MIT Press, Cambridge (1999)

    Google Scholar 

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

    Article  Google Scholar 

  13. Belady, L.A., Lehman, M.M.: A model of large program development. IBM Syst. J. 15(3), 225–252 (1976)

    Article  MATH  Google Scholar 

  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. Binkley, D., Horwitz, S., Reps, T.: Program integration for languages with procedure calls. ACM Trans. Softw. Eng. Methodol. 4(1), 3–35 (1995)

    Article  Google Scholar 

  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. 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. Breu, S., Zimmermann, T.: Mining aspects from version history. In: International Conference on Automated Software Engineering, pp. 221–230 (2006)

    Google Scholar 

  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. Cambridge University Study States Software Bugs Cost Economy $312 Billion Per Year. http://markets.financialcontent.com/stocks/news/read/23147130/Cambridge_University_Study_States_Software_Bugs_Cost_Economy_$312_Billion_Per_Year

  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. 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. 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. 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. 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. Cordy, J.R.: The txl source transformation language. Sci. Comput. Program. 61(3), 190–210 (2006)

    Article  MathSciNet  MATH  Google Scholar 

  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–160

    Google Scholar 

  28. Cornélio, M., Cavalcanti, A., Sampaio, A.: Sound refactorings. Sci. Comput. Program. 75(3), 106–133 (2010)

    Article  MathSciNet  MATH  Google Scholar 

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

    Chapter  Google Scholar 

  36. Dig, D., Johnson, R.: How do APIs evolve? A story of refactoring. J. Softw. Maint. Evol. Res. Pract. 18(2), 83–107 (2006)

    Article  Google Scholar 

  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. Duley, A., Spandikow, C., Kim, M.: Vdiff: a program differencing algorithm for verilog hardware description language. Autom. Softw. Eng. 19, 459–490 (2012)

    Article  Google Scholar 

  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, delocalized

    Google Scholar 

  40. Eclipse EMF Compare Project description: http://www.eclipse.org/emft/projects/compare

  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)

    Article  Google Scholar 

  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. Engelbertink, F.P., Vogt, H.H.: How to save on software maintenance costs. Omnext white paper (2010)

    Google Scholar 

  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. 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. Fagan, M.E.: Design and code inspections to reduce errors in program development. IBM Syst. J. 38(2–3), 258–287 (1999). Code inspection, checklist

    Article  Google Scholar 

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

    Article  Google Scholar 

  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. 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. 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. Griswold, W.G.: Program restructuring as an aid to software maintenance. PhD thesis, Seattle (1992). UMI Order No. GAX92-03258

    Google Scholar 

  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. 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. Grubb, P., Takang, A.A.: Software Maintenance: Concepts and Practice. World Scientific (2003)

    Google Scholar 

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

    Chapter  Google Scholar 

  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. Horwitz, S., Prins, J., Reps, T.: Integrating noninterfering versions of programs. ACM Trans. Program. Lang. Syst. 11(3), 345–387 (1989)

    Article  Google Scholar 

  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. 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. Hunt, J.W., Szymanski, T.G.: A fast algorithm for computing longest common subsequences. Commun. ACM 20(5), 350–353 (1977)

    Article  MathSciNet  MATH  Google Scholar 

  70. ISO/IEC 14764:2006: Software engineering software life cycle processes maintenance. Technical report, ISO/IEC (2006)

    Google Scholar 

  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. 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. 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. 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. Javassist. http://jboss-javassist.github.io/javassist/

  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. 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. Johnson, P.M.: Reengineering inspection. Commun. ACM 41(2), 49–52 (1998)

    Article  Google Scholar 

  79. Johnson, R.: Beyond behavior preservation. Microsoft Faculty Summit 2011, Invited Talk, July 2011

    Google Scholar 

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

    Chapter  Google Scholar 

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

    Article  Google Scholar 

  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)

    Article  Google Scholar 

  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. 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. Koni-N’Sapu, G.G.: A scenario based approach for refactoring duplicated code in object-oriented systems. Master’s thesis, University of Bern, June 2001

    Google Scholar 

  101. Krishnan, G.P., Tsantalis, N.: Refactoring clones: an optimization problem. In: Proceedings of the ICSM, pp. 360–363 (2013)

    Google Scholar 

  102. Ladd, D.A., Ramming, J.C.: A*: a language for implementing language processors. IEEE Trans. Softw. Eng. 21(11), 894–901 (1995)

    Article  Google Scholar 

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

    Chapter  Google Scholar 

  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. Lehman, M.M.: On understanding laws, evolution, and conservation in the large-program life cycle. J. Syst. Softw. 1, 213–221 (1984)

    Article  Google Scholar 

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

    Article  Google Scholar 

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

    Article  Google Scholar 

  114. Madhavji, N.H., Ramil, F.J.C., Perry, D.E.: Software Evolution and Feedback: Theory and Practice. Wiley, Hoboken (2006)

    Book  Google Scholar 

  115. Malpohl, G., Hunt, J.J., Tichy, W.F.: Renaming detection. Autom. Softw. Eng. 10(2), 183–202 (2000)

    Article  Google Scholar 

  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. 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. 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. 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. 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. Mens, T.: A state-of-the-art survey on software merging. IEEE Trans. Softw. Eng. 28(5), 449–462 (2002)

    Article  Google Scholar 

  122. Mens, T., Tourwé, T.: A survey of software refactoring. IEEE Trans. Softw. Eng. 30(2), 126–139 (2004)

    Article  Google Scholar 

  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)

    Article  Google Scholar 

  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. 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. Moser, R., Sillitti, A., Abrahamsson, P., Succi, G.: Does refactoring improve reusability? In: Proceedings of ICSR, pp. 287–297 (2006)

    Google Scholar 

  127. Mossienko, M.: Automated Cobol to Java recycling. In: Proceedings Seventh European Conference on Software Maintenance and Reengineering (2003)

    Google Scholar 

  128. Muchnick, S.S.: Advanced Compiler Design and Implementation. Morgan Kaufmann, San Francisco (1997)

    Google Scholar 

  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)

    Article  Google Scholar 

  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)

    Article  Google Scholar 

  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. Naish, L., Lee, H., Ramamohanarao, K.: A model for spectra-based software diagnosis. ACM TOSEM 20(3), 11 (2011)

    Article  Google Scholar 

  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. 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. 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. 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. 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. 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. 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. Opdyke, W.F.: Refactoring object-oriented frameworks. PhD thesis, Champaign (1992). UMI Order No. GAX93-05645

    Google Scholar 

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

    Article  Google Scholar 

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

    Article  Google Scholar 

  146. Pmd: http://pmd.sourceforge.net/

  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. Purushothaman, R., Perry, D.E.: Toward understanding the rhetoric of small source code changes. IEEE Trans. Softw. Eng. 31(6), 511–526 (2005)

    Article  Google Scholar 

  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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. Rothermel, G., Harrold, M.J.: A safe, efficient regression test selection technique. ACM Trans. Softw. Eng. Methodol. 6(2), 173–210 (1997)

    Article  Google Scholar 

  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. 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. 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. 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. 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. 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. Ś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. Sneed, H.M.: Migrating from COBOL to Java. In: Proceedings of the 2010 IEEE International Conference on Software Maintenance (2010)

    Google Scholar 

  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. Software Maintenance and Computers (IEEE Computer Society Press Tutorial). IEEE Computer Society, Los Alamitos (1990)

    Google Scholar 

  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. 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. Sullivan, K., Chalasani, P., Sazawal, V.: Software design as an investment activity: a real options perspective. Technical report (1998)

    Google Scholar 

  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. 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. Tairas, R., Gray, J.: Increasing clone maintenance support by unifying clone detection and refactoring activities. Inf. Softw. Technol. 54(12), 1297–1307 (2012)

    Article  Google Scholar 

  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. 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. The AspectJ Project. https://eclipse.org/aspectj/

  182. The Guided Tour of TXL. https://www.txl.ca/tour/tour1.html

  183. Tichy, W.F.: The string-to-string correction problem with block moves. ACM Trans. Comput. Syst. 2(4), 309–321 (1984)

    Article  Google Scholar 

  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. 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. 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. Tsantalis, N., Chatzigeorgiou, A.: Identification of move method refactoring opportunities. IEEE Trans. Softw. Eng. 35(3), 347–367 (2009)

    Article  Google Scholar 

  188. Tsantalis, N., Chatzigeorgiou, A.: Identification of extract method refactoring opportunities for the decomposition of methods. J. Syst. Softw. 84(10), 1757–1782 (2011)

    Article  Google Scholar 

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

    Google Scholar 

  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)

    Article  Google Scholar 

  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. 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. 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. 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. 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. Wikipedia. Comparison of BSD operating systems — Wikipedia, the free encyclopedia (2012)

    Google Scholar 

  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. 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. 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. 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. Xing, Z., Stroulia, E.: API-evolution support with diff-catchup. IEEE Trans. Softw. Eng. 33(12), 818–836 (2007)

    Article  Google Scholar 

  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)

    Chapter  Google Scholar 

  206. Yang, W.: Identifying syntactic differences between two programs. Softw. Pract. Experience 21(7), 739–755 (1991)

    Article  Google Scholar 

  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. Yasumatsu, K., Doi, N.: SPiCE: a system for translating Smalltalk programs into a C environment. IEEE Trans. Softw. Eng. 21(11), 902–912 (1995)

    Article  Google Scholar 

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

    Article  Google Scholar 

  212. Zeller, A.: Automated debugging: are we close? IEEE Comput. 34(11), 26–31 (2001)

    Article  Google Scholar 

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

    Article  Google Scholar 

Download references

Author information

Author notes

    Authors and Affiliations

    1. University of California, Los Angeles, CA, USA

      Miryung Kim & Tianyi Zhang

    2. Virginia Tech, Blacksburg, VA, USA

      Na Meng

    Authors
    1. Miryung Kim
      View author publications

      You can also search for this author in PubMed Google Scholar

    2. Na Meng
      View author publications

      You can also search for this author in PubMed Google Scholar

    3. Tianyi Zhang
      View author publications

      You can also search for this author in PubMed Google Scholar

    Corresponding author

    Correspondence to Miryung Kim .

    Editor information

    Editors and Affiliations

    1. College of Informatics, Korea University, Seoul, Korea (Republic of)

      Sungdeok Cha

    2. University of California, Irvine, CA, USA

      Richard N. Taylor

    3. Professor Emeritus, POSTECH, Pohang, Korea (Republic of)

      Kyochul Kang

    Appendix

    Appendix

    The following text box shows selected, recommended readings for understanding the area of software evolution.

    Key References

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

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

    • Cordy, J.R.: The txl source transformation language. Sci. Comput. Program. 61(3), 190–210 (2006)

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

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

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

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

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

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

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

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

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

    Rights and permissions

    Reprints and permissions

    Copyright information

    © 2019 Springer Nature Switzerland AG

    About this chapter

    Check for updates. Verify currency and authenticity via CrossMark

    Cite this chapter

    Kim, M., Meng, N., Zhang, T. (2019). Software Evolution. In: Cha, S., Taylor, R., Kang, K. (eds) Handbook of Software Engineering. Springer, Cham. https://doi.org/10.1007/978-3-030-00262-6_6

    Download citation

    • DOI: https://doi.org/10.1007/978-3-030-00262-6_6

    • Published:

    • Publisher Name: Springer, Cham

    • Print ISBN: 978-3-030-00261-9

    • Online ISBN: 978-3-030-00262-6

    • eBook Packages: Computer ScienceComputer Science (R0)

    Publish with us

    Policies and ethics

    Search

    Navigation