A Denotational Engineering of Programming Languages

ArXiv, 2019

Denotational models should provide an opportunity for the revision of current practices seen in the manuals of programming languages. New styles should on one hand base on denotational models but on the other - do not assume that today readers are acquainted in this field. A manual should, therefore, provide some basic knowledge and notation needed to understand the definition of a programming language written in a new style. At the same time - I strongly believe that - it should be written for professional programmers rather than for amateurs. The role of a manual is not to teach the skills of programming. Such textbooks are, of course, necessary, but they should tell the readers what the programming is about rather than the technicalities of a concrete language. The paper contains an example of a manual for a virtual programming language Lingua developed in our project.

Proceedings of the 7th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL '80, 1980

about a year I have worked on a semantic specification for the C programming language My objecti~e was to construct a readable and precise specification of C. aimed at compiler writers, maintamers, and language pundm, This paper is a report on the project, * UNIX is a trademark of Bell Laboratories.

2016

In these lecture notes we present a few basic approaches to the definition of the semantics of programming languages. In particular, we present: (i) the operational semantics and the axiomatic semantics for a simple imperative language, and (ii) the operational semantics and the denotational semantics for some first order and higher order, typed functional languages. We then present some basic techniques for proving properties of imperative, functional, and concurrent programs. We closely follow the presentation done in the book by Glynn Winskel [19]. I express my gratitude to my colleagues at the Department of Informatics, Systems, and Production of the University of Roma Tor Vergata, and to my students and my co-workers Fabio Fioravanti, Fulvio Forni, Maurizio Proietti, and Valerio Senni for their support and encouragement. Thanks to Michele Ranieri and Massimiliano Macchia for pointing out some imprecisions in a preliminary version of these lecture notes. Many thanks also to the Aracne Publishing Company for its helpful cooperation.

2018

We present a novel approach to construction of a formal semantics for a programming language. Our approach, using a parametric denotational semantics, allows the semantics to be easily extended to support new language features, and abstracted to define program analyses. We apply this in analysing a duck-typed, reflective, curried dynamic language. The benefits of this approach include its terseness and modularity, and the ease with which one can gradually build language features and analyses on top of a previous incarnation of a semantics.

Communications of the ACM, 1966

Electronic Proceedings in Theoretical Computer Science

Many universities have courses and projects revolving around compiler or interpreter implementation as part of their degree programmes in computer science. In such teaching activities, tool support can be highly beneficial. While there are already several tools for assisting with development of the front end of compilers, tool support tapers off towards the back end, or requires more background experience than is expected of undergraduate students. Structural operational semantics is a useful and mathematically simple formalism for specifying the behaviour of programs and a specification lends itself well to implementation; in particular bigstep or natural semantics is often a useful and simple approach. However, many students struggle with learning the notation and often come up with ill-defined and meaningless attempts at defining a structural operational semantics. A survey shows that students working on programming language projects feel that tool support is lacking and would be useful. Many of these problems encountered when developing a semantic definition are similar to problems encountered in programming, in particular ones that are essentially the result of type errors. We present a pedagogical metalanguage based on natural semantics, and its implementation, as an attempt to marry two notions: a syntax similar to textbook notation for natural semantics on the one hand, and automatic verification of some correctness properties on the other by means of a strong type discipline. The metalanguage and the tool provide the facilities for writing and executing specifications as a form of programming. The user can check that the specification is not meaningless as well as execute programs, if the specification makes sense.

Electronic Notes in Theoretical Computer Science, 2006

These notes give an overview of the main frameworks that have been developed for specifying the formal semantics of programming languages. Some of the pragmatic aspects of semantic descriptions are discussed, including modularity, and potential applicability to visual and modelling languages. References to the literature provide starting points for further study.

2000

Programming language semantics has lost touch with large groups of potential users [39]. Among the reasons for this unfortunate state of affairs, one stands out. Semantic results are rarely incorporated in practical systems that would help language designers to implement and test a language under development, or assist programmers in answering their questions about the meaning of some language feature not properly documented in the language's reference manual.

2012

These notes are designed to accompany 8-10 lectures on denotational semantics for Part II of the Cambridge University Computer Science Tripos. Some of the material of this course (roughly, the first half) used to form part of courses on semantics of programming languages for Parts IB/II. The Part IB course on Semantics of Programming Languages is a prerequisite. Tripos questions Of the many past Tripos questions on programming language semantics, here are those which are relevant to the current course and predate those available from the Lab webpage-all denotational semantics questions available from the Lab webpage are relevant.

2008

Unlike natural languages, programming languages are strictly stylized entities created to facilitate human communication with computers. In order to make programming languages recognizable by computers, one of the key challenges is to describe and implement language syntax and semantics such that the program can be translated into machine-readable code. This process is normally considered as the front-end of a compiler, which is mainly related to the programming language, but not the target machine.

A_LispKit Lisp programming language is described in terms of a modified denotational semantics approach. The functional programming language A_LispKit Lisp, developed in the Institute of Mathematics Novi Sad in 1991/92, is described, by a new technique of the defining semantics -denotational approach combined with some object oriented view.

ACM Transactions on Programming Languages and Systems, 1994

Logic-programming languages are based on a principle of separation of "logic" and "control." This means that they can be given simple model-theoretic semantics without regard to any particular execution mechanism (or proof procedure, viewing execution as theorem proving). Although the separation is desirable from a semantical point of view, it makes sound, efficient implementation of logic-programming languages difficult. The lack of "control information" in programs calls for complex data-flow analysis techniques to guide execution. Since data-flow analysis furthermore finds extensive use in error-finding and transformation tools, there is a need for a simple and powerful theory of data-flow analysis of logic programs. This paper offers such a theory, based on F. Nielson's extension of P. Cousot and R. Cousot's abstract interpretation. We present a denotational definition of the semantics of definite logic programs. This definition is of interest in its own right because of its compactness. Stepwise we develop the definition into a generic data-flow analysis that encompasses a large class of data-flow analyses based on the SLD execution model. We exemplify one instance of the definition by developing a provably correct groundless analysis to predict how variables may be bound to ground terms during execution. We also discuss implementation issues and related work.

Sigplan Notices, 2002

The Alloy Annotation Language (AAL) is a language (under development) for annotating Java code based on the Alloy modeling language. It offers a syntax similar to the Java Modeling Language (JML), and the same opportunities for generation of run-time assertions. In addition, however, AAL offers the possibility of fully automatic compile-time analysis. Several kinds of analysis are supported, including: checking the code of a method against its specification; checking that the specification of a method in a subclass is compatible with the specification in the superclass; and checking properties relating method calls on different objects, such as that the equals methods of a class (and its overridings) induce an equivalence. Using partial models in place of code, it is also possible to analyze object-oriented designs in the abstract: investigating, for example, a view relationship amongst objects.

Theoretical Computer Science, 1994

Science 135 (I 994) 267-288 Elsevier 267

An approach to formal specification of programming languages is proposed. This approach considers specifications of programming languages as query ontologies. Concepts of these ontologies denote sets of natural-language-like queries. We hope that it makes the specifications human-oriented. The approach is based on a formalism that we call query evolving systems. A special kind of these systems (called ontological query evolving systems) is used to define query ontologies. A query evolving system A is defined as a triple (B, C, D), where B is a set of names, (C, D) is a transition system with the set C of states and the transition relation D called an evolving relation.