No full-text available
To read the full-text of this research,
you can request a copy directly from the author.
The systematic design of file‐processing programs
Abstract
The theory of formal languages is applied to the systematic top-down design of file processing programs. A methodology is described which leads to well structured programs for a large class of data processing problems. The method leads to more reliable programs because it is easier to check the method steps than an intuitive program. The method and its limitations are illustrated by the design process for some data processing programs. The limitations of the method are explained as the result of a theorem about formal languages.
Based on a review of textbooks and literature and discussion with information systems educators, the use of structured concepts began to be taught in programming classes in the early 1970s. The classic articles on structured programming and analysis/design, respectively, are the following: “Flow Diagrams, Turing Machines, and Languages with Only Two Formation Rules,” by Bohm, C. and Jacopini, G. Communications of the ACM, Volume 9, Number 5, pp. 366-371, May 1966. “Structured Design,” by Stevens, W. P.; Myers, G. J.; and Constantine, L. L. IBM Systems Journal, Volume 13, Number 2, pp. 115-139, 1974.
The key to Jackson's Program Design Method is the definition of the inputs and outputs of a program as labelled trees and the recognition of a correspondence between them.
This paper gives a more formal definition of the trees and the correspondence. These definitions are then used to explain his basic method and methods for ‘structure clashes’ by reference to formal language theory.
A method of program design is described which leads naturally to the expression of a program as a pipeline network of simple processes. Starting from the problem statement the valid inputs and outputs are specified by grammars, which can be combined to define the requisite translation. A notation for translation grammars is described informally which allows a translation to take into account semantic as well as syntactic information. Terminal symbols may be attributed by data types and may be qualified by Boolean expressions. The notation is capable of direct compilation but in this paper we show how it may be used to derive a program in a conventional high level language such as Pascal or Cobol. It is shown that more complex problems can be solved by simple pipeline structures of simple translations. Provided that nonbacktracking grammars are used to specify translations, the pipeline structure is well-suited to concurrent execution on a multiprocessor. The method is illustrated by examples from data processing.
Design of sequential programs, based on structures of input and output streams
From the Preface (See Front Matter for full Preface) The study of formal languages constitutes an important subarea of computer science. This area sprang to life around 1956 when Noam Chomsky gave a mathematical model of a grammar in connection with his study of natural languages. Shortly afterwards, the concept of a grammar was found to be of great importance to the programmer when the syntax of the programming language ALGOL was defined by a context-free grammar. This development led naturally to syntax-directed compiling and the concept of a compiler compiler. Since then a considerable flurry of activity has taken place, the results of which have related formal languages and automata theory to such an extent that it is impossible to treat the areas separately. By now, no serious study of computer science would be complete without a knowledge of the techniques and results from language and automata theory. This book presents the theory of formal languages as a coherent theory and makes explicit its relationship to automata. The book begins with an explanation of the notion of a finite description of a language. The fundamental descriptive device--the grammar--is explained, as well as its three major subclasses--regular, context-free, and context-sensitive grammars. The context-free grammars are treated in detail, and such topics as normal forms, derivation trees, and ambiguity are covered. Four types of automata equivalent to the four types of grammars are described. These automata are the finite automaton, the pushdown automaton, the linear bounded automaton, and the Turing machine. The Turing machine is covered in detail, and unsolvability of the halting problem shown. The book concludes with certain advanced topics in language theory--closure properties, computational complexity, deterministic pushdown automata, LR(k) grammars, stack automata, and decidability.
This study focuses largely on two issues: (a) improved syntax for iterations and error exits, making it possible to write a larger class of programs clearly and efficiently without ″go to″ statements; (b) a methodology of program design, beginning with readable and correct, but possibly inefficient programs that are systematically transformed in necessary into efficent and correct, but possibly less readable code. The discussion brings out opposing points of view about whether or not ″go to″ statements should be abolished; some merit is found on both sides of this question. Finally, an attempt is made to define the true nature of structured programming, and to recommend fruitful directions for further study.