Semantics Of Programming Languages Research Articles

Conflict exceptions

We argue in this paper that concurrency errors should be treated as exceptions, i.e. , have fail-stop behavior and precise semantics. We propose an exception model based on conflict of synchronization free regions, which precisely detects a broad class of data-races. We show that our exceptions provide enough guarantees to simplify high-level programming language semantics and debugging, but are significantly cheaper to enforce than traditional data-race detection. To make the performance cost of enforcement negligible, we propose architecture support for accurately detecting and precisely delivering these exceptions. We evaluate the suitability of our model as well as the behavior of our architectural mechanisms using the PARSEC benchmark suite and commercial applications. Our results show that the exception model largely reflects how programmers are already writing code and that the main memory, traffic and performance overheads of the enforcement mechanisms we propose are very low.

VDM semantics of programming languages: combinators and monads

Abstract The Vienna Development Method (VDM) was developed in the early 1970s as a variant of denotational semantics. VDM descriptions of programming languages differ from the original Scott–Strachey style by making extensive use of combinators which have a fixed operational interpretation. After recalling the main features of denotational semantics and the Scott–Strachey style, we examine the combinators of the VDM specification language, and relate them to monads, which were introduced more than 15 years later. We also suggest that use of further monadic combinators in VDM could be beneficial. Finally, we provide an overview of published VDM semantic descriptions of major programming languages.

The tccp Interpreter

The Timed Concurrent Constraint language (tccp in short) is a declarative language inspired by some formalisms specially developed to deal with concurrent and reactive systems. It is defined as a timed extension of the Saraswat's Concurrent Constraint Paradigm (ccp in short) which makes the new language suitable for modeling reactive systems. The computational model of ccp is based on agents generating (telling) and checking (asking) partial information (constraints) on a global store (a conjunction of constraints). tccp inherits the main characteristics of ccp: it is parametric w.r.t. a constraint system and non-deterministic. This work presents the tccpInterpreter system, which is the result of implementing the tccp language in Maude. Maude has been shown to be well suited for the task of prototyping the semantics of programming languages. Our tccpInterpreter parses a given program and simulates its behavior, also allowing us to reuse the Maude features to execute and analyze tccp programs.

Domain Equations Based on Sets with Families of Pre-orders

In this paper we are interested in finding solutions of domain equations based on posets with families of pre-orders. Let (P,⊑) be a poset and let (ω,⩽) be the natural number set. If R=(⊑n)n∈ω is a family of pre-order relations on P, where ⊑0=P×P, such that (i)∀n,m∈ω, m⩽n implies ⊑n⊆⊑m, and (ii)∩n∈ω⊑n=⊑, then we call (P,⊑) a poset with pre-order family R. We write it R-poset or rpos for short and denote it briefly by (P,⊑;R) [L. Fan, W. Ji and W.L. Wang. The Information Order Approximation and Generalized Chains'Completion, Beijing: Capital Normal University, Preprint, 2005, (in Chinese)]. R-posets are a particular case of quasi-metric spaces (qms) [M.B. Smyth. Quasi uniformities: reconciling domains with metric spaces. Proceedings of the 3rd Workshop on Mathematical Foundations of Programming Language Semantics, APR.8-10,1987. Lecture Notes In Computer Science, Vol. 298, pp 236-253. Springer-Verlag, Berlin, 1988] and generalized ultrametric spaces (gums) [J.J.M.M. Rutten. Elements of Generalized Ultrametric Domain Theory. Technical Report CS-R9507, CWI, Amsterdam, 1995]. R-poset is a ‘nonsymmetric’ version of sfe [L. Monteiro. Semantic domains based on sets with families of equivalences. Electronic Notes in Theoretical Computer Science, 11, pp 1-34, 1998]. We propose a fixed points theorem that can be used for solving domain equations. The paper ends in a final coalgebra theorem.

Formalisation of C Language Interfaces

In practical computing, implementations of programming languages provide an interface that allow programs written in a language to call code written in another programming language, most often C. Usually, those language interfaces are left out of the formal definition of the language, and reasoning about multi-language programs is very difficult due to the lack of precise specifications for the language interfaces. In this paper, we present an application of a framework for the interoperability of programming languages, in which we specified in a systematic way the C interface of a real, rule-based programming language. Our framework is based on simple combinations of the small-step operational semantics of programming languages. We give the main elements of a small-step semantics for the C programming language that can be used to specify the same kind of interfaces for other programming languages implemented in C.

Compositionality of Model Transformations

Model transformations can be used not only for code or platform-specific model generation, but also for denotational semantics definition, e.g. using process algebras as semantics for visual modeling languages. Denotational semantics of programming languages are by definition compositional. In order to enjoy a similar property in the case of model transformations, every component of the source model should be distinguishable in the target model and the mapping compatible with syntactic and semantic composition. Since typed graphs are a natural representation of visual models, model transformations are often described by typed graph transformations. This paper proposes a formal definition of compositionality for mappings from typed graphs to semantic domains. To verify compositionality, syntactic criterion has been established for the implementation of the mappings by graph transformations with negative application conditions. An example compositional transformation is presented that maps architectural models described in UML component diagrams to CSP.

Formal certification of code-based cryptographic proofs

As cryptographic proofs have become essentially unverifiable, cryptographers have argued in favor of developing techniques that help tame the complexity of their proofs. Game-based techniques provide a popular approach in which proofs are structured as sequences of games and in which proof steps establish the validity of transitions between successive games. Code-based techniques form an instance of this approach that takes a code-centric view of games, and that relies on programming language theory to justify proof steps. While code-based techniques contribute to formalize the security statements precisely and to carry out proofs systematically, typical proofs are so long and involved that formal verification is necessary to achieve a high degree of confidence. We present Certicrypt, a framework that enables the machine-checked construction and verification of code-based proofs. Certicrypt is built upon the general-purpose proof assistant Coq, and draws on many areas, including probability, complexity, algebra, and semantics of programming languages. Certicrypt provides certified tools to reason about the equivalence of probabilistic programs, including a relational Hoare logic, a theory of observational equivalence, verified program transformations, and game-based techniques such as reasoning about failure events. The usefulness of Certicrypt is demonstrated through various examples, including a proof of semantic security of OAEP (with a bound that improves upon existing published results), and a proof of existential unforgeability of FDH signatures. Our work provides a first yet significant step towards Halevi's ambitious programme of providing tool support for cryptographic proofs.

Relaxed memory models

Memory models define an interface between programs written in some language and their implementation, determining which behaviour the memory (and thus a program) is allowed to have in a given model. A minimal guarantee memory models should provide to the programmer is that well-synchronized, that is, data-race free code has a standard semantics. Traditionally, memory models are defined axiomatically, setting constraints on the order in which memory operations are allowed to occur, and the programming language semantics is implicit as determining some of these constraints. In this work we propose a new approach to formalizing a memory model in which the model itself is part of a weak operational semantics for a (possibly concurrent) programming language. We formalize in this way a model that allows write operations to the store to be buffered. This enables us to derive the ordering constraints from the weak semantics of programs, and to prove, at the programming language level, that the weak semantics implements the usual interleaving semantics for data-race free programs, hence in particular that it implements the usual semantics for sequential code.

Operational ontological approach to formal programming language specification

Development of formal programming language specifications is an important problem of theoretical and practical programming. The paper presents operational ontological approach to formal specification of programming languages. It defines formalism for introduction of operational ontological semantics of programming languages: ontological transition systems, description language for ontological transition systems (OTSL), and methodology of applying the OTSL to the development of formal specifications of programming languages.

Relational Analysis and Precision via Probabilistic Abstract Interpretation

Within the context of a quantitative generalisation of the well established framework of Abstract Interpretation – i.e. Probabilistic Abstract Interpretation – we investigate a quantitative notion of precision which allows us to compare analyses on the basis of their expected exactness for a given program. We illustrate this approach by considering various types of numerical abstractions of the values of variables for independent analysis as well as weakly and fully relational analysis. We utilise for this a linear operator semantics of a simple imperative programming language. In this setting, fully relational dependencies are realised via the tensor product. Independent analyses and weakly relational analyses are realised as abstractions of the fully relational analysis.

Thread algebra for noninterference

Thread algebra is a semantics for recent object-oriented programming languages [J.A. Bergstra and M.E. Loots, J. Logic Algebr. Program. 51 (2002) 125-156; J.A. Bergstra and C.A. Middelburg, Formal Aspects Comput. (2007)] such as C# and Java. This paper shows that thread algebra provides a process-algebraic framework for reasoning about and classifying various standard notions of noninterference, an important property in secure information flow. We will take the noninterference property given by Volpano et al. [D. Volpano, G. Smith and C. Irvine, J. Comput. Secur. 4 (1996) 167-187] on type systems as an example of our approach. We define a comparable notion of noninterference in the setting of thread algebra. Our approach gives a similar result to the approach of [G. Smith and D. Volpano, in POPL'98 29 (1998) 355-364] and can be applied to unstructured and multithreaded programming languages.

Deductive Semantics of RTPA

Deductive semantics is a novel software semantic theory that deduces the semantics of a program in a given programming language from a unique abstract semantic function to the concrete semantics embodied by the changes of status of a finite set of variables constituting the semantic environment of the program. There is a lack of a generic semantic function and its unified mathematical model in conventional semantics, which may be used to explain a comprehensive set of programming statements and computing behaviors. This article presents a complete paradigm of formal semantics that explains how deductive semantics is applied to specify the semantics of real-time process algebra (RTPA) and how RTPA challenges conventional formal semantic theories. Deductive semantics can be applied to define abstract and concrete semantics of programming languages, formal notation systems, and large-scale software systems, to facilitate software comprehension and recognition, to support tool development, to enable semantics-based software testing and verification, and to explore the semantic complexity of software systems. Deductive semantics may greatly simplify the description and analysis of the semantics of complicated software systems specified in formal notations and implemented in programming languages.

Prototyping A&A ReSpecT in Maude

The formal modelling of programming languages has always been a challenging activity due to the gap occurring between formal definition and actual implementation. On the other hand, the Maude rewriting language has already proven to be a suitable tool to bridge the gap between theory and practice when implementing the operational semantics of programming languages. In particular, Maude has been exploited to model languages belonging to different paradigms and levels of abstraction, leading to specifications that represent de facto executable prototypes of such languages.In this paper we focus on A&A ReSpecT, a coordination language based on the agents and artifacts (A&A) meta-model, and exploit Maude to generate an execution machine for A&A ReSpecT programs, acting as an implementation of its operational semantics.

Denotational semantics for programming languages, balanced quasi-metrics and fixed points

A new mathematical model is introduced for the study of the domain of words. We do it by means of the introduction of a suitable balanced quasi-metric on the set of all words over an alphabet. It will be shown that this construction has better quasi-metric and topological properties than several classical constructions. We also prove a fixed point theorem which allows us to develop an application for the study of probabilistic divide and conquer algorithms.

Basic research in computer science and software engineering at SKLCS

The State Key Laboratory of Computer Science (SKLCS) is committed to basic research in computer science and software engineering. The research topics of the laboratory include: concurrency theory, theory and algorithms for real-time systems, formal specifications based on context-free grammars, semantics of programming languages, model checking, automated reasoning, logic programming, software testing, software process improvement, middleware technology, parallel algorithms and parallel software, computer graphics and human-computer interaction. This paper describes these topics in some detail and summarizes some results obtained in recent years.

Building Verification Condition Generators by Compositional Extension

Current mechanizations of programming logics are often in the form of verification condition generators. These front ends to a prover translate a program and assertions into conditions that state that the program fulfills its assertions. Traditional verification condition generators are monolithic encapsulations of a programming language's semantics. This makes it hard to build such verification generators when designing a new language, or when extending a language.We propose a more compositional method of building verification condition generators, using ideas from monadic denotational semantics and from generic programming. Our technique allows us to extend an existing verification condition generator to handle new language constructs, but also to add extensions at another level, such as the ability to generate validation traces. We explain the technique through an example, extending a simple while language with a construct for exception handling. This construct not only needs an extension to the logic, but also a change of its structure.

Free-algebra models for the π -calculus

The finite π -calculus has an explicit set-theoretic functor-category model that is known to be fully abstract for strong late bisimulation congruence. We characterize this as the initial free algebra for an appropriate set of operations and equations in the enriched Lawvere theories of Plotkin and Power. Thus we obtain a novel algebraic description for models of the π -calculus, and validate an existing construction as the universal such model. The algebraic operations are intuitive, covering name creation, communication of names over channels, and nondeterministic choice; the equations then combine these features in a modular fashion. We work in an enriched setting, over a “possible worlds” category of sets indexed by available names. This expands significantly on the classical notion of algebraic theories: we can specify operations that act only on fresh names, or have arities that vary as processes evolve. Based on our algebraic theory of π we describe a category of models for the π -calculus, and show that they all preserve bisimulation congruence. We develop a direct construction of free models in this category; and generalise previous results to prove that all free-algebra models are fully abstract. We show how local modifications to the theory can give alternative models for π I and the early π -calculus. From the theory of π we also obtain a Moggi-style computational monad, suitable for a programming language semantics of mobile communicating systems. This addresses the challenging area of correctly combining computational monads: in this case those for concurrency, name generation, and communication.

Java+ITP: A Verification Tool Based on Hoare Logic and Algebraic Semantics

Java+ITP is an experimental tool for the verification of properties of a sequential imperative subset of the Java language. It is based on an algebraic continuation passing style (CPS) semantics of this fragment as an equational theory in Maude. It supports compositional reasoning in a Hoare logic for this Java fragment that we propose and prove correct with respect to the algebraic semantics. After being decomposed, Hoare triples are translated into semantically equivalent first-order verification conditions (VCs) which are then sent to Maude's Inductive Theorem Prover (ITP) to be discharged. The long-term goal of this project is to use extensible and modular rewriting logic semantics of programming languages, for which CPS axiomatizations are indeed very useful, to develop similarly extensible and modular Hoare logics on which generic program verification tools can be based.

Partial Order Reduction for Rewriting Semantics of Programming Languages

Software model checkers are typically language-specific, require substantial development efforts, and are hard to reuse for other languages. Adding partial order reduction (POR) capabilities to such tools typically requires sophisticated changes to the tool's model checking algorithms. This paper proposes a new method to make software model checkers language-independent and improving their performance through POR. Getting the POR capabilities does not require making any changes to the underlying model checking algorithms: for each language L, they are instead achieved through a theory transformationRL↦RL+POR of L's formal semantics, rewrite theory RL. Under very minimal assumptions, this can be done for any language L with relatively little effort. Our experiments with the JVM, a Promela-like language and Maude indicate that significant state space reductions and time speedups can be gained for tools generated this way.

Understanding Programming Languages

We document the influence on programming language semantics of the Platonism/formalism divide in the philosophy of mathematics.