Abstract
Change makes software different from any other artifact created by humans. Although this is known since the 1970s, change is still often handled in an ad hoc manner. Agile development and, more recently, DevOps have been proposed as a solution, and success stories are reported from industry. Still, principled and rigorous foundations that can be taught, practiced, and systematically replicated are lacking. We argue that change has to become a first-class concept and that the development tools used by engineers and the run time environment supporting software execution should be structured in a way that naturally accommodates change. We distinguish between evolution and adaptation and discuss how software can be made self-adaptive, and how it can cooperate with humans in-the-loop, supporting continuous verification and assuring dependability. We discuss how several research approaches that were investigated in the past decade may be integrated and extended in a roadmap of future work leading to progress in tool support and automation to achieve dependable adaptation and evolution.
Chapter PDF
Similar content being viewed by others
References
Avizienis, A., Laprie, J.-C., Randell, B., Landwehr, C.: Basic concepts and taxonomy of dependable and secure computing. IEEE Trans. Dependable Secure Comput. 1, 11–33 (2004)
Baresi, L., Ghezzi, C.: The disappearing boundary between development-time and run-time. In: Proceedings of the FSE/SDP Workshop on Future of Software Engineering Research, FoSER ’10, pp. 17–22 (2010)
Baresi, L., Di Nitto, E., Ghezzi, C.: Toward open-world software: issue and challenges. IEEE Comput. 39(12), 36–43 (2006)
Baresi, L., Ghezzi, C., Ma, X., Panzica La Manna, V.: Efficient dynamic updates of distributed components through version consistency. IEEE Trans. Softw. Eng. 43(4), 340–358 (2017)
Bass, L., Weber, I., Zhu, L.: DevOps: A Software Architect’s Perspective. Addison-Wesley Professional, Reading (2015)
Belady, L.A., Lehman, M.M.: A model of large program development. IBM Syst. J. 15(3), 225–252 (1976)
Bianculli, D., Filieri, A., Ghezzi, C., Mandrioli, D.: Incremental syntactic-semantic reliability analysis of evolving structured workflows. In: International Symposium on Leveraging Applications of Formal Methods, Verification and Validation, pp. 41–55 (2014)
Bianculli, D., Filieri, A., Ghezzi, C., Mandrioli, D., Rizzi, A.M.: Syntax-driven program verification of matching logic properties. In: Proceedings of FME Workshop on Formal Methods in Software Engineering (2015)
Blair, G., Bencomo, N., France, R.B.: Models @ run time. IEEE Comput. 42(10), 22–27 (2009)
Calinescu, R., Ghezzi, C., Kwiatkowska, M., Mirandola, R.: Self-adaptive software needs quantitative verification at runtime. Commun. ACM 55(9), 69–77 (2012)
Cheng, B., et al.: Software engineering for self-adaptive systems: a research roadmap. In: Software Engineering for Self-adaptive Systems, pp. 1–26. Springer, Berlin (2009)
Combemale, B., France, R., Jézéquel, J.M., Rumpe, B., Steel, J., Vojtisek, D.: Engineering Modeling Languages: Turning Domain Knowledge into Tools. CRC Press, Boca Raton (2016)
De Lemos, R., et al.: Software engineering for self-adaptive systems: a second research roadmap. In: Software Engineering for Self-adaptive Systems II, pp. 1–32. Springer, Berlin (2013)
Epifani, I., Ghezzi, C., Mirandola, R., Tamburrelli, G.: Model evolution by run-time parameter adaptation. In: IEEE 31st International Conference on Software Engineering, pp. 111–121 (2009)
Filieri, A., Ghezzi, C., Tamburrelli, G.: Run-time efficient probabilistic model checking. In: Proceedings of the 33rd International Conference on Software Engineering, pp. 341–350 (2011)
Filieri, A., Ghezzi, C., Tamburrelli, G.: A formal approach to adaptive software: continuous assurance of non-functional requirements. Form. Asp. Comput. 24(2), 163–186 (2012)
Filieri, A., Tamburrelli, G., Ghezzi, C.: Supporting self-adaptation via quantitative verification and sensitivity analysis at run time. IEEE Trans. Softw. Eng. 42(1), 75–99 (2016)
Ghezzi, C.: Dependability of adaptable and evolvable distributed systems. In: Bernardo, M., De Nicola, R., Hillston, J. (eds.) Formal Methods for the Quantitative Evaluation of Collective Adaptive Systems: 16th International School on Formal Methods for the Design of Computer, Communication, and Software Systems, SFM 2016, Bertinoro, June 20–24, 2016, pp. 36–60. Springer, Berlin (2016)
Ghezzi, C.: Of software and change. J. Softw. Evol. Process 29, 1–14 (2017)
Ghezzi, C., Tamburrelli, G.: Reasoning on non-functional requirements for integrated services. In: Proceedings of 17th IEEE International Requirements Engineering Conference, pp. 69–78 (2009)
Ghezzi, C., Pinto Sales, L., Spoletini, P., Tamburrelli, G.: Managing non-functional uncertainty via model-driven adaptivity. In: Proceedings of the 2013 International Conference on Software Engineering, pp. 33–42 (2013)
Ghezzi, C., Sharifloo Molzam, A., Menghi, C.: Towards agile verification. In: Münch, J., Schmid, K. (eds.) Perspectives on the Future of Software Engineering: Essays in Honor of Dieter Rombach, pp. 31–47. Springer, Berlin (2013)
Ghezzi, C., Panzica La Manna, V., Motta, A., Tamburrelli, G.: Performance-driven dynamic service selection. Concurr. Comput. Pract. Exp. 27(3), 633–650 (2015)
Hallsteinsen, S., Hinchey, M., Sooyong P., Schmid, K.: Dynamic software product lines. IEEE Comput. 41(4), 93–95 (2008)
Kephart, J.O., Chess, D.M.: The vision of autonomic computing. IEEE Comput. 36(1), 41–50 (2003)
Kramer, J., Magee, J.: The evolving philosophers problem: dynamic change management. IEEE Trans. Softw. Eng. 16(11), 1293–1306 (1990)
Lehman, M.M., Belady, L.A.: Program Evolution: Processes of Software Change. Academic Press Professional, Inc., San Diego (1985)
Menghi, C.: Verifying incomplete and evolving specifications. In: Companion Proceedings of the 36th International Conference on Software Engineering, pp. 670–673 (2014)
Menghi, C., Spoletini, P., Ghezzi, C.: Dealing with incompleteness in automata-based model checking. In: FM 2016: Formal Methods - 21st International Symposium, Limassol, November 9–11, 2016, Proceedings, pp. 531–550 (2016)
Meyer, B.: Agile!: The Good, the Hype and the Ugly. Springer Science, Berlin (2014)
Parnas, D.L.: On the criteria to be used in decomposing systems into modules. Commun. ACM 15(12), 1053–1058 (1972)
Parnas, D.L.: On the design and development of program families. IEEE Trans. Softw. Eng. 2(1), 1–9 (1976)
Parnas, D.L.: A rational design process: How and why to fake it. IEEE Trans. Softw. Eng. 12(2), 251–257 (1986)
Parnas, D.L.: Software aging. In: Proceedings of the 16th International Conference on Software Engineering, pp. 279–287 (1994)
Uchitel, S., Alrajeh, D., Ben-David, S., Braberman, V., Chechik, M., De Caso, G., D’Ippolito, N., Fischbein, D., Garbervetsky, D., Kramer, J., Russo, A., Sibay, G.: Supporting incremental behaviour model elaboration. Comput. Sci. Res. Dev. 28(4), 279–293 (2013)
Vandewoude, Y., Ebraert, P., Berbers, Y., D’Hondt, T.: Tranquility: a low disruptive alternative to quiescence for ensuring safe dynamic updates. IEEE Trans. Softw. Eng. 33(12), 856–868 (2007)
Zave, P., Jackson, M.: Four dark corners of requirements engineering. ACM Trans. Softw. Eng. Methodol. 6(1), 1–30 (1997)
Author information
Authors and Affiliations
Corresponding author
Editor information
Editors and Affiliations
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.
Copyright information
© 2018 The Author(s)
About this chapter
Cite this chapter
Ghezzi, C. (2018). Formal Methods and Agile Development: Towards a Happy Marriage. In: Gruhn, V., Striemer, R. (eds) The Essence of Software Engineering. Springer, Cham. https://doi.org/10.1007/978-3-319-73897-0_2
Download citation
DOI: https://doi.org/10.1007/978-3-319-73897-0_2
Published:
Publisher Name: Springer, Cham
Print ISBN: 978-3-319-73896-3
Online ISBN: 978-3-319-73897-0
eBook Packages: Computer ScienceComputer Science (R0)