Showing papers in "Communications of The ACM in 1963"

Revised report on the algorithm language ALGOL 60

Abstract: a survey of the basic coustituents arid fcuturcs of the language is given, and the formal notation, by which the syntactic structure is defined, is esplaincd. The sccnnd chapter lists all the basic symbols, and the syntactic units known as identifiers, numbers and strings are defined. Further, some im.portant notions such as cliiantity and value are defined. The third chapter explains the rules for forming expressions and the meaning of these expressions. Three different types of expressions exist: arithmetic, Boolean (logical) and designational. The fourth chapter describes the operational units of the language, known as statements. The basic statements are : assignment statements (evaluation of a formula), go to statements (explicit break of the sequence of execution of statements), dummy statements, and procedure statements (call for execution of a closed process, defined by a procedure declaration). The formation of more complex structures, having statement character, is explained. These include : conditional statements, for statements, compound statements, and blocks. In the fifth chapter, the units known as declarations, serving for defining permanent properties of the units entering into a process described in the language, are defined. The report ends with two detailed examples of the use of the language and an alphabetic index of definitions.

Design of a separable transition-diagram compiler

Abstract: A COBOL compiler design is presented which is compact enough to permit rapid, one-pass compilation of a large subset of COBOL on a moderately large computer Versions of the same compiler for smaller machines require only two working tapes plus a compiler tape The methods given are largely applicable to the construction of ALGOL compilers

Systematic mistake analysis of digital computer programs

Abstract: Effective program checkout is imperative to any complex computer program. One or more test eases are always run for a program before it is considered ready for application to the actual problem. Each test ease checks that portion of the program actually used in its computation. To() Often, however, mistakes show up as late as several months (or even years) after a program has been put into operation. This is an indication that portions of the program called upon only by rarely occurring input conditions have not been properly tested during the checkout stage. In order to rely with confidence upon any particular program, it is not sufficient to know that the program works most of the time or even that it has never made a mistake so far. The real question is whether it, can be counted upon to fulfill its functional specifications sueeessfully every single time. This means that, after a program has passed the eheekout stage, there should be no possibility that an unusual combination of input data or conditions ,nay bring to light an unexpected mistake in the program. Every portion of tile program must be utilized during checkout in order/ ,hat its correctness may be confirmed. The purpose of work reported here has been to develop a systematic way in which a programmer may test, all realistic combinations of input data, and hence all portions of a given program. Although at first this seems to be an arduous task, its handling is simplified by an orderly approach, and its reward is a greater assurance of the correctness and reliability of the program. The potential number of test cases is given by 2 n, where B is the number of branchpoints in the flowchart. The computer could be programed to generate all of these cases automatically. However, if the number of branchpoints is at all large,

Use of tree structures for processing files

Abstract: In data processing problems, files are frequently used which must both be searched and altered. Binary search techniques are efficient for searching large files, but the associated file organization is not readily adapted to the file alterations. Conversely, a chained file allocation permits e 1 cient alteration but cannot be searched efficiently. A file organized into a tree-like structure is discussed, and it is shown that such a file may both be searched and altered with times proportional to s logsN, where N is the number of file items and s is a parameter of the tree. It is also shown that optimizing the value of s leads to a search time which is only 25 per cent slower than the binary search. The tree organization employs two data chains and may be considered to be a compromise between the organizations for the binary search and the chained file. The relation of the tree organization to multidimensional indexing and to the trie structure is also discussed.

An exponential method of numerical integration of ordinary differential equations

Abstract: A formula for numerical integration is prepared, which involves an exponential term. This formula is compared to two standard integration methods, and it is shown that for a large class of differential equations, the exponential formula has superior stability properties for large step sizes. Thus this formula may be used with a large step size to decrease the total computing time for a solution significantly, particularly in those engineering problems where high accuracy is not needed.

American standard code for information interchange

Abstract: There was the germ of an idea in two previous papers [1, 2] which no one seems to have picked up in almost five years For certain functions it seems desirable to transform the argument to a short range symmetric about 10 I will give examples of this usage for the square root and logarithm function for both binary and decimal machines

Computer-drawn flowcharts

Abstract: To meet the need for improved documentation of written computer programs, a simple system for effective communication is presented, which has shown great promise. The programmer describes his program in a simple format, and the computer prepares flow charts and other cross-referenced listings from this input. The description can be kept up-to-date easily, and the final output clearly explains the original program. The system has also proved to be a valuable debugging and coding aid.

An error-correcting parse algorithm

Abstract: During the past few years, research into so-called “Syntax Directed Compiler” and “Compiler Compiler” techniques [1, 2, 3, 4, 5, 6] has given hope that constructing computer programs for translating formal languages may not be as formidable a task as it once was. However, the glow of the researchers' glee has obscured to a certain extent some very perplexing problems in constructing practical translators for common programming languages. The automatic parsing algorithms indeed simplify compiler construction but contribute little to the production of “optimized” machine code, for example. An equally perplexing problem for many of these parsing algorithms has been what to do about syntactically incorrect object strings. It is common knowledge that most of the ALGOL or FORTRAN “programs” which a compiler sees are syntactically incorrect. All of the parsing algorithms detect the existence of such errors. Many have considerable difficulty pinpointing the location of the error, printing out diagnostic information, and recovering enough to move on to other correct parts of the object string. It is the author's opinion that those algorithms which do the best job of error recovery are those which are restricted to simpler forms of formal languages.

A syntax controlled generator of formal language processors

Abstract: In recent years formal languages have become a subject of wide interest--from a theoretical point of view in connection with symbolic logic and automata theory, from a practical point of view as input languages for information processing systems. In both cases some processing of these languages enters into the question, generally as a translation into another formal language. Some examples illustrate the possible variation of the circumstances with regard to the origin and meaning of formM languages and to their syntactical structure: languages for describing theorems, sequential circuits, differential equations systems or numerical algorithms. However, actual processors constructed for languages whose syntax can be described in the same metalanguage, e.g. Baekus notation [2], have shown remarkable similarities. In our own experience an important general principle in processing formal languages was the cellar principle introduced in 1957 by F. L. Bauer and K. Samelson [4, 5] in the design of a formal language-controlled computer. This principle has been described in [19, 20]. The essential features are as follows: The incoming information is analyzed sequentially, the meaning of each symbol already being established insofar as it can be determined from previous history. Corresponding information is stored into a state pushdown store, the \"cellar.\" In this way the momentary top levels of the cellar always reflect previous histo~T to the extent necessary to analyze the next incoming symbol. This principle proved to be applicable in translating programs from the algorithmic language ALGOL [3, 17] into machine code (pilot ALGOL 58 translator of the ZMMD group for the Zuse Z22, ERMETH and PERM computer) or into a computer-oriented, macro instruction language (logical plans of the ALCOR group in 1.959 and 1960). The principle was found and used independently elsewhere. Processors for other formal languages have been built, using a similar technique [7, 18].

An empirical study of minimal storage sorting

Abstract: techniques previously published. The additional space required is one word per record. Therefore, given a memory area of size A and a record of size S, then the number of records (N) tha t can be sequenced in memory using the Replacement-Selection technique is A/(S+i) , as compared to A/S for other techniques. If the additional memory is not available, then N would have to be reduced by N/(S-4-1) records in order to confine the working area to A. The number of comparisons and the same number of exchanges required by the P 0 p e r a t o r method is given in [3, 4]. The Replacement-Selection method requires N[log2N] comparisons and N exchanges. Table 1 shows a comparison of the P-Operator method and the Replacement-Selection technique for various values of N. (A memory size of NS for the P-Opera tor method and N(S-4-1) for the Replacement-Selection method.) TABLE 1

A generalization of ALGOL

Abstract: For purposes of programming in machine code a problem must normally be so minutely fragmented that the task of attempting to identify the problem from the program is like trying to reconstruct a table from sawdust. This is a prime cause of difficulty in checking new programs for errors, and it does not seem to have received from the writers of compilers the attention it deserves. We are trying to do something about this by making the operations defined by sentences as comprehensive as possible. To take a simple example,

A contour-map program for x-ray crystallography

Abstract: A FORTRAN program is described for use with the IBM 7090 system and an x, y-plotter to produce a contour map. A matrix of points evenly spaced in each dimension is contoured. Scale factors along the axes may be different and the axes need not be perpendicular.

A description of the APT language

Abstract: The APT (Automatically Programmed Tools) language for numerical control programming is described using the metalinguistic notation introduced in the ALGOL 60 report. Examples of APT usage are included. Presented also are an historical summary of the development of APT and a statement concerning its present status.

CORC—the Cornell computing language

Abstract: CORC is an experimental computing language that was developed at Cornell University to serve the needs of a large and increasing group of computer users whose demands are both limited and intermittent. These are the laymen of the computing world, who chose to become as little concerned as possible in the computing process and mechanics, but who would like to benefit from the computational ability that is now commonplace. At a university most of the faculty and student users would fall into this category. In recognition of the current significance of the computer in every area of business, science and engineering there is increasing faculty interest in introducing some use of modern computation into the students' academic experience if this can be done without placing too great a burden on an already hard-pressed curriculum. But computing is not going to be widely used in mathematics and engineering courses if the mechanics of its use are a burden to either the teacher or the student, or if the time necessary to prepare, test and operate programs cuts significantly into the subject matter for which the course was intended. Some participation on the part of the student appears to be an academic virtue, as well as a practical economic necessity—we have never heard any university computing center expansionist, in his wildest moments, propose a completely closed shop programming-operating service for general undergraduate use. In their own research many of the faculty are in the same position as their students. They will use the computer if it is convenient to do so and if it does not involve a major diversion into a technical field which is essentially extraneous to the basic subject matter. The closed-shop computing service in which the professor has (in principle anyway) only to describe his problem to a professional is of course intended to serve this need but we believe it is axiomatic that no university computing center will ever be adequately staffed to

Partioning algorithms for finite sets

Abstract: The partitions of a set with n elements are represented by certain n-tuples of positive integers. Algorithms are described which generate without repetitions the n-tuples corresponding to: (1) all partitions of the given set, (2) all partitions of the given set into m or fewer sets (1 l m l n), and (3) all partitions of the given set into exactly m sets (1 l m l n).

Sorting on computers

Abstract: An ACM Symposium on Sorting, organized by Applied Data Research, Inc., was held in Princeton, New Jersey, November 29 and 30, 1962. The papers presented form a comprehensive report on the state of the art of sorting; the Communications of the ACM is pleased to publish a number of them in this issue. The remainder are invited for future issues. It is our hope that this issue will serve as a reference on sorting. To further this objective, an expository paper, a bibliography, a list of manufacturers' bulletins and a glossary are included. The expository paper, by C. C. Gotlieb, originally given as an invited lecture at Brown University, is reprinted here to provide a convenient introduction to the developments reported in the papers. The bibliography is a combination of those compiled by M. H. Hall and C. C. Gotlieb plus all other references known to us. The list of manufacturers' bulletins was compiled from responses to invitations to all manufacturers to submit the bulletins they wished to have included. The glossary is published exactly as prepared for the Sort Symposium by Applied Data Research, Inc. There are many issues raised by this set of papers, some of which have not been completely resolved. Readers are encouraged to submit queries, comments, etc., to the Scientific and Business Applications department of the Communications; letters and answers will be published as an addendum in a future issue. The preparation of the papers has involved considerable effort under severe time pressure; I wish to take this opportunity to thank the authors and reviewers for their cooperation.~D. Teichroew, Editor

Debugging systems at the source language level

Abstract: One of the most important and time-consuming phases of programming is the testing of a program to insure that it works properly. I t is therefore worthwhile to consider systems for facilitating this phase. In this paper the design of systems for mechanizing these tests is considered. A system for mechanizing debugging at the problem-oriented language (POL) level is described. This system facilitates program testing and minimizes the possibilities of introducing errors in the testing process. The system is well suited to organizations that need debugging facilities tha t are not provided by the compiler being used. The debugging system has been implemented for FORTRAN aS the source,, language and could be easily adapted to other problem-oriented languages. The implementation of the processor for mechanized debugging depends only on the POL syntax and is independent of the compiler. The syntax table approach of Irons [1] is used which provides that changes in the processor may be easily made to accommodate changes in the source language.

Report on proposed American standard flowchart symbols for information processing

Abstract: This paper presents the essential contents of the Proposed American Standard Flowchart Symbols for Information Processing. This is the first proposed standard prepared by Subcommittee X3.6 on Problem Description and Analysis of the American Standards Association (ASA).

An extension of Fibonaccian search to several variables

Abstract: A technique which uses Fibonaccion search concepts has been developed to solve optimization problems involving unimodal functions of several variables. The technique has not been proven to be optimal in the sense that the one-dimensional Fibonaccion search is. However, it is valuable for certain kinds of calculations.

Some remarks on the syntax of symbolic programming languages

Abstract: This paper concerns some preliminary results of an investigation of certain syntactical features of symbolic programming languages (SPL), which is a part of a wider research in the field of problem-oriented languages for automatic processor construction [1] Our main aim is to point out certain peculiar features of SPL's which yield a deeper insight into their linguistic nature from a formal point of view, in order to take further steps in the direction of finding a proper way to define them The general approach suggested here might be of some interest in the broader field of general linguistics, since many languages, including natural languages, show similar properties

MIRFAC: a compiler based on standard mathematical notation and plain English

Abstract: A pilot version of the compiler MIRFAC, now in the operation, is described. The chief features of the system, which is intended for the solution of scientific problems, are the presentation of mathematical formulas entirely in standard textbook notation. The use of plain English for organizational instructions, automatic error diagnosis indicating the actual location of the error in the uncompiled program, and an attempt to minimize that fragmentation of the original problem statement which is a normal feature of programming systems.

Selected definitions

Abstract: A selection of the definitions prepared by the ACM Standards Committee's Subcommittee on Programming Terminology is presented for review by the ACM membership.

Internal and tape sorting using the replacement-selection technique

Abstract: A general technique for sequencing unsorted records is presented. The technique is shown to be applicable for the first stage of a generalized sort program (the formation of initial strings) as well as for sorting records within a memory storage (an internal sort). It is shown that given N records in memory storage, records are sequenced using 1+log2N tests per record, that initial string lengths will average 2N for random input records, and that reading, writing and processing can be accomplished simultaneously if the computer permits such overlap.

A procedure for converting logic table conditions into an efficient sequence of test instructions

Abstract: human (or any other) judgment. The writers of monitor systems are generally very skilled programmers of high intelligence. If the monitor systems were as good as the persons writing them, there could be no complaint. But this is not the ease, and cannot be the ease. Instructions carried out big a machine obeying the commands of a monitor program are not and cannot be the equivalent of intelligent operation of the machine by the system designer who wrote the monitor. In all this talk of bigger, better and faster machines, let us not forget the fact tha t a machine is still just a dumb piece of hardware, obeying a list of specific and largely inflexible instructions. As long as this remains a fact, monitor systems had better remain discreet.