Skip to main content
SpringerLink
Log in

Deconstructing the semantics of big-step modelling languages

  • RE'09 Special Issue
  • Published:
Requirements Engineering Aims and scope Submit manuscript

Abstract

With the popularity of model-driven methodologies and the abundance of modelling languages, a major question for a requirements engineer is: which language is suitable for modelling a system under study? We address this question from a semantic point-of-view for big-step modelling languages (BSMLs). BSMLs are a class of popular behavioural modelling languages in which a model can respond to an input by executing multiple transitions, possibly concurrently. We deconstruct the operational semantics of a large class of BSMLs into eight high-level, mostly orthogonal semantic aspects and their common semantic options. We analyse the characteristics of each semantic option. We use feature diagrams to present the design space of BSML semantics that arises from our deconstruction, as well as to taxonomize the syntactic features of BSMLs that exhibit semantic variations. We enumerate the dependencies between syntactic and semantic features. We also discuss the effects of certain combinations of semantic options when used together in a BSML semantics. Our goal is to empower a requirements engineer to compare and choose an appropriate BSML from the plethora of existing BSMLs, or to articulate the semantic features of a new desired BSML when such a BSML does not exist.

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

Access this article

Log in via an institution

Price excludes VAT (USA)
Tax calculation will be finalised during checkout.

Instant access to the full article PDF.

Institutional subscriptions

Fig. 1
Fig. 2
Fig. 3
Fig. 4
Fig. 5
Fig. 6
Fig. 7
Fig. 8
Fig. 9
Fig. 10
Fig. 11
Fig. 12
Fig. 13
Fig. 14
Fig. 15
Fig. 16
Fig. 17
Fig. 18
Fig. 19
Fig. 20
Fig. 21
Fig. 22

Similar content being viewed by others

Notes

  1. Big steps and small steps are often called macro steps and micro steps, respectively. We adopt new terms to avoid association with the fixed semantics of the languages that use those terms. The big-step/small-step terminology has been used in the study of the operational semantics of programming languages in a similar spirit as we use them here [40].

  2. We have adopted the term “helpful environment” from a similar notion in Interface Automata [11].

  3. This example is adopted from [33], where a more elaborate version of it is used as the running example of the paper.

  4. This example is adopted from [27].

  5. In Esterel [1], the value parameter of an event can be of type array, which means that, in effect, an event can have more than one value parameter, each of which being an element of a single array.

  6. As shown in Table 6, in SCR [22, 23], both the GC Big Step and GC Small Step memory protocols are used, but in different syntactic constructs of the language, namely in the “event tables” and “condition tables”, respectively.

  7. It is possible to define a non-total new_small operator that returns a value for a variable, only if it is assigned a value in the current small step. Such an operator would be in the spirit of the “next” operator in SMV language [34], which is an input language for a family of model checkers with the same name. However in the semantics of SMV, unlike in BSMLs, even if a variable is not assigned a value during a small step, it is assigned a non-deterministic value, which, in effect, makes the “next” operator a total operator.

  8. Internal variables are often called “private variables”. We use the term “internal variables” to keep the terminology of variables consistent with that for events.

  9. In SCR [22, 23], the RHS Small Step assignment memory protocol is used together with a combination of the GC Big Step and GC Small Step enabledness memory protocols.

  10. The GC Strong Synchronous Variable and RHS Strong Synchronous Variable semantic options for interface variables, described in Sects. 3.4.2 and 3.5.1, respectively, can also introduce dataflow orders.

  11. As pointed out by one of our reviewers, choosing the Take Many big-step maximality semantics, the Many concurrency semantics, the Present in Next Combo Step event lifeline semantics (or the Present in Remainder event lifeline semantics), and the RHS Small Step assignment memory protocol, also yields the correct behaviour. While such an equivalence of behaviours holds for some models, it does not always hold. For example, if there is a possibility for race conditions (e.g., in Example 20) or if it is important whether a model can reach certain configuration of control states or not, then it is not possible to replace the Single concurrency semantics with the Many concurrency semantics.

  12. This example is inspired by the motivating example in [2], where sequence diagrams are used for modelling an aspect of the operation of a nuclear power plant.

References

  1. The Esterel v7 reference manual version v7.30, initial IEEE standardization proposal (2005)

  2. Alur R, Etessami K, Yannakakis M (2003) Inference of message sequence charts. IEEE Trans Softw Eng 29(7):623–633

    Article  Google Scholar 

  3. Alur R, Henzinger TA (1999) Reactive modules. Form Method Syst Des 15(1):7–48

    Article  MathSciNet  Google Scholar 

  4. Berry G (1992) A hardware implementation of pure Esterel. Sadhana Acad Proc Eng Sci Indian Acad Sci 17(1):95–130

    Google Scholar 

  5. Berry G (1993) Preemption in concurrent systems. In: Foundations of software technology and theoretical computer science, vol 761 of LNCS. Springer, pp 72–93

  6. Berry G, Gonthier G (1992) The Esterel synchronous programming language: design, semantics, implementation. Sci Comp Programm 19(2):87–152

    Article  MATH  Google Scholar 

  7. Boussinot F (1998) Sugarcubes implementation of causality. Technical Report RR-3487, Inria, Institut National de Recherche en Informatique et en Automatique

  8. Chapiro DM (1984) Globally-asynchronous locally-synchronous systems. PhD thesis, Stanford University

  9. Dabney J, Harman TL (2004) Mastering simulink. Pearson Prentice Hall, New Jersey

    Google Scholar 

  10. Day N (1993) A model checker for statecharts: linking CASE tools with formal methods. Master’s thesis, University of British Columbia

  11. de Alfaro L, Henzinger TA (2001) Interface automata. In: Proceedings of the joint 8th European software engineering conference and 9th ACM SIGSOFT symposium on the foundation of software engineering (ESEC/FSE-01), Software engineering notes, vol 26. ACM Press, pp 109–120

  12. Esmaeilsabzali S, Day NA (2010) Prescriptive semantics for big-step modelling languages. In: Fundamental approaches to software engineering, volume 6013 of LNCS. Springer, pp 158–172

  13. Esmaeilsabzali S, Day NA, Atlee JM, Niu J (2009) Big-step semantics. Technical Report CS-2009-05, University of Waterloo, Cheriton School of Computer Science

  14. Esmaeilsabzali S, Day NA, Atlee JM, Niu J (2009) Semantic criteria for choosing a language for big-step models. In: 17th IEEE international requirements engineering conference. IEEE Computer Society Press, pp 181–190

  15. Fidge C (1994) A comparative introduction to CSP, CCS and LOTOS. Technical Report 93-24, The university of Queensland, Department of Computer Science

  16. Halbwachs Nicolas (1993) Synchronous programming of reactive systems. Kluwer, Dordrecht

    MATH  Google Scholar 

  17. Harel D (1987) Statecharts: a visual formalism for complex systems. Sci Comp Programm 8(3):231–274

    Article  MATH  MathSciNet  Google Scholar 

  18. Harel D, Kugler H (2004) The RHAPSODY semantics of statecharts (or, on the executable core of the UML). In: Integration of software specification techniques for application in engineering, volume 3147 of LNCS. Springer, pp 325–354

  19. Harel D, Naamad A (1996) The STATEMATE semantics of statecharts. ACM Trans Softw Eng Methodol 5(4):293–333

    Article  Google Scholar 

  20. Harel D, Pnueli A (1985) On the development of reactive systems. In: Logics and models of concurrent systems. Springer

  21. Harel D, Pnueli A, Schmidt JP, Sherman R (1987) On the formal semantics of statecharts. In: IEEE symposium on logic in computation. pp 54–64

  22. Heitmeyer CL, Jeffords RD, Labaw BG (1996) Automated consistency checking of requirements specifications. ACM Trans Softw Eng Methodol 5(3):231–261

    Article  Google Scholar 

  23. Heninger KL, Kallander JW, Parnas DL, Shore JE (1978) Software requirements for the A-7E aircraft. Technical Report 3876, United States Naval Research Laboratory

  24. Hoare T (1985) Communicating sequential processes. Prentice Hall, New Jersey

    MATH  Google Scholar 

  25. Hoare T, Jifeng H (1998) Unifying theories of programming. Prentice Hall, New Jersey

    Google Scholar 

  26. Huizing C, Gerth R (1992) Semantics of reactive systems in abstract time. In: REX Workshop, volume 600 of LNCS. Springer, pp 291–314

  27. i Logix Inc (1991) Statemate 4.0 analyzer user and reference manual

  28. Kang KC, Cohen SG, Hess JA, Novak WE, Peterson AS (1990) Feature-oriented domain analysis (FODA) feasibility study. Technical Report CMU/SEI-90-TR-21, SEI, Carnegie Mellon University

  29. Lamport L, Schneider FB (1989) Pretending atomicity. Technical Report 44, Digital Equipment Corporation

  30. Leveson NG, Heimdahl MPE, Hildreth H, Reese JD (1994) Requirements specification for process-control systems. IEEE Trans Softw Eng 20(9):684–707

    Article  Google Scholar 

  31. Lipton RJ (1975) Reduction: a method of proving properties of parallel programs. Commun ACM 18:717–721

    Article  MATH  MathSciNet  Google Scholar 

  32. Maggiolo-Schettini A, Peron A, Tini S (1996) Equivalences of statecharts. In: International concurrency theory conference, volume 1119 of LNCS. Springer, pp 687–702

  33. Maraninchi F, Rémond Y (2001) Argos: an automaton-based synchronous language. Comp Lang 27(1/3):61–92

    Article  MATH  Google Scholar 

  34. McMillan K (1993) Symbolic model checking: an approach to the state explosion problem. Kluwer, Dordrecht

    Google Scholar 

  35. Milner R (1983) Calculi for synchrony and asynchrony. Theor Comp Sci 25(3):267–310 (Fundamental study)

    Google Scholar 

  36. Milner R (1989) Communication and concurrency. Prentice Hall, New Jersey

    MATH  Google Scholar 

  37. Niu J, Atlee JM, Day NA (2003) Template semantics for model-based notations. IEEE Trans Softw Eng 29(10):866–882

    Article  Google Scholar 

  38. OMG (2007) OMG unified modeling language (OMG UML), superstructure, v2.1.2. Formal/2007-11-01

  39. Parnas DL, Madey J (1995) Functional documents for computer systems. Sci Comp Programm 25(1):19–23

    Google Scholar 

  40. Pierce BC (2002) Types and programming languages. MIT Press, Cambridge

    Google Scholar 

  41. Pnueli A, Shalev M (1989) What is in a step? In: De Bakker JW (ed) Liber Amicorum. CWI, Amsterdam, pp 373–400

    Google Scholar 

  42. Pnueli A, Shalev M (1991) What is in a step: on the semantics of statecharts. In: Theoretical aspects of computer Software, volume 526 of LNCS. Springer, pp 244–264

  43. Sassone V, Nielsen M, Winskel G (1996) Models for concurrency: towards a classification. Theor Comp Sci 170(1–2):297–348

    MATH  MathSciNet  Google Scholar 

  44. Shukla SK, Theobald M (2006) Special issue on formal methods for globally asynchronous and locally synchronous (GALS) systems. Formal Methods Syst Des 28(2):91–92

    Article  Google Scholar 

  45. Silver SJ, Brzozowski JA (2003) True concurrency in models of asynchronous circuit behavior. Formal Methods Syst Des 22(3):183–203

    Article  MATH  Google Scholar 

  46. Taleghani A, Atlee JM (2006) Semantic variations among UML StateMachines. In: Model driven engineering languages and systems, 9th international conference, volume 4199 of LNCS. Springer, pp 245–259

  47. Tardieu O (2007) A deterministic logical semantics for pure Esterel. ACM Trans Programm Lang Syst 29(2):8:1–8:26

    Article  Google Scholar 

  48. van Glabbeek R. The linear time—branching time spectrum. In: International concurrency theory conference, volume 458 of LNCS

  49. von der Beeck M (1994) A comparison of statecharts variants. In: Formal techniques in real-time and fault-tolerant systems, volume 863 of LNCS. Springer, pp 128–148

  50. Zave P, Jackson M (1997) Four dark corners of requirements engineering. ACM Trans Softw Eng Methodol 6(1):1–30

    Article  Google Scholar 

Download references

Acknowledgments

We thank the reviewers for their insightful, detailed comments, which have improved our paper. We also thank the anonymous reviewers of our RE’09 paper, as well as Patrick Heymans, for their helpful comments that have influenced this paper.

Author information

Authors and Affiliations

  1. Cheriton School of Computer Science, University of Waterloo, Waterloo, ON, N2L 3G1, Canada

    Shahram Esmaeilsabzali, Nancy A. Day & Joanne M. Atlee

  2. Department of Computer Science, University of Texas at San Antonio, San Antonio, TX, 78249, USA

    Jianwei Niu

Authors
  1. Shahram Esmaeilsabzali
    View author publications

    You can also search for this author in PubMed Google Scholar

  2. Nancy A. Day
    View author publications

    You can also search for this author in PubMed Google Scholar

  3. Joanne M. Atlee
    View author publications

    You can also search for this author in PubMed Google Scholar

  4. Jianwei Niu
    View author publications

    You can also search for this author in PubMed Google Scholar

Corresponding author

Correspondence to Shahram Esmaeilsabzali.

Rights and permissions

Reprints and permissions

About this article

Cite this article

Esmaeilsabzali, S., Day, N.A., Atlee, J.M. et al. Deconstructing the semantics of big-step modelling languages. Requirements Eng 15, 235–265 (2010). https://doi.org/10.1007/s00766-010-0102-z

Download citation

  • Received:

  • Accepted:

  • Published:

  • Issue Date:

  • DOI: https://doi.org/10.1007/s00766-010-0102-z

Keywords

Search

Navigation