David Alex Lamb

Spelling correction in user interfaces

The feasibility of providing a spelling corrector as a part of interactive user interfaces is demonstrated. The issues involved in using spelling correction in a user interface are examined, and a simple correction algorithm is described. The results of an experiment in which the corrector is incorporated into a heavily used interactive program are described. More than one quarter of the errors made by users during the experiment were corrected using the simple mechanisms presented here. From this we have concluded that there are considerable benefits and few obstacles to providing a spelling corrector in almost any interactive user interface.

Construction of a peephole optimizer

The design and construction of a peephole optimizer is described. The optimizer consists of a database of patterns, a translator that translates the patterns into an implementation language, and a pattern‐matcher skeleton into which the generated pattern code is inserted. it is argued that this three‐part split is a good way to approach the construction of certain kinds of programs.

Simulation of Procedure Variables Using Ada Tasks

We give a technique for partially simulating procedure variables using Ada tasks. The simulation involves using interface tasks, a technique which may be useful for other problems.

Evaluation of computer architectures via test programs

This article presents the evaluation of the Computer Family Architecture (CFA) candidate architectures via a set of test programs. The measures used to rank the computer architectures were S, the size of the test program, and M and R, two measures designed to estimate the principal components contributing to the nominal execution speed of the architecture. Descriptions of the twelve test programs and definitions of the S, M, and R measures are included here. The statistical design of the assignment of test programs to programmers is also discussed. Each program was coded from two to four times on each machine to minimize the uncertainty due to programmer variability. The final results show that for all three measures (S, M, and R) the Interdata 8/32 is the superior architecture, followed closely by the PDP-11, and the IBM S/370 trailed by a significant margin.

The Charrette Ada compiler

The Charrette Ada compiler is a working compiler for a substantial subset of the preliminary Ada language. The Ada source program is translated into an equivalent program in an intermediate implementation language. The result of the compilation process is machine language generated for this intermediate program.This paper provides a brief overview of the compiler with special attention given to the primary translation phase. Emphasis is placed on the transformation of Ada type and subtype information and the representation of objects. The translation of several interesting statement and expression forms is also outlined.

An Ada code generator for VAX 11/780 with Unix

This paper describes the final phase of an Ada compiler which produces code for the VAX 11/780 running the Unix operating system. Problems encountered in the implementation of subprogram calls, parameter passing, function return values, and exception handling are discussed and their solutions outlined. An underlying requirement for the code generator has been speed of implementation consistent with being a test bed for an Ada implementation. To accomplish this, a common model for the target environment has been assumed. The assumptions include: the VAXis a stack machine, a single address space is used, only the general case is implemented (no optimization of special cases), the hardware does as much work as possible, run time routines for lengthy code sequences are acceptable, and the conventions given in the VAX architecture, hardware, and software manuals are used. The code generator has been running on a PDP-10 with Tops-10, producing a VAX assembly language source program as output. It has been available to local users since the beginning of 1980.

A runtime representation for Ada variables and types

The type and subtype facilities of the Ada programming language permit some subtype information to be determined dynamically. This subtype information requires a runtime representation, and its dynamic nature influences the representation of variables. In this paper, we first review Adas types and subtypes to identify some of those aspects which affect runtime representation. We then present the particular representation scheme which is used in the CHARRETTE Ada implementation. The scheme is straightforward and consistent in that a variable is represented the same way independently of where it appears, whether it is on the stack, on the heap, or a component of another variable. The design treats Adas discriminants and discriminant constraints as a form of parameterized types, where the parameterization permits different instances of a type to have different variants and different sizes for array fields. Composition of such parameterized types is supported. We explain how several Ada operations are handled by our particular representation. We briefly discuss some alternative approaches to Ada representation, comparing them to our design.