Bruce J. MacLennan

Values and objects in programming languages

Abstract : The terms value-oriented and object-oriented are used to describe both programming languages and programming styles. This paper will describe the differences between values and objects and to show that their proper discrimination can be a valuable aid to conquering program complexity. The first section will show that values amount to timeless abstractions for which the concepts of updating, sharing and instantiation have no meaning. The second section will show that objects exist in time and, hence, can be created, destroyed, copied, shared and updated. The third section shows that proper discrimination of these concepts in programming languages will clarify problems such as the role of state in functional programming. The paper concludes by demonstrating the use of the value/object distinction as a tool for program organization. (Author)

Overview of relational programming

Abstract : This report provides a brief overview of the method of programming in a relational calculus. This is a style of programming in which entire relations are manipulated as data, and in which the program itself is represented as a relation. This report describes the use of the relational operators to manipulate both data and functions, and introduces an improved notation for relational programming. (AUthor)

Introduction to relational programming

In this paper we discuss relational programming, i.e. a style of programming in which entire relations are manipulated rather than individual data. This analogous to functional programming [1], wherein entire functions are the values manipulated by the operators. We will see that relational programming subsumes functional programming because every function is also a relation. It is appropriate this point to discuss why we have chosen investigate relational programming.

Simple metrics for programming languages

Abstract Several metrics for guiding the design and evaluation of programming languages are introduced. The objective is to formalize notions such as “size”, “complexity”, “orthogonality”, and “simplicity”. Three different kinds of metrics are described: syntactic, semantic, and transformational. Syntactic metrics are based on the size of a context-free grammar for a language or a part of a language. They can be used to judge the size of a language and the relative sizes of its parts. These techniques are demonstrated by their application to Pascal, Algol-60, and Ada. Syntactic metrics make no reference to the meaning of a languages constructs. For this purpose we have developed several semantic metrics that measure the inter-dependencies among the basic semantic ideas in a language. This technique has been applied to the control, data, and name structures of FORTRAN, BASIC, Lisp, Algol-60, and Pascal. Finally, we suggest that a useful measure of a programming language is the complexity of the relationship between its syntactic and semantic structures. For this purpose we introduce a transformational metric and demonstrate its use on subsystems of several languages. The paper concludes by discussing the general principles underlying all of these metrics and by discussing the proper method of validating metrics such as these.

A simple software environment based on objects and relations

This paper presents a simple programming system based on a clear separation of value-oriented programming and object-oriented programming [MacLennan82, MacLennan83a]. The value-oriented component is a conventional functional programming language. The object-oriented component is based on a model of objects and values connected by relations, and on production system-like rules that determine the alteration of these relations through time. It is shown that these few basic ideas permit simple prototyping of a software development environment.

Abstraction in the Intel iAPX-432 prototype systems implementation language

Abstract : This report describes the abstraction mechanism of a prototype systems implementaiton language for Intels iAPX-432 microprocessor. Full exploitation of the 432s facilities places many demands on a language intended for systems implementation. The 432 is a capability-based machine, with hardware-enforced typing of large objects, dynamically instantiated domains (i.e., packages), hardware-enforced information information hiding (seals), and hardware-supported, software-defined access-rights (trademarks). The prototype languages support for these facilities is described in this project.