Richard B. Kieburtz

Extending Concurrent Pascal to Allow Dynamic Resource Management

In Concurrent Pascal, the syntactic and semantic definition of the language prevents the inadvertent definition of a program that might violate the integrity of a shared data object. However, the language also does not allow the dynamic allocation of reusable resources among processes, and this restriction seems unnecessarily stingent. This paper proposes the addition to Concurrent Pascal of a new type of program component, to be called a resource manager. By this means, dynamic resource allocation can be accomplished both safely and efficiently. The notion that a process holds access rights to a resource is generalized to the notion that it holds capability rights, but the capability to atually make use of a resource is granted dynamically. The anonymity of dynamically allocatable resources is also guaranteed.

Transformations of FP program schemes

The perceived inefficiency in execution functional programming languages has been an obstacle to their widespread acceptance. Consequently, algorithms are often coded for efficient execution at the expense of clarity. This compromises the functional style, which is the prime advantage of such languages. We argue that high-level program transformations can relieve the programmer from concern for efficiency in many instances. We present several transformations applicable to FP program schemes, and show how these may be proven using fixpoint induction. We also show how specific subalgebras may be exploited to develop more specialised transformations, and suggest that this may be the most fruitful direction for further efforts to take. Comparison with earlier work on transformations reveals that the use of variables in LISP-like languages has often interfered with the identification of superficially dissimilar programs as instances of a common scheme. A variable-free notation such as FP has proven easier to work with.

Comments on “Communicating Sequential Processes”

In his recent paper, “Communicating Sequential Processes” (Comm. ACM 21, 8 (Aug. 1978), 666-677), C.A.R. Hoare outlines a programming language notation for interprocess communication in which processes are synchronized by the messages they exchange. The notation carries with it certain implications for the synchronization protocols required in a message transfer. These are not at all obvious and are made explicit here. An alternative convention is suggested in which communication and synchronization are partially uncoupled from one another.

Programming without pointer variables

The presence of pointer variables in high level programming languages constitutes an artifact originally introduced to support the representation of recursive data structures. Programming practice has come to rely on pointer variables for their originally intended use, and for several others as well. Their use adds to the complexity of stating algorithms by forcing one to conceptualize data representations in which storage addressing is made manifest. In addition, the use of pointer variables allows one to refer to a common data object by a multiplicity of names, a phenomenon we call the alias variable problem, Alias variables make the verification of program behavior substanially more difficult, and frustrate the goals of modular decomposition. In this paper, we consider alternatives to the use of pointer variables in programming. One of these alternatives is the inclusion of a class of data abstractions based on recursively defined data types. The representational power of the proposed data types is characterized formally, and some issues of implementation and efficiency of programs are discussed.

Global Context Recovery: A New Strategy for Syntactic Error Recovery by Table-Drive Parsers

Described is a method for syntactic error recovery that is compatible with deterministic parsing methods and that is able to recover from many errors more quickly than do other schemes because it performs global context recovery. The method relies on fiducial symbols, which are typically reserved key words of a language, to provide mileposts for error recovery. The method has been applied to LL(1) parsers, for which a detailed algorithm is given, and informally proved correct. The algorithm will always recover and return control to the parser if the text being analyzed satisfies only minimal requirements: that it contains one or more occurrences of fiducial symbols following the point at which an error is detected. Tables needed for error recovery have been automatically generated, along with parsing tables, by a parser constructor for the LL(1) grammars. A theoretical characterization of fiducial symbols is given, and the utility of this characterization in practice is discussed. It has been applied to a grammar for the programming language Pascal to aid in selection of a set of fiducial symbols. The error recovery scheme has been tested on a set of student-written Pascal program texts and is compared with other error recovery strategies.

TOMAL: a high-level programming language for microprocessor process control applications

This paper describes the multi-tasking capabilities of a new microprocessor programming language that has been designed to support process control applications. A program in TOMAL is a collection of tasks, priority ordered, and possibly having real-time response constraints and internal synchronization statements. It also supports device-independent I/O programming, by allowing the characteristics of each external device to be given in a declaration. A TOMAL source program is translated into space-optimized, absolute code for a target microprocessor. The object program runs under the control of a compact, application-tailored Task Control Monitor that is also generated by the compiler. The paper discusses design philosophy and several important requirements of an implementation to achieve multi-tasking capabilities.

Access-Right Expressions

data types, and in particular those that are designed to provide resources for use by concurrently executable programs, are often designed to be used only in certain ways. The intended constraints on use of an instance of such a type can be expressed in two principal ways: as assertions on the domain of values input to each operator, and as constraints on the sequences in which the operators of the type can be called by a customer process. These constraints must be enforced in the environment in which an instance of the type is used. Nevertheless, they are very much a part of the type specification, for its definition is not complete, nor can the consistency of its representation be proved, without them. A notation is provided in which to express sequential constraints, which are here called accessright expressions. It is suggested that these expressions should be declared in a programming language that supports the definition of monitors or resource managers. Implications for the proof rules of monitors are discussed, and suggestions are made for a programming language implementation.

Global context recovery: A new strategy for parser recovery from syntax errors

Methods for error recovery in parsing a deterministic, context-free language need not be derived by ad hoc means. When fixed, table-driven parsing algorithms are used the error recovery procedures can also make use of knowledge about the grammar for the language, derived from the parsing tables. However, at the point of detection of certain kinds of syntax errors, the knowledge of a sentential prefix already parsed, as reflected in the current state of the parsing stack, will be incorrect. Effective error recovery under such circumstances has proven to be difficult. We suggest the use of fiducial, or trustworthy symbols of a language as a key to recovery in these difficult cases. In this paper we give a characterization of such symbols in terms of properties of a grammar and give an algorithm that is capable of global context recovery under all circumstances. It has been implemented in conjunction with an LL(1) parser. We have compared it experimentally with the LR-parser recovery algorithm of Pennello and DeRemer on a test set of 126 small Pascal programs.

Construction of asymptotic solutions to scattering problems in the fourier transform representation

It is shown that the construction of a high-frequency asymptotic solution for the problem of a slit can be greatly simplified in the Fourier transform representation. This is accomplished by iterative solution of a pair of coupled integral equations whose kernels are the Greens functions for two isolated half planes.

The external consistency of abstract data types

In the definition of an abstract data type, much attention is given to specifying how instances of the type are to behave when they are used as intended. Such specifications are used to guide the choice of a representation for the type, and to verify that an implementation is correct. An equally important task, but one that has been relatively overlooked until now, is to specify clearly what are the circumstances of intended use of the type. These specifications must also be made use of if one is to certify that an implementation will produce the behavior that is anticipated. This paper addresses the specification of the environment and the mode of use to be made of instances of an abstract type, and shows how these can be incorporated into the type definition itself.