DOCSLIB.ORG

UTP Semantics for Shared-State, Concurrent, Context-Sensitive Process Models

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
UTP Semantics for Shared-State, Concurrent, Context-Sensitive Process Models View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by University of Limerick Institutional Repository UTP Semantics for Shared-State, Concurrent, Context-Sensitive Process Models Andrew Butterfield Anila Mjeda John Noll Lero @ TCD Lero @ TCD Lero @ UL School of Computer Science and Statistics School of Computer Science and Statistics Tierney Building Trinity College, Dublin 2, Ireland Trinity College, Dublin 2, Ireland University of Limerick Email: Andrew.Butterfi[email protected] Email: [email protected] Email: [email protected] Abstract—Process Modelling Language (PML) is a notation semantics for shared global state concurrency, as a way to for describing software development and business processes. It get a suitable semantics for strict and flexible PML, inspired takes the form of a shared-state concurrent imperative language by the work of Woodcock and Hughes on unifying parallel describing tasks as activities that require resources to start and provide resources when they complete. Its syntax covers programming (UTPP, [13]). We present both a formal seman- sequential composition, parallelism, iteration and choice, but tics for a “weak” interpretation of PML, as well as a unified without explicit iteration and choice conditions. It is intended theory of concurrent programs (UTCP) that will provide a to support a range of context-sensitive interpretations, from a baseline theory for modelling more “flexible” and “strong” rough guide for intended behaviour, to being very prescriptive interpretations of PML. Part of our contribution is extending about the order in which tasks must occur. We are using Unifying Theories of Programming (UTP) to model this range of semantic the UTP methodology to use non-homogenous relations that interpretations, with formal links between them, typically of the mix dynamic state-change (observations with before- and nature of a refinement. We address a number of challenges after-values) along with static context parameters (observations that arise when trying to develop a compositional semantics whose value is unchanged during program execution). We also for PML and its shared-state concurrent underpinnings, most develop a notion of label generators to allow us to describe notably in how UTP observations need to distinguish between dynamic state-changes and static context parameters. The formal flow of control in a compositional manner. semantics are intended as the basis for tool support for process The structure of this paper is as follows: In xII we give analysis, with applications in the healthcare domain, covering a quick introduction to an abstract form of PML, while in such areas as healthcare pathways and software development xIII we provide a quick overview of UTP. We then move on and certification processes for medical device software. c IEEE to present the weak semantics for PML in xIV, the baseline 2016 http://doi.ieeecomputersociety.org/10.1109/TASE.2016.22 UTCP semantics in xV, and then to relate the two in xV-H, I. INTRODUCTION where we also discuss future work. We then describe related Programming-like notations have been used to describe work (xVI) and conclude (xVII). business processes and workflows for many years [1]–[3]. There is considerable interest at present in healthcare systems II. PROCESS MODELLING LANGUAGE in so-called clinical pathways, that describe processes for Process Modelling Language (PML) [10] is a shared-state managing patient care. These too can be described using concurrent imperative language describing named basic ac- general business process notations [4]–[6]. Deploying process tions (N?rr!pr) as activities that require resources to start (rr) models in the medical domain in practise requires flexible and provide resources when they complete (pr). Actions are interpretations of those models [2], [4], [6]–[9] . non-destructive in that the required resources are not consumed PML is such a language [10], developed originally for but remain in place. Its concrete syntax is C-like, but we modelling software development processes, but applicable to present a simpler abstract syntax here: a much wider range of activities, including clinical pathways [11]. It is designed to encourage a flexible approach to its N 2 Name interpretation and deployment. This is most obvious when A 2 Action ::= N?rr!pr one considers that the condition and iterative constructs of ! P; Q 2 PML ::= A j P ;; Q j P CB Q j P k Q j P the language have no condition predicates, relying on the judgement of those enacting the process to determine which We use P ;; Q and P k Q to denote respectively sequential conditional branch should be taken, or when a loop should and parallel composition. Both the conditional (P CB Q) and terminate. the loop construct P ! are unusual in that they have no explicit In this paper we present results obtained while developing conditions. Instead the decision of which branch to take or a range of formal semantics for PML using the Unifying whether or not to end the loop is left unspecified—this is one Theorems of Programming (UTP) framework [12] to sup- aspect of the flexible nature of the language. In its original port reasoning about flexible deployment. We define a UTP intended use, it was left to the people enacting the business process described by PML to use their judgement to determine value of expression e in the before-state, while the other which branch to take or when a process has been repeated variables, denoted collectively by ν, remain unchanged. In enough. UTP, a predicate of the form ok ^ P =) ok0 ^ Q is called We are developing a formal PML semantics framework a Design, denoting a total-correctness assertion, is typically which can investigate and relate at least three interpretations shortened to P ` Q. UTP supports specification languages as of a PML description: well as programming ones, and a general notion of refinement • Strict: the behaviour follows strictly according to the as universally-closed reverse implication: control-flow structure, becoming deadlocked if control S v P = [P =) S] requires execution of actions whose required resources b are not available. A key part of the UTP framework is the use of healthiness • Flexible: the behaviour is guided by the control flow, but conditions to ensure that the predicates actually correspond to actions can run out of sequence if their required resources feasible program outcomes. These are typically defined using become available before the control flow has determined idempotent and monotonic predicate-transformers (H) that that they should start. make an un-healthy predicate healthy (H(Bad) = Better), • Weak: control flow is completely ignored, and exe- while leaving healthy ones untouched (H(Good) = Good). cution simply iterates the non-deterministic choice of For example, the unhealthy predicate :ok ^ ok0 (I’ve finished actions whose resources are available (also known as the even though I didn’t start!) is ruled out by the following “dataflow interpretation”). predicate-transformer: In our framework, the three interpretations form a refinement hierarchy: H1(P ) = :ok _ P W eak v F lexible v Strict In contrast, applying H1 to the definition of assignment leaves As an example, consider the following PML description: it unchanged. Most of the healthiness conditions define sets of healthy predicates that form complete lattices, where the A?!r1 ;; (B?r1!r2 k C?r2!r3) ;; D?r1!r4 bottom element is the most liberal specification (“chaos”), and In the strict interpretation, only one sequence is possible, the top element is the infeasible program that satisfies any namely A; B; C; D because (i) A is required by control-flow specification (“miracle”). The healthiness conditions that do to precede both B and C, and (ii) D is forced to be last. not produce lattices are typically optional ones that can be In the weak interpretation, we ignore the flow control, and invoked to rule out miracles, and which effectively chop off the are left with resource constraints only (B must follow A, upper infeasible predicates, and leaving fully refined programs C must follow B and D must followA) This admits three as maximal elements. possible enactment sequences: A; B; C; D, or A; D; B; C, or IV. WEAK PML A; B; D; C. In this paper we focus on the weak semantics, and on We give the semantics of the weakest interpretation of PML, developments we have done within the Unifying Theories where we only consider the dataflow-like behaviour induced of Programming (UTP) framework [12] to create a semantic by the “requires”(?) and “provides” (!) annotations on basic baseline on top of which both the flexible and strict semantics actions. We shall assume a simple model of resources, as can be constructed. uninterpreted entities that are distinguishable, and where the only property of interest is whether or not any given resource III. UNIFYING THEORIES OF PROGRAMMING is present in the system. What we want to observe is how the The Unifying Theories of Programming framework [12] resources in the system evolve over time, as well as keeping uses predicate calculus to define before-after relationships track (by name) of which basic actions were executed. We over appropriate collections of free observation variables. introduce three observations, all of which can be made both The before-variables are undashed, while after-variables have before and after a PML run: starting, termination (ok; ok0 : B); dashes1. Some observations correspond to the values of pro- resources in the system (r; r0 : P Res); and basic actions gram variables (v; v0), while others deal with important obser- executed (h; h0 : Name∗). vations one might make of a running program, such as start Due to space limitations, we do not give a detailed account (ok) and termination (ok0) or event traces (tr; tr0). The set of the healthiness conditions here, but note that we have the of observation variables associated with a theory or predicate usual Design conditions (H1; H2; H3) as well as modified is known as its alphabet.
Load more

Recommended publications
  • Domain Theory for Concurrency
    Domain Theory for Concurrency Mikkel Nygaard Glynn Winskel BRICS∗ Computer Laboratory University of Aarhus University of Cambridge Abstract A simple domain theory for concurrency is presented. Based on a categorical model of linear logic and associated comonads, it highlights the role of linear- ity in concurrent computation. Two choices of comonad yield two expressive metalanguages for higher-order processes, both arising from canonical construc- tions in the model. Their denotational semantics are fully abstract with respect to contextual equivalence. One language derives from an exponential of linear logic; it supports a straightforward operational semantics with simple proofs of soundness and adequacy. The other choice of comonad yields a model of affine-linear logic, and a process language with a tensor operation to be under- stood as a parallel composition of independent processes. The domain theory can be generalised to presheaf models, providing a more refined treatment of nondeterministic branching. The article concludes with a discussion of a broader programme of research, towards a fully fledged domain theory for concurrency. 1 Introduction Denotational semantics and domain theory of Scott and Strachey provide a global mathematical setting for sequential computation, and thereby place programming languages in connection with each other; connect with the mathematical worlds of algebra, topology and logic; and inspire programming languages, type disciplines and methods of reasoning. In concurrent/distributed/interactive computation that global mathematical gui- dance is missing, and domain theory has had little direct influence on theories of concurrent computation. One reason is that classical domain theory has not scaled up to the more intricate models used there.
    [Show full text]
  • Four Domains for Concurrency
    Theoretical Computer Science 90 (1991) 127-149 127 Elsevier Four domains for concurrency J.W. de Bakker and J.H.A. Warmerdam* Centre for Mathematics and Computer Science, P.O. Box 4079, 1009 AB Amsterdam, The Netherlands Abstract Bakker, J.W. de, and J.H.A. Warmerdam, Four domains for concurrency, Theoretical Computer Science 90 (1991) 127-149. We give four domains for concurrency in a uniform way by means of domain equations. The domains are intended for modelling the four possible combinations of linear time versus branching time, and of interleaving versus noninterleaving concurrency. We use the linear time, noninter­ leaved domain to give operational and denotational semantics for a simple concurrent language with recursion, and prove that (} ~ ftl. Prologue Among the reasons to fondly remember my first IFIP Congress (New York, 1965), I recall a meeting with the late Professors Andrei Ershov and Aad van Wijngaarden, both then already famous scholars, who strongly encouraged me to continue my incipient work on programming language semantics. Among the reasons to somewhat embarrassedly remember the 6th MFCS meeting (Tatranska Lomnica, 1977), I recall a discussion with Andrei Ershov on my unsatis­ factory first steps towards an understanding of concurrency semantics and infinite behaviour (cf. [6]). The paper to follow reports on how we spent the 1980s in Amsterdam working to remedy this. Among the reasons to sadly remember my otherwise so enjoyable visit to Akademgorodok in the fall of 1988, I recall in sorrow the news about the mortal illness and death of Academician Andrei Ershov, eminent computer scientist and world specialist in programming.
    [Show full text]
  • Contractions in Comparing Concurrency Semantics
    Contractions in Comparing Concurrency Semantics J.N. Kok & J.J.M.M. Rutten Centre for Mathematics and Computer Science P.O. Box 4079, 1009 AB Amsterdam, The Netherlands We define for a simple concurrent imperative language both operational and denotational semantic models as fixed points of contractions on complete metric spaces. Next, we develop a general method for comparing different semantic models by relating their defining contractions and exploit­ ing the fact that contractions have a unique fixed point. 0. INTRODUCTION We present a study of a simple concurrent imperative language, called L 0 . We shall define an operational semantics Bo and a denotational semantics 0D0 for it and give a comparison of the two models. (We shall use the terms semantics and semantic model as synonyms.) This comparison is the main subject of our paper, rather than the specific nature of the language itself or the particular properties of its semantics. The language L 0 has been defined and studied already in much detail in [BMOZI,2] and [BKMOZ], on which we rely heavily. It belongs to the wide class of concurrent (parallel) imperative programming languages. We shall discuss parallel execution through interleaving (shuffie) of elementary actions. Further, L 0 contains constructs for sequential composition, local nondeterrninacy, and recursion. For our semantic definitions we shall use metric structures, rather than order-theoretic domains. The metric approach is particularly felicitous for problems where histories, computa­ tional traces and tree-like structures of some kind are essential. Moreover, it allows for the definition of the notion of contraction, which we discuss in more detail in a moment.
    [Show full text]
  • A Lightweight Formal Method for the Prediction of Non-Functional System Properties
    A Lightweight Formal Method for the Prediction of Non-Functional System Properties Der Technischen Fakultät der Universität Erlangen-Nürnberg zur Erlangung des Grades Doktor-Ingenieur vorgelegt von Jörg Barner Erlangen — 2005 Als Dissertation genehmigt von der Technischen Fakultät der Universität Erlangen-Nürnberg Tag der Einreichung: 20.06.2005 Tag der Promotion: 14.10.2005 Dekan: Prof. Dr.-Ing. Alfred Leipertz Berichterstatter: Prof. Dr. Fridolin Hofmann, Prof. Dr. Khalid Al-Begain Acknowledgments First of all, I would like to thank Prof. Dr. Fridolin Hofmann for supervising this dissertation and for the open environment he created together with Prof. Dr.-Ing. Wolfgang Schröder- Preikschat in our department which allowed me to finish this project. Furthermore, I am particularly grateful to Prof. Dr. Khalid Al-Begain, my co-promoter, whose interest in appli- cations and the encouraging feedback he gave were always a great pleasure. I owe a lot of thanks to Dr.-Ing. Gunter Bolch, my “Ana” research group leader for many inspiring discussions which helped me a lot to sharpen my thoughts on important issues and prevented me from losing my direction. Without the commitment that Björn Beutel and Patrick Wüchner exhibited during the preparation of their master theses some of the concepts presented in this dissertation would have remained purely theoretical. My former office mate Dr.-Ing. Michael Schröder proof-read various intermediate ver- sions of this dissertation. Together with him, Stephan Kösters supported me in the nerve- wracking final phase before submitting the thesis by doing some valuable last-minute proof- reading. It has been a lot of fun to work at the department for distributed systems and operat- ing systems with all the colleagues and students.
    [Show full text]
  • Correctness and Full Abstraction of Metric Semantics for Concurrency
    Correctness and full abstraction of metric semantics for concurrency J.J.M.M. Rutten Centre for Mathematics and Computer Science P.O. Box 4079, 1009 AB Amsterdam, The Netherlands ABSTRACT: Four different semantic models are given for a simple uniform programming language, containing constructs for parallel composition, global nondeterminism and com­ munication: linear semantics, failure semantics, readiness semantics, and branching semantics. The mathematical framework used consists of complete metric spaces. All models and operators are given as fixed points of suitably defined contractions. This allows for a uniform presentation and an easy comparison of these models. It is shown that the latter three semantics all are correct and that the failure semantics is fully abstract with respect to the linear semantics. Although these results are not new, we believe the unifor­ mity of the way they are presented here to be of some interest. KEY WORDS AND PHRASES: concurrency, complete metric spaces, contractions, operational semantics, denotational semantics, compositionality, correctness, full abstraction. CoNTENTS 1. Introduction 2. A simple language 3. Four operational models 3.1. Linear semantics 3.2. Branching semantics 3.3. Readiness semantics 3.4. Failure semantics 629 3.5. Some examples 3.6. Relating the different operational models 4. 1bree compositional models 5. Semantic equivalence 6. Correctness and full abstraction 7. Related work 8. References 9. Appendix: Mathematical definitions 1. INTRODUCTION The semantics of a uniform programming language e is studied, containing the following con­ structs: atomic actions, which are left uninterpreted and which can be either internal or commun­ ications; sequential composition, global nondetenninism and parallel composition; and recursion, modeled via the simultaneous declaration of statement variables.
    [Show full text]
  • Modular, Compositional, and Executable Formal Semantics for LLVM IR
    Modular, Compositional, and Executable Formal Semantics for LLVM IR YANNICK ZAKOWSKI, Inria, France CALVIN BECK, University of Pennsylvania, USA IRENE YOON, University of Pennsylvania, USA ILIA ZAICHUK, Taras Shevchenko National University of Kyiv, Ukraine VADIM ZALIVA, Carnegie Mellon University, USA STEVE ZDANCEWIC, University of Pennsylvania, USA This paper presents a novel formal semantics, mechanized in Coq, for a large, sequential subset of the LLVM IR. In contrast to previous approaches, which use relationally-specified operational semantics, this new semantics 67 is based on monadic interpretation of interaction trees, a structure that provides a more compositional approach to defining language semantics while retaining the ability to extract an executable interpreter. Our semantics handles many of the LLVM IR’s non-trivial language features and is constructed modularly in terms of event handlers, including those that deal with nondeterminism in the specification. We show how this semantics admits compositional reasoning principles derived from the interaction trees equational theory of weak bisimulation, which we extend here to better deal with nondeterminism, and we use them to prove that the extracted reference interpreter faithfully refines the semantic model. We validate the correctness ofthe semantics by evaluating it on unit tests and LLVM IR programs generated by HELIX. CCS Concepts: • Software and its engineering ! Semantics; Compilers; • Theory of computation ! Program verification; Denotational semantics. Additional Key Words and Phrases: Semantics, Monads, Coq, LLVM, Verified Compilation ACM Reference Format: Yannick Zakowski, Calvin Beck, Irene Yoon, Ilia Zaichuk, Vadim Zaliva, and Steve Zdancewic. 2021. Modular, Compositional, and Executable Formal Semantics for LLVM IR. Proc. ACM Program. Lang. 5, ICFP, Article 67 (August 2021), 30 pages.
    [Show full text]
  • Sense and Reference in Semantics Examples
    Sense And Reference In Semantics Examples Hassan tats vehemently while inextensible Sid naphthalises rebukingly or cooings vestigially. Leguminous and tight Aram unpinned her tooms haggis outguess and getter homologous. Which Waiter dirties so disposedly that Wyatt soar her tummies? These possibilities in sense and epistemic intensions associated sense in identifying the meanings The in language may turn play the examples in sense reference semantics and of language but they varied according to. Priming led to shorter planning times but actually speaking times. We understand these examples structure and sense is hesperus picks out that description above examples we might intuitively think that? This direction is straightforwardly plausible. Lexical Semantics Department our Second Language Studies. For example dictionaries often monetary the words black death white senses like In. Here are whether few. Recent work in neurolinguistics supports this proposal. One word relationships between names and in his going the! Sometimes said to senses is semantically related matters is not occur if different reference? We are some man hits the sentences, then it will the examples in! There from some semantic featuresproperties that feeling usually prototypical for a word The green of attributes that define a pile the family The sense include a. To senses of reference in my research interests lie in its referent as ways in mapping process produces an example proves that have different epistemic contexts. Many philosophers and linguists have sought to define the trunk of meaning. So may every epistemic possibility W, the epistemic intensions of these sentences are true. Monica Lewinsky illustrate this conception, as do several other words labels attached to objects for sale being a shop, or life found nor a paint color chart.
    [Show full text]
  • Graph Rewriting for a Partial Ordering Semantics of Concurrent Constraint Programming*
    Theoretical Computer Science 109 (1993) 225-256 225 Elsevier Graph rewriting for a partial ordering semantics of concurrent constraint programming* Montanari, U. and F. Rossi. Graph rewriting for a partial ordering semantics of concurrent constraint programming, Theoretical Computer Science 109 (1993) 225-256. The concurrent constraint logic programming framework extends both logic programming and concurrent logic programming in that a program consists of the concurrent execution of agents which add (i.e., “tell”) and check (i.e., “ask”) constraints on a shared set of variables, and whose behaviour is described by a set of clauses. This formulation is very genera1 and can be seen as a concurrent logic programming she11 which is parametrized w.r.t. the underlying constraint system. Graphs and graph grammars can be conveniently used to describe such a framework, and the modelling is so elegant and expressive that they provide what we believe is the most natural abstract machine for concurrent constraint programming. In fact. basic notions like the possibility of asking or telling a constraint into the shared store are very easy to express in the algebraic approach to graph rewriting. More precisely, the shared store is represented as a (hyper)graph, where nodes are variables and arcs are constraints or agents. Then. both the entailment relation of the underlying constraint system and the local behaviour of agents is expressed by suitable sets of graph produc- tions, which transform the current global state of the system into a new one. Finally, each computation is represented by a graph derivation. In our setting the shared store is not seen as one constraint, but as a set of constraints which possibly share variables.
    [Show full text]
  • Owicki-Gries Reasoning for C11 Programs with Relaxed Dependencies (Extended Version)?
    Owicki-Gries Reasoning for C11 Programs with Relaxed Dependencies (Extended Version)? Daniel Wright1, Mark Batty1, and Brijesh Dongol2 1 University of Kent 2 University of Surrey Abstract. Deductive verification techniques for C11 programs have ad- vanced significantly in recent years with the development of operational semantics and associated logics for increasingly large fragments of C11. However, these semantics and logics have been developed in a restricted setting to avoid the thin-air-read problem. In this paper, we propose an operational semantics that leverages an intra-thread partial order (called semantic dependencies) induced by a recently developed denotational event-structure-based semantics. We prove that our operational seman- tics is sound and complete with respect to the denotational semantics. We present an associated logic that generalises a recent Owicki-Gries framework for RC11 (repaired C11), and demonstrate the use of this logic over several example proofs. 1 Introduction Significant advances have now been made on the semantics of (weak) memory models using a variety of axiomatic (aka declarative), operational and denota- tional techniques. Several recent works have therefore focussed on logics and associated verification frameworks for reasoning about program executions over weak memory models. These include specialised separation logics [9, 11, 15, 26] and adaptations of classical Owicki-Gries reasoning [7, 17]. At the level of lan- guages, there has been a particular focus on C11 (the 2011 C/C++ standard). Due to the complexity of C11 [4], many reasoning techniques have restricted themselves to particular fragments of the language by only allowing certain types of memory accesses and/or reordering behaviours.
    [Show full text]
  • Modular Relaxed Dependencies in Weak Memory Concurrency⋆
    Modular Relaxed Dependencies in Weak Memory Concurrency? Marco Paviotti12, Simon Cooksey2, Anouk Paradis3, Daniel Wright2, Scott Owens2, and Mark Batty2 1 Imperial College London, United Kingdom [email protected] 2 University of Kent, Canterbury, United Kingdom fm.paviotti, sjc205, daw29, S.A.Owens, [email protected] 3 ETH Zurich, Switzerland [email protected] Abstract. We present a denotational semantics for weak memory con- currency that avoids thin-air reads, provides data-race free programs with sequentially consistent semantics (DRF-SC), and supports a com- positional refinement relation for validating optimisations. Our semantics identifies false program dependencies that might be removed by compiler optimisation, and leaves in place just the dependencies necessary to rule out thin-air reads. We show that our dependency calculation can be used to rule out thin-air reads in any axiomatic concurrency model, in particular C++. We present a tool that automatically evaluates litmus tests, show that we can augment C++ to fix the thin-air problem, and we prove that our augmentation is compatible with the previously used compilation mappings over key processor architectures. We argue that our dependency calculation offers a practical route to fixing the long- standing problem of thin-air reads in the C++ specification. Keywords: Thin-air problem · Weak memory concurrency · Compiler Optimisations · Denotational Semantics · Compositionality 1 Introduction It has been a longstanding problem to define the semantics of programming languages with shared memory concurrency in a way that does not allow un- wanted behaviours { especially observing thin-air values [8,7] { and that does not forbid compiler optimisations that are important in practice, as is the case with Java and Hotspot [30,29].
    [Show full text]
  • Concurrency Semantics in Continuation-Passing Style — The
    Concurrency Semantics in Continuation-Passing Style∗ — The Companion Technical Report — Eneia Nicolae Todoran Technical University of Cluj-Napoca Department of Computer Science Baritiu Str. 28, 400027, Cluj-Napoca, Romania. [email protected] Nikolaos S. Papaspyrou National Technical University of Athens School of Electrical and Computer Engineering Software Engineering Laboratory Polytechnioupoli, 15780 Zografou, Greece. [email protected] Abstract By using the mathematical framework of metric semantics we develop a denotational semantics designed in continuation-passing style for an abstract concurrent language providing a general mech- anism of interaction between multisets of distributed actions. The basic laws of concurrent systems are satisfied in this semantics. Next, by customizing the behavior of continuations we obtain denota- tional semantics for a couple of concurrent languages incorporating mechanisms for multiparty and binary interactions. We offer denotational semantics for two imperative concurrent languages based on Hoare’s CSP and a process algebra for DNA computing introduced by Cardelli. Keywords: continuation-passing style, denotational semantics, metric spaces, concurrency semantics 1 Introduction Continuations are a very powerful control-flow mechanism. As abstract representations of control flow, they were introduced in the 1960s and soon came into prominence in the field of denotational semantics for modelling the semantics of programming languages [23, 38, 34]. In a few words, a continuation represents control flow by capturing the notion of “the rest of the program”, after the current point during the program’s execution. Some functional languages, such as Scheme [22] and SML/NJ [37], provide direct support for capturing and invoking continuations, which are treated as first-class values.
    [Show full text]