Wm. A. Wulf

Preliminary) An Informal Definition of Alphard

The Alphard language was designed to support the joint goals of facilitating contemporary programming methodology, encouraging formal specification of programs and verification of those specifications, allowing the programmer to exercise control over details that affect performance, and being able to compile compact, efficient code. This report presents the informal definition of the complete language.

MINICOMPUTER COMPLEXES: PROGRESS AND PROSPECTS

Abstract The economics of computers have reversed since the early 1960s; at that time a phenomenon known as “Groschs law” seemed to hold. Groschs law asserted that the power of a computer was related to the square of its cost. More recently, however, mass production of mini and micro computers has made them more costeffective (in

Introducing "theory" in the second programming course

/computation) than large machines. This reversal has a number of implications, one of which is that the “right” way to build large machines may be as an assembledge of a large number of these smaller processors. This implication was recognized several years ago and spawned several research projects; each of these projects took a somewhat different approach to the problem of interconnecting many small processors to deliver the power of a large machine. This paper will: (1) expand on the problems and potentials of interconnected mini (or micro) computers, (2) assess the progress to date in realizing the potential of some of these systems, and (3) take another look at the future prospects for these systems.

Language design for the Ironman requirement: notes and examples

Traditionally, the first two programming courses have emphasized basic techniques and skills—the details of a programming language, basic problem solving and program development, “structured programming”, the manipulation of simple data structures and files, basic sorting and searching algorithms, etc. Our principle motivation is the conviction that programming should be an engineering discipline, and that engineering disciplines must be grounded in engineering science. Further, to be effectively taught, this science must be introduced as early as possible. In contrast to the measure-theoretic under pinnings of the calculus, the theory we introduce is immediately useful to working programmers. In addition, the topics we cover are fundamental to later courses. By introducing the topics early in the curriculum, we provide a common vocabulary for these later courses, eliminate redundant treatment of topics, and give students greater exposure to the material and a better chance to absorb it. We feel we have been successful with the course, although our evidence is necessarily subjective. Because its philosophy flies in the face of current practice, we shall attempt to explain that philosophy in this paper. The course itself, “Fundamental Structures of Computer Science” (FS here after) is described in somewhat greater detail in [2] and we are preparing a supporting text [3]. We are not so much interested in pressing our own particular treatment of the topics, however, as we are the choice of material and its place in the curriculum.

Abstraction and verification in Alphard: Defining and specifying iteration and generators

The Tartan language was designed as an experiment to see whether the Ironman requirement for a common high-order programming language could be satisfied by an extremely simple language. The result, Tartan substantially meets the Ironman requirement. We believe it is substantially simpler than the four designs that were done in the first phase of the DOD-1 effort. The language definition appears in a companion report; this report provides a more expository discussion of some of the languages features, some examples of its use, and a discussion of some facilities that could enhance the basic design at relatively little cost.

Global variable considered harmful

The Alphard form provides the programmer with a great deal of control over the implementation of abstract data types. In this paper we extend the abstraction techniques from simple data representation and function definition to the iteration statement , the most important point of interaction between data and the control structure of the language itself. We introduce a means of specializing Alphards loops to operate on abstract entities without explicit dependence on the representation of those entities. We develop specification and verification techniques that allow the properties of the generators for such iterations to be expressed in the form of proof rules. We obtain results for common special cases of these loops that are essentially identical to the corresponding constructs in other languages. We also provide a means of showing that a generator will terminate.