On implementations and semantics of a concurrent programming language

An introduction to metric semantics: operational and denotational models for programming and specification languages

In this work we propose to use a Horn fragment of Concurrent Transaction Logic ( ${\mathcal CTR}$) as an intuitive logic framework to specify semantics of concurrent programming languages. Using Horn logic to specify a programming language has been suggested before [5,6,2]. By specifying a programming language we mean writing semantics, all three semantics-operational, denotational, and axiomatic-in Horn logic, which is also executable. Slonneger convincingly demonstrated that, for the specification of denotational semantics, Prolog can be regarded as superior to imperative languages. Gupta [2] expanded on the idea and showed how Horn logic denotations lead to some interesting practical applications, such as automatic program verification and automatic generation of compilers. The work presented here builds on the aforementionedworks and extends that of [2] by providing a Horn logic denotational semantics for concurrent programming languages.

In this chapter we outline a process algebra, whose name — Petri Box Calculus (PBC) — arises from its original Petri net semantics [6, 7]. PBC combines a number of features taken from other process algebras, such as COSY (Concurrent Systems notation, [62]), CCS (Calculus of Communicating Systems, [80, 81]), SCCS (Synchronous CCS, [81]), CSP (Communicating Sequential Processes, [58]), TCSP (Theoretical CSP, [59]) and ACP (Algebra of Communicating Processes, [2]). However, there are some fundamental differences with each of these process algebras since PBC has been designed with two specific objectives in mind: To support a compositional Petri net semantics, together with an equivalent — more syntax-oriented — structured operational semantics (SOS) [89]. To provide as flexible as possible a basis for developing a compositional semantics of high-level concurrent specification and programming languages with full data and control features.

This paper provides an analysis of the meaning–reference problem, as traditionally advanced in the philosophy of language, for imperative programming languages. Addressing the problem is relevant for the philosophy of computer science in the context of the debate of whether simulative programs can be considered representational theories of their simulated systems. This paper challenges the thesis that, since programming languages have semantics, they also have reference, presumably to the external world. First, denotational, operational, game theoretic, and axiomatic semantics are epistemologically analysed to provide a theory of meaning for high-level language programs. It is argued that programming language semantics can be seen, to some extent, under the light of Fregean descriptivism, thereby rejecting the view that it is reference that determines meaning. Secondly, descriptivist, causal, character, and intentionalist theories of reference are examined to argue that meaning is not sufficient for programming languages to determine reference, thereby rejecting the view that meaning determines reference. It is argued that it is the intentions of agents that allow programming language semantics to identify referents. The paper concludes that if the semantics of programming languages may determine their reference, the latter is not to the external world but to the internal operations of the implementation executing them. This does not prevent simulative programs from representing empirical systems, but they do so not on the basis of programming language semantics.

This book – the first of two volumes – explores the syntactical constructs of the most common programming languages, and sheds a mathematical light on their semantics, while also providing an accurate presentation of the material aspects that interfere with coding. Concepts and Semantics of Programming Languages 1 is dedicated to functional and imperative features. Included is the formal study of the semantics of typing and execution; their acquisition is facilitated by implementation into OCaml and Python, as well as by worked examples. Data representation is considered in detail: endianness, pointers, memory management, union types and pattern-matching, etc., with examples in OCaml, C and C++. The second volume introduces a specific model for studying modular and object features and uses this model to present Ada and OCaml modules, and subsequently Java, C++, OCaml and Python classes and objects. This book is intended not only for computer science students and teachers but also seasoned programmers, who will find a guide to reading reference manuals and the foundations of program verification.

Isabelle is a generic meta-logical framework for implementing logical formalisms, and Isabelle/HOL is the specialization of Isabelle for HOL, which stands for Higher Order Logic. In programming language theory, formal semantics is the field concerned with the rigorous mathematical study of the meaning of programming languages. In this paper we develop a relational denotational semantics for a small imperative programming language and implement it as a theory in Isabelle/HOL. We give special attention to the specification of monotonic fix point functional for loops and provide non-trivial proofs of interesting lemmas and properties with the structured proof language Isar.

Semantics of programming languages: Using Asf+Sdf

Language semantics that is formal and mathematically precise, is the essential prerequisite for the design of logics and calculi that permit automated reasoning about programs. The most popular approach to programming language semantics—small step operational semantics (SOS)—is not modular in the sense that it does not separate conceptual layers in the target language. SOS is also hard to relate formally to program logics and calculi. Minimalist semantic formalisms, such as automata, Petri nets, or \(\pi \)-calculus are inadequate for rich programming languages. We propose a new formal trace semantics for a concurrent, active objects language. It is designed with the explicit aim of being compatible with a sequent calculus for a program logic and has a strong model theoretic flavor. Our semantics separates sequential and object-local from concurrent computation: the former yields abstract traces which in a second stage are combined into global system behavior.

The theory and semantics of programming languages are typically formulated using abstract mathematical models that have no obvious connection to any physical theory. While this approach has a number of advantages, it does not generalize to complex nondiscrete systems, and it obscures the underlying mathematical connections between computational and physical theory. Moreover, it can lead to inaccurate models of more complex phenomena such as concurrency. In this paper, we describe the current directions and initial results of our efforts to build connections between programming language theory and semantics and physical theory. The first and most mature of these efforts aims to develop a denotational semantic model that expands upon the mathematical formulation of quantum systems to provide a denotational foundation for concurrent languages. The second effort aims to generalize the notion of type systems to a probability inference system based on Bayesian probability. The third and final effort aims to develop an understanding of the dynamics of concurrent processes, with the goal of reasoning about the real behavior of processes in greater detail. In each of these efforts, we aim to draw connections between computing and other scientific disciplines.

A problem which confronts the developers of concurrent logic programming (CLP) systems concerns the design of the programming environment, particularly the provision of debugging tools. Debugging tools are useful for many activities besides identifying bugs: they can help in program testing and demonstration, in software experiments, and in teaching the language semantics. For CLP languages the questions of what debugging tools should be provided, and of how they should be used, are still open. Although the languages are closely related to other logic programming and concurrent programming languages, they are sufficiently different that new debugging techniques are required. This paper describes a primarily channel-oriented debugging methodology and a set of debugging tools that we have developed in the light of our experience in using and teaching the CLP language Parlog. With these tools a programmer can test a program by observing communication on channels, opening up a process to examine the activity on internal channels and, if necessary, to check in detail the execution steps of a process. Almost all of the ideas, which are equally applicable to other CLP languages, have been implemented in two commercial Parlog systems. As well as fulfilling the needs of existing users of CLP languages, we believe that the tools emphasise the attractions of CLP as a concurrent programming paradigm, since they are made possible by the unique attributes of CLP.

Formal, mathematically rigorous programming language semantics are the essential prerequisite for the design of logics and calculi that permit automated reasoning about concurrent programs. We propose a novel modular semantics designed to align smoothly with program logics used in deductive verification and formal specification of concurrent programs. Our semantics separates local evaluation of expressions and statements performed in an abstract, symbolic environment from their composition into global computations, at which point they are concretised. This makes incremental addition of new language concepts possible, without the need to revise the framework. The basis is a generalisation of the notion of a program trace as a sequence of evolving states that we enrich with event descriptors and trailing continuation markers. This allows to postpone scheduling constraints from the level of local evaluation to the global composition stage, where well-formedness predicates over the event structure declaratively characterise a wide range of concurrency models. We also illustrate how a sound program logic and calculus can be defined for this semantics.

Modern science commonly uses computer modelling. Thousands of scientific model are daily transformed to computers programs and tested. The transformation must overcome the gap between abstract human formal notation and low level semantics of contemporary programming languages. The simultaneous knowledge of specific scientific models and programming languages is an unpleasant necessity for a significant proportion of scientists and practitioners (engineers, economist, etc.). But a solution exists - accommodation of programming languages to mental models of their users. The article discuss one partial solution - implementation of domain specific languages in the heart of existing universal languages by mechanisms of metaprogramming. This mechanism overcomes limitations of classical programming languages and complexity of creation new languages from scratch. However, the support of metaprogramming in contemporary languages is limited to isolated and peripheral constructs in very few languages. These constructs are demonstrated by simplified but real examples (metaobject system of Python, monads in F# and macro-based metaprogramming of Boo language) together with discussion of their advantages and disadvantages. The discussion of examples is aimed to finding requirements for new languages and their implementation in a original (parent) language.

In this paper we discuss the semantics of a simple block-structured programming language which allows sharing or aliasing. Sharing, which arises naturally in procedural languages which permit certain forms of parameter passing, has typically been regarded as problematical for the semantic treatment of a language. Difficulties have been encountered in both denotational and axiomatic treatments of sharing in the literature. Nevertheless, we find that it is possible to define a clean and elegant formal semantics for sharing. The key to our success is the choice of semantic model; we show that conventional approaches based on locations are less than satisfactory for the purposes of reasoning about partial correctness, and that in a well defined sense locations are unnecessary.We begin by defining a denotational semantics for our programming language. The semantic model is not based on locations, but instead uses an abstract sharing relation on identifiers to represent the notion of aliasing, and uses an abstract state with a stack-like structure to capture the semantics of blocks and accurately model the scope rules. The semantics is shown to be fully abstract with respect to partial correctness properties, in contrast to conventional location-based models. This means that the semantics identifies terms if and only if they induce identical partial correctness behaviour in all program contexts. This property usually fails for location-based semantics because in such models it is possible to distinguish between terms on the basis of their effect on individual locations, which has no bearing on partial correctness.We believe that axiomatic reasoning about program behaviour should be based directly on a semantic model specifically tailored for that purpose; full abstraction with respect to an appropriate behavioural notion is a formal criterion against which to judge the suitability of a semantics. The structure of a semantic model should be used directly to suggest the structure of an assertion language for expressing program properties. With this in mind, we build a Hoare-style (syntax-directed) proof system for partial correctness properties of our programming language, and we prove soundness and relative completeness of this system. The proof system is built up in a hierarchical manner which reflects the syntactic and semantic structure of the programming language. We first design a proof system for declarations, and then use it in building proof rules for commands. We claim that our proof rules are conceptually simpler to understand than other rules proposed in the literature for aliasing, without losing any expressive power. We show, for example, that it is possible to define a “generic” inference rule for blocks which is uniformly applicable to3 blocks headed by different forms of declaration. The important point here is that, unlike most of the proof systems for these constructs in the literature, we do not have to design a separate rule for blocks for each possible form of declaration. This results in greater flexibility and adaptability in our proof system. We demonstrate that some well known rules from the literature for blocks can be derived in our system.

Virtual classes are class-valued attributes of objects.<br />Like virtual methods, virtual classes are defined in<br />an object’s class and may be redefined within subclasses.<br />They resemble inner classes, which are also<br />defined within a class, but virtual classes are accessed<br />through object instances, not as static components<br />of a class. When used as types, virtual classes depend<br />upon object identity – each object instance introduces<br />a new family of virtual class types. Virtual classes support large-scale program composition techniques,<br />including higher-order hierarchies and family<br />polymorphism. The original definition of virtual<br />classes in Beta left open the question of static type<br />safety, since some type errors were not caught until<br />runtime. Later the languages Caesar and gbeta have<br />used a more strict static analysis in order to ensure<br />static type safety. However, the existence of a sound,<br />statically typed model for virtual classes has been a<br />long-standing open question. This technical report<br />presents a virtual class calculus, vc, that captures<br />the essence of virtual classes in these full-fledged programming languages. The key contributions of the<br />paper are a formalization of the dynamic and static<br />semantics of vc and a proof of the soundness of vc.<br />Categories: D.3.3 [Language Constructs and Features]:<br />Classes and objects, inheritance, polymorphism.<br />F.3.3 [Studies of Program Constructs]:<br />Object-oriented constructs, type structure. F.3.2<br />[Semantics of Programming Languages]: Operational<br />semantics.

We describe several views of the semantics of a simple programming language as formal documents in the calculus of inductive constructions that can be verified by the Coq proof system. Covered aspects are natural semantics, denotational semantics, axiomatic semantics, and abstract interpretation. Descriptions as recursive functions are also provided whenever suitable, thus yielding a a verification condition generator and a static analyser that can be run inside the theorem prover for use in reflective proofs. Extraction of an interpreter from the denotational semantics is also described. All different aspects are formally proved sound with respect to the natural semantics specification.