Skip to main content
SpringerLink
Log in

Software Abstractions and Human-Cyber-Physical Systems Architecture Modelling

  • Chapter
  • First Online:
Engineering Trustworthy Software Systems (SETSS 2019)

Part of the book series: Lecture Notes in Computer Science ((LNPSE,volume 12154))

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.

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

Access this chapter

Log in via an institution
eBook
USD 16.99
Price excludes VAT (USA)
  • Available as EPUB and PDF
  • Read on any device
  • Instant download
  • Own it forever
Softcover Book
USD 16.99
Price excludes VAT (USA)
  • Compact, lightweight 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

Notes

  1. 1.

    The years and features of the methods in the table are not guaranteed to be accurate or comprehensive.

  2. 2.

    In old Chinese shops, the Cashier used to send the bill to an accountant sitting in a glass room doing the calculation.

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

  1. Abrial, J.R.: The B-Book: Assigning Programs to Meanings. Cambridge University Press, Cambridge (1996)

    Book  Google Scholar 

  2. Ambler, S.: The Agile Unified Process (AUP). http://www.ambysoft.com/unifiedprocess/agileUP.html

  3. Back, R.J.: On the correctness of refinement steps in program, development. Ph.D. thesis, University of Helsinki, Finland (1978)

    Google Scholar 

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

    Article  MathSciNet  MATH  Google Scholar 

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

    Article  MATH  Google Scholar 

  6. Bjørner, N.: The Z3 theorem prover. GitHub. https://github.com/Z3Prover/z3

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

    Article  Google Scholar 

  8. Booch, G.: Object-Oriented Analysis and Design with Applications. Addison-Wesley, Boston (1994)

    MATH  Google Scholar 

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

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

    Chapter  Google Scholar 

  11. Brooks, F.P.: The Mythical Man-Month: Essays on Software Engineering. Addison-Wesley, Boston (1975)

    Google Scholar 

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

    Article  Google Scholar 

  13. Brooks, F.P.: The mythical man-month: after 20 years. IEEE Softw. 12(5), 57–60 (1995). https://doi.org/10.5555/624609.625509

    Article  Google Scholar 

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

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

    Article  MathSciNet  MATH  Google Scholar 

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

    Chapter  Google Scholar 

  17. Chandy, K.M., Misra, J.: Parallel Program Design: A Foundation. Addison-Wesley, Reading (1988)

    MATH  Google Scholar 

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

    Article  Google Scholar 

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

    Chapter  MATH  Google Scholar 

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

    Chapter  Google Scholar 

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

    Article  MathSciNet  MATH  Google Scholar 

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

    Chapter  Google Scholar 

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

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

    Google Scholar 

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

    Google Scholar 

  26. Pigott, D.: Online historical encyclopaedia of programming languages (2020). http://hopl.info

  27. de Alfaro, L., Henzinger, T.A.: Interface automata. ACM SIGSOFT Softw. Eng. Notes 26(5) (2001). https://doi.org/10.1145/503271.503226

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

    Article  MATH  Google Scholar 

  29. Dijkstra, E.W.: A Discipline of Programming. Prentice Hall, Upper saddle River (1976)

    MATH  Google Scholar 

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

    Article  Google Scholar 

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

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

    Google Scholar 

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

    Article  Google Scholar 

  34. Goguen, J.A.: Higher-order functions considered unnecessary for higher-order programming. In: Research Topics in Functional Programming. Programming Research Group, Oxford University (1987)

    Google Scholar 

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

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

    Book  MATH  Google Scholar 

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

    Article  Google Scholar 

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

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

    Article  MathSciNet  MATH  Google Scholar 

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

    Chapter  Google Scholar 

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

    Article  MathSciNet  MATH  Google Scholar 

  42. Hoare, C.A.R.: An axiomatic basis for computer programming. Commun. ACM 12(10), 576–580 (1969). https://doi.org/10.1145/363235.363259

    Article  MATH  Google Scholar 

  43. Hoare, C.A.R.: Communicating sequential processes. Commun. ACM 21(8), 666–677 (1978). https://doi.org/10.1145/359576.359585

    Article  MATH  Google Scholar 

  44. Hoare, C.A.R., He, J.: Unifying Theories of Programming. International Series in Computer Science. Prentice Hall, Upper Saddle River (1998)

    MATH  Google Scholar 

  45. IEEE: SWEBOK V3.0: software engineering body of knowledge. IEEE Computer Society (2014). http://www.swebok.org

  46. Jackson, M.A.: Principles of Program Design. Academic, Cambridge (1975)

    Google Scholar 

  47. Jackson, M.: Software Requirements & Specifications: A Lexicon of Practice, Principles and Prejudices. ACM Press/Addison-Wesley Publishing, Boston (1995)

    Google Scholar 

  48. Jackson, M.: Problem Frames: Analysing and Structuring Software Development Problems. Addison-Wesley, Boston (2001)

    Google Scholar 

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

    Chapter  Google Scholar 

  50. Jones, C.B.: Systematic Software Development Using VDM. International Series in Computer Science. Prentice Hall, Upper Saddle River (1990)

    MATH  Google Scholar 

  51. Khaitan, S.K., McCalley, J.D.: Design techniques and applications of cyberphysical systems: a survey. IEEE Syst. J. 9(2), 350–360 (2014)

    Article  Google Scholar 

  52. Kroll, P., Kruchten, P.: The Rational Unified Process Made Easy: A Practitioner’s Guide to the RUP. Addison-Wesley, Boston (2003)

    Google Scholar 

  53. Lamport, L.: The temporal logic of actions. ACM Trans. Program. Lang. Syst. 16(3), 872–923 (1994). https://doi.org/10.1145/177492.177726

    Article  Google Scholar 

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

    Google Scholar 

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

    Chapter  Google Scholar 

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

    Chapter  Google Scholar 

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

    Article  Google Scholar 

  58. Leondes, C.T.: Intelligent Systems: Technology and Applications. CRC Press, Boca Raton (2002)

    Google Scholar 

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

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

    Article  Google Scholar 

  61. Liu, Z.: Software development with UML. Technical report 259, UNU-IIST: International Institute for Software Technology, United Nations University, Macau (2002)

    Google Scholar 

  62. Liu, Z.: Fault-tolerant programming by transformations. Ph.D. thesis, University of Warwick, UK (1991)

    Google Scholar 

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

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

    Chapter  Google Scholar 

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

    Chapter  Google Scholar 

  66. Liu, Z., Joseph, M.: Transformation of programs for fault-tolerance. Formal Aspects Comput. 4(5), 442–469 (1992). https://doi.org/10.1007/BF01211393

    Article  MATH  Google Scholar 

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

    Article  Google Scholar 

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

    Book  Google Scholar 

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

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

    Article  MATH  Google Scholar 

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

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

    Chapter  Google Scholar 

  73. McCarthy, J.: Towards a mathematical science of computation. In: IFIP Congress, pp. 21–28. IFIP (1962)

    Google Scholar 

  74. Mills, H.: Top-down programming in large systems. In: Ruskin, R. (ed.) Debugging Techniques in Large Systems. Prentice Hall, Eaglewood Cliffs (1971)

    Google Scholar 

  75. Milner, R.: A Calculus of Communicating Systems. Springer, Heidelberg (1980). https://doi.org/10.1007/3-540-10235-3

    Book  MATH  Google Scholar 

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

    Google Scholar 

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

    Google Scholar 

  78. NSF: Workshop on cyber-physical systems, Austin, Texas, 16–17 October 2006. https://cps-vo.org/node/179

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

    Article  Google Scholar 

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

    Article  Google Scholar 

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

    Article  Google Scholar 

  82. Paul, C., et al.: Documenting Software Architectures: Views and Beyond, 2nd edn. Addison-Wesley, Boston (2010)

    Google Scholar 

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

    Article  Google Scholar 

  84. Petri, C.A., Reisig, W.: Petri net. Scholarpedia 3(4), 6477 (2008). https://doi.org/10.4249/scholarpedia.6477

    Article  Google Scholar 

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

    Article  MathSciNet  MATH  Google Scholar 

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

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

    Chapter  Google Scholar 

  88. Randell, B.: System structure for software fault tolerance. IEEE Trans. Softw. Eng. 22, 220–232 (1975). https://doi.org/10.1109/TSE.1975.6312842

    Article  Google Scholar 

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

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

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

    Google Scholar 

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

    Book  Google Scholar 

  93. Roscoe, A.W.: Theory and Practice of Concurrency. International Series in Computer Science. Prentice Hall, Upper Saddle River (1997)

    Google Scholar 

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

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

    Article  Google Scholar 

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

    Article  MathSciNet  MATH  Google Scholar 

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

  98. Scott, D., Strachey, C.: Toward a mathematical semantics for computer languages. In: Technical Monograph PRG-6, Programming Research Group, Oxford University (1971)

    Google Scholar 

  99. Sommerville, I.: Software Engineering, 10th edn. Pearson, Upper Saddle River (2016)

    MATH  Google Scholar 

  100. Spivey, J.M.: The Z Notation: A Reference Manual. International Series in Computer Science, 2nd edn. Prentice Hall, Upper Saddle River (1992)

    MATH  Google Scholar 

  101. Stoy, J.E.: Denotational Semantics: The Scott-Strachey Approach to Programming Language Semantics. The MIT Press, Cambridge (1977)

    MATH  Google Scholar 

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

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

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

    MathSciNet  MATH  Google Scholar 

  105. West, D.: Hermeneutic computer science. Commun. ACM 40(4) (1997). https://doi.org/10.1145/248448.248467

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

  107. Wilkes, M.V., Wheeler, D.J., Gill, S.: Preparation of Programs for an Electronic Digital Computer. Addison-Wesley, Boston (1951)

    MATH  Google Scholar 

  108. Wirth, N.: Program development by stepwise refinement. Commun. ACM 14(4), 221–227 (1971). https://doi.org/10.1145/362575.362577

    Article  MATH  Google Scholar 

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

    Article  Google Scholar 

Download references

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

  1. RISE – Centre for Research and Innovation in Software Engineering, Southwest University, Chongqing, China

    Zhiming Liu, Jonathan P. Bowen, Bo Liu, Shmuel Tyszberowicz & Tingting Zhang

  2. School of Engineering, London South Bank University, London, UK

    Jonathan P. Bowen

  3. Afeka Academic College of Engineering, Tel Aviv, Israel

    Shmuel Tyszberowicz

Authors
  1. Zhiming Liu
    View author publications

    You can also search for this author in PubMed Google Scholar

  2. Jonathan P. Bowen
    View author publications

    You can also search for this author in PubMed Google Scholar

  3. Bo Liu
    View author publications

    You can also search for this author in PubMed Google Scholar

  4. Shmuel Tyszberowicz
    View author publications

    You can also search for this author in PubMed Google Scholar

  5. Tingting Zhang
    View author publications

    You can also search for this author in PubMed Google Scholar

Corresponding author

Correspondence to Jonathan P. Bowen .

Editor information

Editors and Affiliations

  1. Southwest University, Chongqing, China

    Jonathan P. Bowen

  2. Southwest University, Chongqing, China

    Zhiming Liu

  3. Southwest University, Chongqing, China

    Zili Zhang

Rights and permissions

Reprints and permissions

Copyright information

© 2020 Springer Nature Switzerland AG

About this chapter

Check for updates. Verify currency and authenticity via CrossMark

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)

Publish with us

Policies and ethics

Search

Navigation