Skip to main content

Advertisement

SpringerLink
Book cover

Ernst Denert Award for Software Engineering 2020 pp 197–226Cite as

  1. Home
  2. Ernst Denert Award for Software Engineering 2020
  3. Chapter
Ever Change a Running System: Structured Software Reengineering Using Automatically Proven-Correct Transformation Rules

Ever Change a Running System: Structured Software Reengineering Using Automatically Proven-Correct Transformation Rules

  • Dominic Steinhöfel9,10 
  • Chapter
  • Open Access
  • First Online: 28 February 2022

  • 729 Accesses

Abstract

Legacy systems are business-critical software systems whose failure can have a significant impact on the business. Yet, their maintenance and adaption to changed requirements consume a considerable amount of the total software development costs. Frequently, domain experts and developers involved in the original development are not available anymore, making it difficult to adapt a legacy system without introducing bugs or unwanted behavior. This results in a dilemma: businesses are reluctant to change a working system, while at the same time struggling with its high maintenance costs. We propose the concept of Structured Software Reengineering replacing the ad hoc forward engineering part of a reengineering process with the application of behavior-preserving, proven-correct transformations improving nonfunctional program properties. Such transformations preserve valuable business logic while improving properties such as maintainability, performance, or portability to new platforms. Manually encoding and proving such transformations for industrial programming languages, for example, in interactive proof assistants, is a major challenge requiring deep expert knowledge. Existing frameworks for automatically proving transformation rules have limited expressiveness and are restricted to particular target applications such as compilation or peep-hole optimizations. We present Abstract Execution, a specification and verification framework for statement-based program transformation rules on JAVA programs building on symbolic execution. Abstract Execution supports universal quantification over statements or expressions and addresses properties about the (big-step) behavior of programs. Since this class of properties is useful for a plethora of applications, Abstract Execution bridges the gap between expressiveness and automation. In many cases, fully automatic proofs are in possible. We explain REFINITY, a workbench for modeling and proving statement-level JAVA transformation rules, and discuss our applications of Abstract Execution to code refactoring, cost analysis of program transformations, and transformations reshaping programs for the application of parallel design patterns.

Download chapter PDF

References

  1. Aho, A.V., Sethi, R., Ullman, J.D.: Compilers: Principles, Techniques, and Tools. Addison-Wesley, Reading (1986)

    MATH  Google Scholar 

  2. Ahrendt, W., Beckert, B., Bubel, R., Hähnle, R., Schmitt, P.H., Ulbrich, M. (eds.): Deductive Software Verification—The KeY Book. LNCS, vol. 10001. Springer, Berlin (2016). https://doi.org/10.1007/978-3-319-49812-6

  3. Albert, E., Arenas, P., Genaim, S., Puebla, G., Zanardini, D.: Cost analysis of object-oriented bytecode programs. Theor. Comput. Sci. 413(1), 142–159 (2012). https://doi.org/10.1016/j.tcs.2011.07.009

    CrossRef  MathSciNet  Google Scholar 

  4. Albert, E., Hähnle, R., Merayo, A., Steinhöfel, D.: Certified abstract cost analysis. In: E. Guerra, M. Stoelinga (eds.) Proc. 24th Intern. Conf. on Fundamental Approaches to Software Engineering (FASE). LNCS, vol. 12649, pp. 24–45. Springer, Berlin (2021). https://doi.org/10.1007/978-3-030-71500-7_2

    CrossRef  Google Scholar 

  5. Alves, E.L.G., Massoni, T., de Lima Machado, P.D.: Test coverage of impacted code elements for detecting refactoring faults: an exploratory study. J. Syst. Softw. 123, 223–238 (2017). https://doi.org/10.1016/j.jss.2016.02.001

    CrossRef  Google Scholar 

  6. Baldoni, R., Coppa, E., D’Elia, D.C., Demetrescu, C., Finocchi, I.: A survey of symbolic execution techniques. ACM Comput. Surv. 51(3), 50:1–50:39 (2018). https://doi.org/10.1145/3182657

  7. Beckert, B., Ulbrich, M.: Trends in relational program verification. In: Principled Software Development—Essays Dedicated to Arnd Poetzsch-Heffter on the Occasion of his 60th Birthday, pp. 41–58 (2018). https://doi.org/10.1007/978-3-319-98047-8_3

  8. Bertot, Y., Castéran, P.: Interactive theorem proving and program development—Coq’Art: the calculus of inductive constructions. Texts in Theoretical Computer Science. An EATCS Series. Springer, Berlin (2004). https://doi.org/10.1007/978-3-662-07964-5

  9. Bubel, R., Roth, A., Rümmer, P.: Ensuring the correctness of lightweight tactics for JavaCard dynamic logic. Electr. Notes Theor. Comput. Sci. 199, 107–128 (2008). https://doi.org/10.1016/j.entcs.2007.11.015

    CrossRef  MathSciNet  Google Scholar 

  10. Burstall, R.M.: Program proving as hand simulation with a little induction. In: Information Processing, pp. 308–312. Elsevier, Amsterdam (1974)

    Google Scholar 

  11. Chikofsky, E.J., Cross, J.H.II..: Reverse engineering and design recovery: a taxonomy. IEEE Softw. 7(1), 13–17 (1990). https://doi.org/10.1109/52.43044

    CrossRef  Google Scholar 

  12. Crotty, J., Horrocks, I.: Managing legacy system costs: a case study of a meta-assessment model to identify solutions in a large financial services company. Appl. Comput. Inform. 13(2), 175–183 (2017). https://doi.org/10.1016/j.aci.2016.12.001

    CrossRef  Google Scholar 

  13. Cuadrado, F., García, B., Dueñas, J.C., G., H.A.P.: A case study on software evolution towards service-oriented architecture. In: Proc. 22nd Inter. Conf. on Advanced Information Networking and Applications (AINA), pp. 1399–1404. IEEE Computer Society, Silver Spring (2008). https://doi.org/10.1109/WAINA.2008.296

  14. Daniel, B., Dig, D., Garcia, K., Marinov, D.: Automated testing of refactoring engines. In: 6th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT International Symposium on Foundations of Software Engineering, pp. 185–194 (2007)

    Google Scholar 

  15. Eilertsen, A.M., Bagge, A.H., Stolz, V.: Safer refactorings. In: Margaria, T., Steffen, B. (eds.) Proc. 7th ISoLA. LNCS, vol. 9952 (2016). https://doi.org/10.1007/978-3-319-47166-2_36

  16. Feathers, M.C.: Working effectively with legacy code. In: Zannier, C., Erdogmus, H., Lindstrom, L. (eds.) Proc. 4th Conf. on Extreme Programming and Agile Methods. LNCS, vol. 3134, p. 217. Springer, Berlin (2004). https://doi.org/10.1007/978-3-540-27777-4_42

    Google Scholar 

  17. Fowler, M.: Refactoring: Improving the Design of Existing Code. Object Technology Series. Addison-Wesley, Reading (1999)

    Google Scholar 

  18. Fowler, M.: Refactoring: Improving the Design of Existing Code, 2nd edn. Addison-Wesley Signature Series. Addison-Wesley, Reading (2018)

    Google Scholar 

  19. Fürnweger, A., Auer, M., Biffl, S.: Software evolution of legacy systems—a case study of soft-migration. In: Hammoudi, S., Maciaszek, L.A., Missikoff, M., Camp, O., Cordeiro, J. (eds.) Proc. 18th Intern. Conf. on Enterprise Information Systems (ICEIS), pp. 413–424. SciTePress, Setúbal (2016). https://doi.org/10.5220/0005771104130424

    Google Scholar 

  20. Godlin, B., Strichman, O.: Regression verification: proving the equivalence of similar programs. Softw. Test., Verif. Reliab. 23(3), 241–258 (2013). https://doi.org/10.1002/stvr.1472

  21. Gulwani, S., Mehra, K.K., Chilimbi, T.M.: SPEED: precise and efficient static estimation of program computational complexity. In: Shao, Z., Pierce, B.C. (eds.) Proc. 36th POPL. ACM (2009). https://doi.org/10.1145/1480881.1480898

  22. Hähnle, R., Heydari Tabar, A., Mazaheri, A., Norouzi, M., Steinhöfel, D., Wolf, F.: Safer parallelization. In: Margaria, T., Steffen, B. (eds.) Proc. 9th Intern. Symposium on Leveraging Applications of Formal Methods, Verification and Validation (ISoLA): Engineering Principles, Part II. LNCS, vol. 12477. Springer, Berlin (2020). https://doi.org/10.1007/978-3-030-61470-6_8

    Google Scholar 

  23. Hoffmann, J., Hofmann, M.: Amortized resource analysis with polynomial potential. In: Gordon, A.D. (ed.) 19th European Symposium Programming Languages and Systems (ESOP). LNCS, vol. 6012. Springer, Berlin (2010). https://doi.org/10.1007/978-3-642-11957-6_16

    Google Scholar 

  24. Huda, Z.U., Jannesari, A., Wolf, F.: Using template matching to infer parallel design patterns. TACO 11(4), 64:1–64:21 (2014). https://doi.org/10.1145/2688905

  25. Kassios, I.T.: The dynamic frames theory. Formal Asp. Comput. 23(3) (2011). https://doi.org/10.1007/s00165-010-0152-5

  26. Khadka, R., Batlajery, B.V., Saeidi, A., Jansen, S., Hage, J.: How do professionals perceive legacy systems and software modernization? In: Jalote, P., Briand, L.C., van der Hoek, A. (eds.) 36th Intern. Conf. on Software Engineering (ICSE), pp. 36–47. ACM, New York (2014). https://doi.org/10.1145/2568225.2568318

    Google Scholar 

  27. King, J.C.: Symbolic execution and program testing. Commun. ACM 19(7), 385–394 (1976)

    CrossRef  MathSciNet  Google Scholar 

  28. Klein, G., Andronick, J., Elphinstone, K., Heiser, G., Cock, D., Derrin, P., Elkaduwe, D., Engelhardt, K., Kolanski, R., Norrish, M., Sewell, T., Tuch, H., Winwood, S.: seL4: formal verification of an operating-system kernel. Commun. ACM 53(6), 107–115 (2010). https://doi.org/10.1145/1743546.1743574

  29. Klein, G., Nipkow, T.: A machine-checked model for a java-like language, virtual machine, and compiler. ACM Trans. PLS 28(4), 619–695 (2006)

    Google Scholar 

  30. Leavens, G.T., Poll, E., Clifton, C., Cheon, Y., Ruby, C., Cok, D., Müller, P., Kiniry, J., Chalin, P., Zimmerman, D.M., Dietl, W.: JML Reference Manual (2013). http://www.eecs.ucf.edu/~leavens/JML//OldReleases/jmlrefman.pdf. Draft revision 2344

  31. Leroy, X.: Formal verification of a realistic compiler. Commun. ACM 52(7), 107–115 (2009)

    CrossRef  Google Scholar 

  32. London, R.L.: Correctness of a compiler for a lisp subset. In: Proc. ACM Conf. on Proving Assertions About Programs, pp. 121–127. ACM, New York (1972). https://doi.org/10.1145/800235.807080

  33. Lopes, N.P., Menendez, D., Nagarakatte, S., Regehr, J.: Practical verification of peephole optimizations with alive. Commun. ACM 61(2), 84–91 (2018). https://doi.org/10.1145/3166064

    CrossRef  Google Scholar 

  34. Massingill, B.L., Mattson, T.G., Sanders, B.A.: Parallel programming with a pattern language. Int. J. Softw. Tools Technol. Transf. 3(2), 217–234 (2001). https://doi.org/10.1007/s100090100045

    CrossRef  Google Scholar 

  35. Mattson, T.G., Sanders, B., Massingill, B.: Patterns for parallel programming. Pearson Education, London (2004)

    MATH  Google Scholar 

  36. McCarthy, J., Painter, J.: Correctness of a compiler for arithmetic expressions. Mathematical Aspects of Computer Science, vol. 1 (1967)

    Google Scholar 

  37. Nipkow, T., Paulson, L.C., Wenzel, M.: Isabelle/HOL—A Proof Assistant for Higher-Order Logic. LNCS, vol. 2283. Springer, Berlin (2002). https://doi.org/10.1007/3-540-45949-9

  38. Norouzi, M.A., Wolf, F., Jannesari, A.: Automatic construct selection and variable classification in OpenMP. In: Eigenmann, R., Ding, C., McKee, S.A. (eds.) Proc. ACM Intern. Conf. on Supercomputing (ICS). ACM, New York (2019). https://doi.org/10.1145/3330345.3330375

    Google Scholar 

  39. Radicek, I., Barthe, G., Gaboardi, M., Garg, D., Zuleger, F.: Monadic refinements for relational cost analysis. Proc. ACM Program. Lang. 2(POPL), 36:1–36:32 (2018). https://doi.org/10.1145/3158124

  40. Ransom, J., Sommerville, I., Warren, I.: A method for assessing legacy systems for evolution. In: Proc. 2nd Euromicro Conference on Software Maintenance and Reengineering (CSMR), pp. 128–134. IEEE Computer Society, Silver Spring (1998). https://doi.org/10.1109/CSMR.1998.665778

  41. Schneider, A.: When companies become prisoners of legacy systems. Wall Street J. (2013). https://deloitte.wsj.com/cio/2013/10/01/when-companies-become-prisoners/

  42. Smith, D.R.: KIDS: a semiautomatic program development system. IEEE Trans. Softw. Eng. 16(9), 1024–1043 (1990). https://doi.org/10.1109/32.58788

    CrossRef  Google Scholar 

  43. Soares, G., Catao, B., Varjao, C., Aguiar, S., Gheyi, R., Massoni, T.: Analyzing refactorings on software repositories. In: Proc. 25th Brazilian Symposium on Software Engineering (SBES), pp. 164–173. IEEE Computer Society, Silver Spring (2011). https://doi.org/10.1109/SBES.2011.21

  44. Soares, G., Gheyi, R., Massoni, T.: Automated behavioral testing of refactoring engines. IEEE Trans. Software Eng. 39(2), 147–162 (2013). https://doi.org/10.1109/TSE.2012.19

    CrossRef  Google Scholar 

  45. Soares, G., Gheyi, R., Serey, D., Massoni, T.: Making program refactoring safer. IEEE Softw. 27(4), 52–57 (2010). https://doi.org/10.1109/MS.2010.63

    CrossRef  Google Scholar 

  46. Srivastava, S., Gulwani, S., Foster, J.S.: From program verification to program synthesis. In: Proc. 37th POPL, pp. 313–326 (2010). https://doi.org/10.1145/1706299.1706337

  47. Steinhöfel, D.: Abstract execution: automatically proving infinitely many programs. Ph.D. Thesis, TU Darmstadt, Dept. of Computer Science, Darmstadt, Germany (2020). https://doi.org/10.25534/tuprints-00008540. http://tuprints.ulb.tu-darmstadt.de/8540/

  48. Steinhöfel, D.: REFINITY to model and prove program transformation rules. In: Oliveira, B.C.D.S. (ed.) Proc. 18th Asian Symposium on Programming Languages and Systems (APLAS). LNCS, vol. 12470. Springer, Berlin (2020). https://doi.org/10.1007/978-3-030-64437-6_16

    Google Scholar 

  49. Steinhöfel, D., Hähnle, R.: Modular, correct compilation with automatic soundness proofs. In: Margaria, T., Steffen, B. (eds.) Proc. 8th ISoLA. LNCS, vol. 11244, pp. 424–447. Springer, Berlin (2018). https://doi.org/10.1007/978-3-030-03418-4_25

    Google Scholar 

  50. Steinhöfel, D., Hähnle, R.: Abstract execution. In: Proc. Third World Congress on Formal Methods—The Next 30 Years (FM) (2019). https://doi.org/10.1007/978-3-030-30942-8_20

  51. Tan, Y.K., Myreen, M.O., Kumar, R., Fox, A., Owens, S., Norrish, M.: A new verified compiler backend for CakeML. In: Proc. 21st ICFP. ACM, New York (2016). https://doi.org/10.1145/2951913.2951924

  52. Vijaya, A., Venkataraman, N.: Modernizing legacy systems: a re-engineering approach. Int. J. Web Portals 10(2), 50–60 (2018). https://doi.org/10.4018/IJWP.2018070104

    CrossRef  Google Scholar 

  53. Winterland, D.: Abstract Execution for Correctness-by-Construction. Master’s thesis, Technische Universität Braunschweig (2020)

    Google Scholar 

Download references

Author information

Authors and Affiliations

  1. CISPA Helmholtz Center for Information Security, Saarbrücken, Germany

    Dominic Steinhöfel

  2. Software Engineering Group, TU Darmstadt, Darmstadt, Germany

    Dominic Steinhöfel

Authors
  1. Dominic Steinhöfel
    View author publications

    You can also search for this author in PubMed Google Scholar

Corresponding author

Correspondence to Dominic Steinhöfel .

Editor information

Editors and Affiliations

  1. Department of Computer Science, University of Innsbruck, Innsbruck, Austria

    Prof. Dr. Michael Felderer

  2. Department of Computer Science, Kiel University, Kiel, Germany

    Prof. Dr. Wilhelm Hasselbring

  3. Corporate Research, ABB, Ladenburg, Germany

    Heiko Koziolek

  4. Institute of Computer Science, Technical University Munich, Garching, Germany

    Prof. Dr. Florian Matthes

  5. Department of Mathematics and Computer Science, Freie Universität Berlin, Berlin, Germany

    Prof. Dr. Lutz Prechelt

  6. Program Structures and Data Organization, Karlsruhe Institute of Technology, Karlsruhe, Germany

    Prof. Dr. Ralf Reussner

  7. Software Engineering, RWTH Aachen University, Aachen, Germany

    Prof. Dr. Bernhard Rumpe

  8. Software Engineering and Automotive Informatics, Technische Universität Braunschweig, Braunschweig, Germany

    Prof. Dr. Ina Schaefer

Rights and permissions

Open Access This chapter is licensed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license and indicate if changes were made.

The images or other third party material in this chapter are included in the chapter's Creative Commons license, unless indicated otherwise in a credit line to the material. If material is not included in the chapter's Creative Commons license and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder.

Reprints and Permissions

Copyright information

© 2022 The Author(s)

About this chapter

Verify currency and authenticity via CrossMark

Cite this chapter

Steinhöfel, D. (2022). Ever Change a Running System: Structured Software Reengineering Using Automatically Proven-Correct Transformation Rules. In: , et al. Ernst Denert Award for Software Engineering 2020. Springer, Cham. https://doi.org/10.1007/978-3-030-83128-8_10

Download citation

  • .RIS
  • .ENW
  • .BIB

  • DOI: https://doi.org/10.1007/978-3-030-83128-8_10

  • Published: 28 February 2022

  • Publisher Name: Springer, Cham

  • Print ISBN: 978-3-030-83127-1

  • Online ISBN: 978-3-030-83128-8

  • eBook Packages: Computer ScienceComputer Science (R0)

Share this chapter

Anyone you share the following link with will be able to read this content:

Sorry, a shareable link is not currently available for this article.

Provided by the Springer Nature SharedIt content-sharing initiative

Over 10 million scientific documents at your fingertips

Switch Edition
  • Academic Edition
  • Corporate Edition
  • Home
  • Impressum
  • Legal information
  • Privacy statement
  • California Privacy Statement
  • How we use cookies
  • Manage cookies/Do not sell my data
  • Accessibility
  • FAQ
  • Contact us
  • Affiliate program

Not affiliated

Springer Nature

© 2023 Springer Nature Switzerland AG. Part of Springer Nature.