Abstract
It is over fifty years since the subject discipline of software engineering and more than forty years from when the area of formal methods have been established. During this period, the academic community has accomplished extensive research in foundations and methods of software engineering, as well as developing and teaching a large body of software engineering knowledge and techniques. At the same time, the IT industry has produced larger, more complex, and better (in many aspects) software systems. Yet, these large projects are largely developed using a trial and error approach, without systematic use of the developed software engineering methods and tools. The cost of these projects is high, the percentage of project delay and cancellation is significant, and the dependability of the systems is low in many requirements. The most serious problem of this ad hoc development approach is that the development process is not repeatable and the systems developed are not well evolvable. This problem is particularly crucial for the design and implementation of modern networked distributed software systems, known as Human-Cyber-Physical Systems (HCPS).
In this tutorial paper, we reflect the development of software engineering through software abstractions and show that these abstractions are integral in the notion of software system architectures. We discuss the importance of architecture modelling and argue for a seamless combination of informal and formal activities in the modelling and design of the architecture. A point that we make is that it is important to engineer systems using formal methods in relation to the definition and management of development processes, and how a model of the software architecture, with rich semantics and refinement relations, plays an important role in this process. We consider development of two typical types of software components and use examples to discuss the traditional processes for their domain modelling and software requirements modelling. We then propose to combine these modelling approaches and this naturally leads to a unified modelling process for HCPS architecture modelling, design, and evolution. Based on the unified processes, we outline a framework in engineering formal methods for HCPS modelling, including the mapping of the system architecture to the technology architecture and organization of the development team with the expertise required, and decide the appropriate formal methods and tools to be used.
Access this chapter
Tax calculation will be finalised at checkout
Purchases are for personal use only
Notes
- 1.
The years and features of the methods in the table are not guaranteed to be accurate or comprehensive.
- 2.
In old Chinese shops, the Cashier used to send the bill to an accountant sitting in a glass room doing the calculation.
- 3.
The word “software” is not meant to be a restriction but in this paper we consider these ideas only within the context of software. Also, the lack of a formal definition for “conceptual integrity” has made it hard to apply this idea systematically and to understand it with better insight.
References
Abrial, J.R.: The B-Book: Assigning Programs to Meanings. Cambridge University Press, Cambridge (1996)
Ambler, S.: The Agile Unified Process (AUP). http://www.ambysoft.com/unifiedprocess/agileUP.html
Back, R.J.: On the correctness of refinement steps in program, development. Ph.D. thesis, University of Helsinki, Finland (1978)
Bergstra, J.A., Tucker, V.J.: Expressiveness and the completeness of Hoare’s logic. J. Comput. Syst. Sci. 25(3), 267–284 (1982). https://doi.org/10.1016/0022-0000(82)90013-7
Berry, G., Gonthier, G.: The Esterel synchronous programming language: design, semantics, implementation. Sci. Comput. Program. 19(2), 87–152 (1992). https://doi.org/10.1016/0167-6423(92)90005-V
Bjørner, N.: The Z3 theorem prover. GitHub. https://github.com/Z3Prover/z3
Boehm, B.W.: A spiral model of software development and enhancement. IEEE Comput. 21(5), 61–72 (1988). https://doi.org/10.1109/2.59
Booch, G.: Object-Oriented Analysis and Design with Applications. Addison-Wesley, Boston (1994)
Bowen, J.P.: The Z notation: whence the cause and whither the course? In: Liu, Zhang [68], pp. 103–151. https://doi.org/10.1007/978-3-319-29628-9_3
Bowen, J.P., Hinchey, M.G.: Formal methods. In: Gonzalez, T.F., Díaz-Herrera, J., Tucker, A.B. (eds.) Computing Handbook. Computer Science and Software Engineering, 3rd edn., pp. 1–25. Chapman and Hall/CRC Press, Boca Raton (2014). https://doi.org/10.1201/b16812. Section XI, Software Engineering, Part 8, Programming Languages
Brooks, F.P.: The Mythical Man-Month: Essays on Software Engineering. Addison-Wesley, Boston (1975)
Brooks, F.P.: No silver bullet: essence and accidents of software engineering. IEEE Comput. 20(4), 10–19 (1987). https://doi.org/10.1109/MC.1987.1663532
Brooks, F.P.: The mythical man-month: after 20 years. IEEE Softw. 12(5), 57–60 (1995). https://doi.org/10.5555/624609.625509
Brooks, F.P.: Learn the hard way - a history 1845–1980 of software engineering. In: Keynote at 40th International Conference on Software Engineering (ICSE), Gothenburg, Sweden (2018). https://www.icse2018.org/info/keynotes
Broy, M., Stefanescu, G.: The algebra of stream processing functions. Theoret. Comput. Sci. 258(1–2), 99–129 (2001). https://doi.org/10.1016/S0304-3975(99)00322-9
Broy, M., Wirsing, M.: On the algebraic extensions of abstract data types. In: Díaz, J., Ramos, I. (eds.) ICFPC 1981. LNCS, vol. 107, pp. 244–251. Springer, Heidelberg (1981). https://doi.org/10.1007/3-540-10699-5_101
Chandy, K.M., Misra, J.: Parallel Program Design: A Foundation. Addison-Wesley, Reading (1988)
Chen, L., Babar, M.A., Nuseibeh, B.: Characterizing architecturally significant requirements. IEEE Softw. 30(2), 38–45 (2013). https://doi.org/10.1109/MS.2012.174
Chen, X., Liu, Z., Mencl, V.: Separation of concerns and consistent integration in requirements modelling. In: van Leeuwen, J., Italiano, G.F., van der Hoek, W., Meinel, C., Sack, H., Plášil, F. (eds.) SOFSEM 2007. LNCS, vol. 4362, pp. 819–831. Springer, Heidelberg (2007). https://doi.org/10.1007/978-3-540-69507-3_71
Chen, Z., et al.: Modelling with relational calculus of object and component systems - rCOS. In: Rausch, A., Reussner, R., Mirandola, R., Plášil, F. (eds.) The Common Component Modeling Example. LNCS, vol. 5153, pp. 116–145. Springer, Heidelberg (2008). https://doi.org/10.1007/978-3-540-85289-6_6
Chen, Z., Liu, Z., Ravn, A.P., Stolz, V., Zhan, N.: Refinement and verification in component-based model driven design. Sci. Comput. Program. 74(4), 168–196 (2009). https://doi.org/10.1016/j.scico.2008.08.003
Clarke, E.M., Emerson, E.A.: Design and synthesis of synchronization skeletons using branching time temporal logic. In: Kozen, D. (ed.) Logic of Programs 1981. LNCS, vol. 131, pp. 52–71. Springer, Heidelberg (1982). https://doi.org/10.1007/BFb0025774
Codd, E.F., Lowry, E.S., McDonough, E., Scalzi, C.A.: Multiprogramming STRECH: feasibility consideration. Commun. ACM 2(11) (1959). https://doi.org/10.1145/368481.368502
Collette, P., Jones, C.B.: Enhancing the tractability of rely/guarantee specifications in the development of interfering operations. In: Plotkin, G.D., Stirling, C.P., Tofte, M. (eds.) Proof, Language, and Interaction: Essays in Honour of Robin Milner, pp. 277–308. The MIT Press, Cambridge (2000)
Cousot, P., Cousot, R.: Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints. In: Proceedings of Fourth ACM Symposium on Principles of Programming Languages, pp. 238–252. ACM Press, Los Angeles (1977)
Pigott, D.: Online historical encyclopaedia of programming languages (2020). http://hopl.info
de Alfaro, L., Henzinger, T.A.: Interface automata. ACM SIGSOFT Softw. Eng. Notes 26(5) (2001). https://doi.org/10.1145/503271.503226
Dijkstra, E.: Guarded commands, non-determinacy and formal derivation of programs. Commun. ACM 18(8), 453–457 (1975). https://doi.org/10.1145/360933.360975
Dijkstra, E.W.: A Discipline of Programming. Prentice Hall, Upper saddle River (1976)
Dijkstra, E.W.: The humble programmer. Commun. ACM 15(10), 859–866 (1972). https://doi.org/10.1145/355604.361591. An ACM Turing Award lecture
Floyd, R.W.: Assigning meanings to programs. In: Schwartz, J.T. (ed.) Mathematical Aspects of Computer Science. Proceedings of Symposium on Applied Mathematics, vol. 19, pp. 19–32. American Mathematical Society (1967). https://doi.org/10.1007/978-94-011-1793-7_4. Republished in Program Verification (1993)
Forsberg, K., Mooz, H.: The relationship of system engineering to the project cycle. In: Proceedings of the First Annual Symposium of National Council on System Engineering, pp. 57–65, October 1991
Giloi, W.K.: Konrad Zuse’s Plankalkül: the first high-level, “non von Neumann” programming language. IEEE Ann. Hist. Comput. 19, 17–24 (1997). https://doi.org/10.1109/85.586068
Goguen, J.A.: Higher-order functions considered unnecessary for higher-order programming. In: Research Topics in Functional Programming. Programming Research Group, Oxford University (1987)
Grattarola, F.: Margaret Hamilton - coding to the moon. In: A Computer of One’s Own, December 2018. https://medium.com/a-computer-of-ones-own/margaret-hamilton-coding-to-the-moon-6ba70b7e6b43
Guttag, J.V., Horning, J.J.: Larch: Languages and Tools for Formal Specification. Springer, New York (1993). https://doi.org/10.1007/978-1-4612-2704-5
Halbwachs, N., Caspi, P., Raymond, P., Pilanud, D.: The synchronous data flow programming language LUSTRE. Proc. IEEE 79(9), 1305–1320 (1991). https://doi.org/10.1109/5.97300
Hamilton, M.H.: The language as a software engineer. In: keynote at 40th International Conference on Software Engineering (ICSE), Gothenburg, Sweden (2018). https://www.icse2018.org/info/keynotes
Harel, D.: Statecharts: a visual formalism for complex systems. Sci. Comput. Program. 8(3), 231–274 (1987). https://doi.org/10.1016/0167-6423(87)90035-9
He, J., Li, X., Liu, Z.: Component-based software engineering. In: Hung, D.V., Wirsing, M. (eds.) Theoretical Aspects of Computing. LNCS, vol. 3722, pp. 70–95. Springer, Hanoi (2005). https://doi.org/10.1007/11560647_5. UNU-IIST TR 330
He, J., Liu, Z., Li, X.: rCOS: a refinement calculus of object systems. Theoret. Comput. Sci. 365(1–2), 109–142 (2006). https://doi.org/10.1016/j.tcs.2006.07.034
Hoare, C.A.R.: An axiomatic basis for computer programming. Commun. ACM 12(10), 576–580 (1969). https://doi.org/10.1145/363235.363259
Hoare, C.A.R.: Communicating sequential processes. Commun. ACM 21(8), 666–677 (1978). https://doi.org/10.1145/359576.359585
Hoare, C.A.R., He, J.: Unifying Theories of Programming. International Series in Computer Science. Prentice Hall, Upper Saddle River (1998)
IEEE: SWEBOK V3.0: software engineering body of knowledge. IEEE Computer Society (2014). http://www.swebok.org
Jackson, M.A.: Principles of Program Design. Academic, Cambridge (1975)
Jackson, M.: Software Requirements & Specifications: A Lexicon of Practice, Principles and Prejudices. ACM Press/Addison-Wesley Publishing, Boston (1995)
Jackson, M.: Problem Frames: Analysing and Structuring Software Development Problems. Addison-Wesley, Boston (2001)
Jiang, Z., Pajic, M., Moarref, S., Alur, R., Mangharam, R.: Modeling and verification of a dual chamber implantable pacemaker. In: Flanagan, C., König, B. (eds.) TACAS 2012. LNCS, vol. 7214, pp. 188–203. Springer, Heidelberg (2012). https://doi.org/10.1007/978-3-642-28756-5_14
Jones, C.B.: Systematic Software Development Using VDM. International Series in Computer Science. Prentice Hall, Upper Saddle River (1990)
Khaitan, S.K., McCalley, J.D.: Design techniques and applications of cyberphysical systems: a survey. IEEE Syst. J. 9(2), 350–360 (2014)
Kroll, P., Kruchten, P.: The Rational Unified Process Made Easy: A Practitioner’s Guide to the RUP. Addison-Wesley, Boston (2003)
Lamport, L.: The temporal logic of actions. ACM Trans. Program. Lang. Syst. 16(3), 872–923 (1994). https://doi.org/10.1145/177492.177726
Larman, C.: Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process, 2nd edn. Prentice Hall, Upper Saddle River (2001)
Laxsen, K.G., Pettersson, P., Yi, W.: Diagnostic model-checking for real-time systems. In: Alur, R., Henzinger, T.A., Sontag, E.D. (eds.) HS 1995. LNCS, vol. 1066, pp. 575–586. Springer, Heidelberg (1996). https://doi.org/10.1007/BFb0020977
Leavens, G.T., Baker, A.L.: Enhancing the pre- and postcondition technique for more expressive specifications. In: Wing, J.M., Woodcock, J., Davies, J. (eds.) FM 1999. LNCS, vol. 1709, pp. 1087–1106. Springer, Heidelberg (1999). https://doi.org/10.1007/3-540-48118-4_8
Lee, E.A.: The past, present and future of cyber-physical systems: a focus on models. Sensors 1(3), 4837–4869 (2015). https://doi.org/10.3390/s150304837
Leondes, C.T.: Intelligent Systems: Technology and Applications. CRC Press, Boca Raton (2002)
Lindsey, C.H., Boom, H.J.: A modules and separate compilation facility for ALGOL 68. ALGOL Bull. 43 (1978). https://doi.org/10.5555/1061719.1061724
Liskov, B., Zilles, S.: Programming with abstract data types. SIGPLAN Not. 9, 50–59 (1974). https://doi.org/10.1145/942572.807045. In: Proceedings of the ACM SIGPLAN Symposium on Very High Level Languages
Liu, Z.: Software development with UML. Technical report 259, UNU-IIST: International Institute for Software Technology, United Nations University, Macau (2002)
Liu, Z.: Fault-tolerant programming by transformations. Ph.D. thesis, University of Warwick, UK (1991)
Liu, Z., Chen, X.: Model-driven design of object and component systems. In: Liu, Zhang [68], pp. 152–255. https://doi.org/10.1007/978-3-319-29628-9_4
Liu, Z., Jifeng, H., Li, X.: rCOS: refinement of component and object systems. In: de Boer, F.S., Bonsangue, M.M., Graf, S., de Roever, W.-P. (eds.) FMCO 2004. LNCS, vol. 3657, pp. 183–221. Springer, Heidelberg (2005). https://doi.org/10.1007/11561163_9
Liu, Z., Jifeng, H., Li, X., Chen, Y.: A relational model for formal object-oriented requirement analysis in UML. In: Dong, J.S., Woodcock, J. (eds.) ICFEM 2003. LNCS, vol. 2885, pp. 641–664. Springer, Heidelberg (2003). https://doi.org/10.1007/978-3-540-39893-6_36
Liu, Z., Joseph, M.: Transformation of programs for fault-tolerance. Formal Aspects Comput. 4(5), 442–469 (1992). https://doi.org/10.1007/BF01211393
Liu, Z., Joseph, M.: Specification and verification of fault-tolerance, timing, and scheduling. ACM Trans. Program. Lang. Syst. 21(1), 46–89 (1999). https://doi.org/10.1145/314602.314605
Liu, Z., Zhang, Z. (eds.): Engineering Trustworthy Software Systems. LNCS, vol. 9506. Springer, Cham (2016). https://doi.org/10.1007/978-3-319-29628-9
Lynch, N.A., Tuttle, M.R.: Hierarchical correctness proofs for distributed algorithms. In: Proceedings of the Sixth Annual ACM Symposium on Principles of Distributed Computing (PODC 1987), pp. 137–151, August 1987. https://doi.org/10.1145/41840.41852
Manna, Z., Waldinger, R.: A deductive approach to program synthesis. ACM Trans. Program. Lang. Syst. 2, 90–121 (1980). https://doi.org/10.1145/357084.357090
Manyika, J.: Big data: the next frontier for innovation, competition, and productivity (2011). http://www.mckinsey.com/insights/business_technology/big_data_the_next_frontier_for_innovation
Mauchly, J.W.: Preparation of problems for EDVAC-type machines (1947). In: Randell, B. (ed.) The Origins of Digital Computers. MCS. Springer, Heidelberg (1982). https://doi.org/10.1007/978-3-642-61812-3_31
McCarthy, J.: Towards a mathematical science of computation. In: IFIP Congress, pp. 21–28. IFIP (1962)
Mills, H.: Top-down programming in large systems. In: Ruskin, R. (ed.) Debugging Techniques in Large Systems. Prentice Hall, Eaglewood Cliffs (1971)
Milner, R.: A Calculus of Communicating Systems. Springer, Heidelberg (1980). https://doi.org/10.1007/3-540-10235-3
Murray, D., Fraser, K.: Xen and the beauty of virtualization. In: Spinellis, D., Gousios, G. (eds.) Beautiful Architecture: Leading Thinkers Reveal the Hidden Beauty in Software Design, p. 172. O’Reilly Media, Newton (2009)
Naur, P., Randell, B. (eds.): Software Engineering: Report of a Conference Sponsored by the NATO Science Committee, Garmisch, Germany, 7–11 October 1968, Brussels, Scientific Affairs Division, NATO. NATO, January 1969
NSF: Workshop on cyber-physical systems, Austin, Texas, 16–17 October 2006. https://cps-vo.org/node/179
Nygaard, K., Dahl, O.J.: The development of the SIMULA languages. ACM SIGPLAN Not. 13(8), 439–480 (1978). https://doi.org/10.1145/960118.808391
Parnas, D.L.: On the criteria to be used in decomposing systems into modules. Commun. ACM 15(12), 1053–1058 (1972). https://doi.org/10.1145/361598.361623
Parnas, D.L., Madey, J.: Functional decomposition for computer systems. Sci. Comput. Program. 25(1), 41–61 (1995). https://doi.org/10.1016/0167-6423(95)96871-J
Paul, C., et al.: Documenting Software Architectures: Views and Beyond, 2nd edn. Addison-Wesley, Boston (2010)
Perry, D.E., Wolf, A.L.: Foundations for the study of software architecture. ACM SIGSOFT Softw. Eng. Notes 17(4), 40–52 (1992). https://doi.org/10.1145/141874.141884
Petri, C.A., Reisig, W.: Petri net. Scholarpedia 3(4), 6477 (2008). https://doi.org/10.4249/scholarpedia.6477
Plotkin, G.D.: The origins of structural operational semantics. J. Logic Algebraic Program. 60–61, 3–15 (2004). https://doi.org/10.1016/j.jlap.2004.03.009
Pnueli, A.: The temporal logic of programs. In: Proceedings of the 18th Annual Symposium on Foundations of Computer Science SFCS 1977, pp. 46–57. IEEE, September 1977. https://doi.org/10.1109/SFCS.1977.32
Queille, J.P., Sifakis, J.: Specification and verification of concurrent systems in CESAR. In: Dezani-Ciancaglini, M., Montanari, U. (eds.) Programming 1982. LNCS, vol. 137, pp. 337–351. Springer, Heidelberg (1982). https://doi.org/10.1007/3-540-11494-7_22
Randell, B.: System structure for software fault tolerance. IEEE Trans. Softw. Eng. 22, 220–232 (1975). https://doi.org/10.1109/TSE.1975.6312842
Randell, B.: Position statement: how far have we come? In: Proceedings of the 32nd Annual IEEE International Computer Software and Applications Conference, COMPSAC 2008, 28 July–1 August 2008, Turku, Finland, p. 8. IEEE, IEEE Computer Society (2008). https://doi.org/10.1109/COMPSAC.2008.233
Randell, B.: Fifty years of software engineering or the view from Garmisch. In: Keynote at 40th International Conference on Software Engineering (ICSE), Gothenburg, Sweden (2018). https://www.icse2018.org/info/keynotes
Randell, B., Buxton, J.N. (eds.): Software engineering: report of a conference sponsored by the NATO science committee, Rome, Italy, 27–31 October 1969, Brussels, Scientific Affairs Division, NATO. NATO (1969)
Rausch, A., Reussner, R., Mirandola, R., Plás̆il, F. (eds.): The Common Component Modeling Example. LNCS, vol. 5153. Springer, Heidelberg (2008). https://doi.org/10.1007/978-3-540-85289-6
Roscoe, A.W.: Theory and Practice of Concurrency. International Series in Computer Science. Prentice Hall, Upper Saddle River (1997)
Royce, W.W.: Managing the development of large software systems. In: Proceedings of IEEE WESCON, pp. 1–9. IEEE (1970). https://doi.org/10.5555/41765.41801. Reprinted in ICSE (1987)
Ryckman, G.F.: 17. The IBM 701 computer at the general motors research laboratories. Ann. History Comput. 5(12), 210–212 (1983). https://doi.org/10.1109/MAHC.1983.10026
Sangiovanni-Vincentelli, A., Damm, W., Passerone, R.: Taming Dr. Frankenstein: contract-based design for cyber-physical systems. Eur. J. Control 18(3), 217–238 (2012). https://doi.org/10.3166/ejc.18.217-238
Schlingloff, B.H.: Cyber-physical systems engineering. In: Liu, Zhang [68], pp. 256–289. https://doi.org/10.1007/978-3-319-29628-9_5
Scott, D., Strachey, C.: Toward a mathematical semantics for computer languages. In: Technical Monograph PRG-6, Programming Research Group, Oxford University (1971)
Sommerville, I.: Software Engineering, 10th edn. Pearson, Upper Saddle River (2016)
Spivey, J.M.: The Z Notation: A Reference Manual. International Series in Computer Science, 2nd edn. Prentice Hall, Upper Saddle River (1992)
Stoy, J.E.: Denotational Semantics: The Scott-Strachey Approach to Programming Language Semantics. The MIT Press, Cambridge (1977)
Turing, A.M.: Checking a large routine. In: Report of a Conference on High Speed Automatic Calculating Machines, pp. 67–69. Cambridge University Mathematical Laboratory (1949). https://doi.org/10.5555/94938.94952. Reprinted in The Early British Computer Conferences (1989)
von Neumann, J.: Introduction to “the first draft report on the edvac”. Archive.org. (1945). https://web.archive.org/web/20130314123032/http://qss.stanford.edu/~godfrey/vonNeumann/vnedvac.pdf
Wang, J., Zhan, N., Feng, X., Liu, Z.: Overview of formal methods. Ruan Jian Xue Bao/J. Softw. 30(1), 33–61 (2019). (in Chinese)
West, D.: Hermeneutic computer science. Commun. ACM 40(4) (1997). https://doi.org/10.1145/248448.248467
Wheeler, D.J.: The use of sub-routines in programmes. In: Proceedings of the 1952 ACM National Meeting, p. 235. ACM, Pittsburgh, USA (1952). https://doi.org/10.1145/609784.609816
Wilkes, M.V., Wheeler, D.J., Gill, S.: Preparation of Programs for an Electronic Digital Computer. Addison-Wesley, Boston (1951)
Wirth, N.: Program development by stepwise refinement. Commun. ACM 14(4), 221–227 (1971). https://doi.org/10.1145/362575.362577
Woodcock, J., Larsen, P.G., Bicarregui, J., Fitzgerald, J.: Formal methods: practive and experience. ACM Comput. Surv. 41(4), 19:1–19:36 (2009). https://doi.org/10.1145/1592434.1592436
Acknowledgements
Thank you for project support by the National Natural Science Foundation of China (61802318, 61732019, 61672435, 61811530327), the Capacity Development Grant of Southwest University (SWU116007), and the Natural Science Foundation of Chongqing (cstc2017jcyjAX0295). Thank you to Museophile Limited for financial support for Jonathan Bowen.
Author information
Authors and Affiliations
Corresponding author
Editor information
Editors and Affiliations
Rights and permissions
Copyright information
© 2020 Springer Nature Switzerland AG
About this chapter
Cite this chapter
Liu, Z., Bowen, J.P., Liu, B., Tyszberowicz, S., Zhang, T. (2020). Software Abstractions and Human-Cyber-Physical Systems Architecture Modelling. In: Bowen, J., Liu, Z., Zhang, Z. (eds) Engineering Trustworthy Software Systems. SETSS 2019. Lecture Notes in Computer Science(), vol 12154. Springer, Cham. https://doi.org/10.1007/978-3-030-55089-9_5
Download citation
DOI: https://doi.org/10.1007/978-3-030-55089-9_5
Published:
Publisher Name: Springer, Cham
Print ISBN: 978-3-030-55088-2
Online ISBN: 978-3-030-55089-9
eBook Packages: Computer ScienceComputer Science (R0)