Abstract There is an effective and quite general method of manually deriving compilers from programming‐language interpreters without dealing directly with machine language. The method is an implementation of the largely theoretical and under‐appreciated concept of partial computation, but can be understood on its own terms. It involves the translation of a source program's intermediate form into the interpreter's implementation language. This paper shows how the method can be used to transform both a sample iterative interpreter and a sample recursive interpreter into compilers. The result can be a large gain in program execution speed. Other advantages of the method, including the ease and practicality of applying it, are discussed.

A framework for a system of charts compatible with the use of applicative programming languages is proposed and illustrated. The charts are similar in spirit to the structured flowcharts that have sometimes been used with algorithmic languages. They are based on a method of representing the structure of nested expressions of arbitrary complexity. This method is adaptable to the incorporation of graphical devices for the depiction of local identifier bindings, conditional expressions, recursive function definitions, and the various functional combining forms employed in the FP-style of applicative programming.

Abstract We describe an approach to, and a case study of, the construction of complete programming language descriptions that are at the same time formal and readily understandable. Such a description includes integrated specifications for abstract and textual syntax, context conditions (static semantics) and dynamic semantics. The imetalanguage is a powerful program design language based on a real general‐purpose programming language. The specifications are presented not as a monolithic block but as an intellectually manageable sequence of sections and subsections with a carefully designed format and cross‐referencing scheme. The approach could reduce the need to choose between formality and understandability in a language reference manual.

The concept of abstract syntax is commonly applied to the formal specification of programming language semantics and is also useful in the broader context of software design. This paper proposes a scheme for the representation of abstract syntax specifications in the form of easily understood charts. The structuring primitives considered are those of scalar enumeration, heterogeneous aggregation, homogeneous lists and sets, disjunction, and partial functions. Secondarily, a related system of charts for depicting particular objects with a given structure is proposed. Examples are given to illustrate the use of these diagrammatic notations in the contexts of language description and software design and documentation.

The metalinguistic formalism of two-level grammars (W-grammars) is known to be capable of precisely defining the dynamic semantics of certain features of programming languages in a fairly understandable fashion. This paper demonstrates that its application to low-level control facilities—labels and goto statements—is not only possible but also reasonably straightforward and manageable. Moreover, the extra definitional complexity that arises when there is a mixture of low-level and high-level (if-then-else, while-do, etc.) facilities does not appear to be any worse than it is with other approaches to semantic specification.

A strategy for the formalisation of the syntactic aspects – abstract syntax, textual (or concrete) syntax, and context conditions (or ‘static semantics’) – of programming languages is described. The strategy emphasises the centrality of abstract syntax in a complete language definition and is compatible with the principle of using a general purpose programming language as a metalanguage. The proposed technique for specifying (using a set of mutually recursive procedures) textual syntax and its relationship to abstract syntax provide a sort of programming language counterpart of BNF as far as overall structure is concerned, and the technique for specifying (using another set of mutually recursive procedures) context conditions parallels the use of attribute grammars or two-level grammars for the same purpose. The techniques are illustrated using the miniature language Asple.

The possibility of using ALGOL 68 as a metalanguage for ‘denotational’ definitions of the semantics of programming languages is considered, using the simple language LOOP as an example. The approach is found to be a viable one if the ‘partial parametrisation’ feature is added to ALGOL 68. The advantages of using a general purpose programming language as a definitional medium are briefly discussed.

Abstract A highly‐structured and conceptually simple processor, written in Algol 68, for a basic but useful subset of SNOBOL4 is presented. It provides a significant, large‐scale demonstration of a particular methodology for constructing ‘master’, machine‐independent implementations of programming languages. The processor is closely related to a formal operational definition of the SNOBOL4 subset in that it incorporates an abstract machine, a high‐level abstract syntax (in the form of mutually recursive mode definitions) for the internal form of programs, and a set of mutually recursive interpretation procedures for programs in this internal form. The various aspects of the processor are documented in some detail. The experience of testing the processor is briefly discussed.

The constructive approach to the formal definition of the semantics of programming languages has much in common with the notion that a language can be defined by an actual processor which compiles or interprets programs written in that language. The two approaches can be unified if the processor is written in a sufficiently powerful and expressive high-level language so that it closely models a formal definition for the processed language. The resulting processor has the conceptual clarity of the formal scheme as well as the advantages of being executable on a real computer. These points are illustrated by exhibiting a formal definition of a minilanguage using the Vienna Definition Language and an equivalent definition using ALGOL 68.