This paper suggests that input and output are basic primitives of programming and that parallel composition of communicating sequential processes is a fundamental program structuring method. When combined with a development of Dijkstra's guarded command, these concepts are surprisingly versatile. Their use is illustrated by sample solutions of a variety of a familiar programming exercises.

/pdf/communicating-sequential-processes-2j6tdrg5nx.pdf

Communicating sequential processes

https://www.inf.ed.ac.uk/teaching/courses/seoc/2005_2006/resources/statecharts.pdf

Statecharts: A visual formalism for complex systems

https://cmi.ac.in/~madhavan/courses/verification-2011/alur-dill-tcs-94.pdf

A theory of timed automata

A program denotes computations in some universe of objects. Abstract interpretation of programs consists in using that denotation to describe computations in another universe of abstract objects, so that the results of abstract execution give some information on the actual computations. An intuitive example (which we borrow from Sintzoff [72]) is the rule of signs. The text -1515 * 17 may be understood to denote computations on the abstract universe {(+), (-), (±)} where the semantics of arithmetic operators is defined by the rule of signs. The abstract execution -1515 * 17 → -(+) * (+) → (-) * (+) → (-), proves that -1515 * 17 is a negative number. Abstract interpretation is concerned by a particular underlying structure of the usual universe of computations (the sign, in our example). It gives a summary of some facets of the actual executions of a program. In general this summary is simple to obtain but inaccurate (e.g. -1515 + 17 → -(+) + (+) → (-) + (+) → (±)). Despite its fundamentally incomplete results abstract interpretation allows the programmer or the compiler to answer questions which do not need full knowledge of program executions or which tolerate an imprecise answer, (e.g. partial correctness proofs of programs ignoring the termination problems, type checking, program optimizations which are not carried in the absence of certainty about their feasibility, …).

/pdf/abstract-interpretation-a-unified-lattice-model-for-static-2jfaix0dre.pdf

Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints

A unified approach to program verification is suggested, which applies to both sequential and parallel programs. The main proof method suggested is that of temporal reasoning in which the time dependence of events is the basic concept. Two formal systems are presented for providing a basis for temporal reasoning. One forms a formalization of the method of intermittent assertions, while the other is an adaptation of the tense logic system Kb, and is particularly suitable for reasoning about concurrent programs.

The temporal logic of programs

Parallel programming: An axiomatic approach

Object-oriented programs [5, 6, 10] are notoriously prone to the following kinds of error, which could lead to increasingly severe problems in the presence of tasking: 1. Following a null pointer; 2. Deletion of an accessible object; 3. Failure to delete an inaccessible object; 4. Interference due to equality of pointers; and 5. Inhibition of optimisation due to fear of (4). Type disciplines and object classes are a great help in avoiding these errors. Stronger protection may be obtainable with the help of assertions, particularly invariants, which are intended to be true before and after each call of a method that updates the structure of the heap. This note introduces a mathematical model and language for the formulation of assertions about objects and pointers, and suggests that a graphical calculus [4] may help in reasoning about program correctness. It deals with both garbage-collected heaps and the other kind. The theory is based on a trace model of graphs, using ideas from process algebra; and our development seeks to exploit this analogy as a unifying principle.

A trace model for pointers and objects

I propose a set of criteria which distinguish a grand challenge in science or engineering from the many other kinds of short-term or long-term research problems that engage the interest of scientists and engineers.

/pdf/the-verifying-compiler-a-grand-challenge-for-computing-5g15j5jrsh.pdf

The Verifying Compiler: A Grand Challenge for Computing Research

Assertions are Boolean formulas placed in program text at places where their evaluation will always be true. If the assertions are strong enough, they express everything that the programmers on either side of an interface need to know about the program on the other side, even before the code is written. Indeed, assertions can serve as the basis of a formal proof of the correctness of a complete program.

/pdf/assertions-a-personal-perspective-4lr92zl1lz.pdf

Assertions: a personal perspective

A computer program is identified with the strongest predicate describing every relevant observation that can be made of the behaviour of a computer executing that program. A programming language is a subset of logical and mathematical notations, which is so restricted that products described in the language can be automatically implemented on a computer. The notations enjoy a number of elegant algebraic properties, which can be used for optimizing program efficiency. A specification is a predicate describing all permitted observations of a program, and it may be expressed with greatest clarity by taking advantage of the whole language of logic and mathematics. A program P meets its specification S iff [Note: Equation omitted. See the image of page 475 for this equation.]. The proof of this implication may use all the classical methods of mathematics and logic. These points are illustrated by design of a small language that includes assignments, conditionals, non-determinism, recursion, input, output, and concurrency.

C. A. R. Hoare

Papers

Parallel programming: An axiomatic approach

A trace model for pointers and objects

The Verifying Compiler: A Grand Challenge for Computing Research

Assertions: a personal perspective

Programs are predicates