Search

The article focuses on PL/I, which stands for Programming Language 1, and how its ambitious goals as a programming language. The author discusses the design of PL/I by International Business Machines (IBM) and explains how it brings together their three programming languages FORTRAN (1954), ALGOL (1958), and COBOL (1959).

A retrospective on the fifty-year history of the Pascal programming language is offered. The author discusses his role in a working group developing the Algol 60 programming language as well as the subsequent Algol W language with a focus on the modifications to Algol which resulted in his development of Pascal. The distribution of Pascal to schools and universities is described along with its successor languages and the alleged dissolution of the hardware-software dichotomy.

This article reports that graphs are a useful medium for modeling relevant parts of reality in computer programs. Representation greatly influences the efficiency of graph algorithms. Often, linearity can only be achieved through appropriate storage of adjacency information. There are several different ways of internally representing graphs in procedural languages, including adjacency matrices, sequential or linked adjacency lists, and edge lists. This article describes an abstract module for graph handling that is especially suited for the edge-oriented paradigm of programming graph algorithms, and show how this module can be implemented efficiently in Algol-like languages. This graph realization is of the adjacency-list type and is suitable for directed and undirected graphs. It is informed that there is a large variety of graph types. Depending on the area of application, graphs can be directed or undirected, weighted or unweighted, and ordered or unordered. Multiple edges and loops are either permitted or forbidden.

We consider the effects of parallelizing branch-and-hound algorithms by expanding several live nodes simultaneously. It is shown that it is quite possible for a parallel branch-and-bound algorithm using n2 processors to take more time than one using n1 processors, even though n1<2. Furthermore, it is also possible to achieve speed- ups that are in excess of the ratio n2/n1. Experimental results with the 0/1-Knapsack and Traveling Salesman problems are also presented. [ABSTRACT FROM AUTHOR]

Focuses on different computer languages. FORTRAN; ALGOL; PL/I.

Describes the syntax of an algorithmic language, such as ALGOL, as a sequence of states indicated by an element called cellar. Control of transitions by admissible state-symbol pairs; Rules for translating into machine program statements in the algorithmic language.

Focuses on the event-driven compiling technique. Difficulties encountered in one-pass compilation process; Application of the technique to the construction of an Algol 68 compiler; Implementation of compiling scheme.

Examines the characteristics of the virtual memory requirements of Algol 60 programs. Presentation of the distributions for the sizes of memory requests; Results in terms of Johnston's contour model and a simple abstract machine; Implications of the results for the design of virtual memory system.

The term "Locality" has been used to denote that subset of a program's segments which are referenced during a particular phase of its execution. A program's behavior can be characterized in terms of its residence in localities of various sizes and lifetimes, and the transitions between these localities. In this paper the concept of a locality is made more explicit through a formal definition of what constitutes a phase of localized reference behavior, and by a corresponding mechanism for the detection of localities in actual reference strings. This definition provides for the existence of a hierarchy of localities at any given time, and the reasonableness of the definition is supported by examples taken from actual programs. Empirical data from a sample of production Algol 60 programs is used to display distributions of Locality sizes and lifetimes, and these results are discussed in terms of their implications for the modeling of program behavior and memory management in virtual memory systems. [ABSTRACT FROM AUTHOR]

GLYPNER is one of the earliest existing languages designed for programming the Illiac IV computer. The syntax of the language is based on ALGOL 60, but has been extended to allow the programmer explicitly to specify the parallelism of his algorithm in terms of 64-word vectors. This paper describes the characteristics, goals, and philosophy of the language, and discusses some of the problems associated with parallel computer architectures. [ABSTRACT FROM AUTHOR]

Two languages enabling their users to estimate the efficiency of computer programs are presented. The program whose efficiency one wishes to estimate is written in the first language, a go-to-less programming language which includes most of the features of Algol 60. The second language consists of interactive commands enabling its users to provide additional information about the program written in the first language and to output results estimating its efficiency. Processors for the two languages are also described. The first processor is a syntax-directed translator which compiles a program into a symbolic formula representing the execution time for that program. The second processor is a set of procedures for algebraic manipulation which can be called by the user to operate on the formula produced by the first processor. Examples of the usage of the two languages are included. The limitations of the present system, its relation to Knuth's work on the analysis of algorithms, and some of the directions for further research are also discussed. [ABSTRACT FROM AUTHOR]

Examines a practical approach of a syntax-directed least-errors analysis for context-free languages. Elements of the Bellman's dynamic programming; Development of least-errors recognizer by using the organizer of Earley; Emphasis of the algorithm design.

This article focuses on the twenty third self-assessment procedure. The purpose of this procedure is to let its readers test their knowledge of some of the more important features of significant programming languages. The features of imperative languages like Fortran, ALGOL 60, PL/I, Pascal, Modula-2, C, and Ada considered are data types, data structures, control structures, program units, scope of names, and parameter passing. Some of the corresponding features of functional languages like Lisp, logic programming languages like Prolog, and object-oriented programming languages like C++ and Smalltalk, are reviewed. Finally brief considerations is given to syntax and semantics, chiefly by reference to the Backus-Naur form. The features of programming languages affect all aspects of programming, including the ease of writing and maintaining programs, the reliability of software, and the efficiency and portability of programs. Thus knowledge of programming language concepts and constructs is of importance to software developers, programmers, and designers of programming languages and compilers.

In spite of impressive gains by PL/I, Fortran and Cobol remain the languages in which most of the world's production programs are written and will remain so into the foreseeable future. There is a great deal of theoretical interest in Algol 68 and in extensible languages, but so far at least they have had little practical impact. Problem-oriented languages may very well become the most important language development area in the next five to ten years. En the operating system area all major computer manufacturers set out to produce very ambitious multiprogramming systems, and they all ran into similar problems. A number of university projects, though not directly comparable to those of the manufacturers, have contributed greatly to a better understanding of operating system principles. Important trends include the increased interest in the development of system measurement and evaluation techniques, and increased use of microprogramming for some programming system functions. [ABSTRACT FROM AUTHOR]

Deals with the use of a second algorithm of Remez to compute minimax approximations to a function by a linear combination of functions which form a Chebyshev system. Algol 60 procedure; Computational examples of the use of the algorithm; Use of orthogonal polynomials.

Explains the main features of ALGOL 68 from a semantic point of view. Examination of how the language permits the composition of values and actions; Programming primitives; Design of programming languages.

A language for the representation of graphs is described, and the formulation of graph operations such as node and/or link deletion or insertion, union, intersection, comparison, and traversal of graphs is given. Graphs are represented by linked lists. The language is syntactically defined as an extension to ALGOL 60, and it is translated into ALGOL by means of a syntax-driven compiler. Application areas for this language are operation research, network problems, control theory, traffic problems, etc. [ABSTRACT FROM AUTHOR]

This article presents several algorithms, formulated by various mathematicians and computer programmers. One of the algorithmic formulas, reported here, is related to the number of doubly restricted partitions, formulated by mathematician John S. White which was recorded on March 4, 1969. According to this algorithm, the number of partitions of L with parts greater than or equal to K and less than or equal to M is set in P[L, M] for all L, M such that N is greater than/equal to L is greater than/equal to M is greater than/equal to 0. This algorithm is a generalization of a previously published algorithm which treats the case K = 1. Some other algorithms, briefly detailed here, are related to: restricted partition generator, fitting data to one exponential, eigenvalues and eigenvectors of a real general matrix, t-test probabilities, and student's t-distribution. Algorithm relating t-test probabilities, formulated by John Morris, was coded in CSIRO 3200 ALGOL and run on a CDC 3200 with programmed floating point operations.

A high level programming language for large, complex associative structures has been designed and implemented. The underlying data structure has been implemented using a hash-coding techniques. The discussion includes a comparison with other work and examples of applications of the language. [ABSTRACT FROM AUTHOR]

This article discusses the ALGOL convolution procedure based on the fast Fourier transform. The operation of convolution is used in computing autocorrelation and cross-correlation functions, in digital filtering of time series, and many other applications. Procedure Convolution computes the convolution of two real vectors of dimension. The special features of this procedure are the usual reordering of the fast Fourier transform results is avoided, and the return from frequency to time is made with a transform of dimension n/2 instead of n. The two vectors A and B are first transformed with a single complex Fourier transform of dimension n. Procedure Convolution uses-procedure REALTRAN but repeated here with revisions to improve accuracy on computers using truncated floating-point arithmetic. Procedures FFT4 and REVFFT4 are also used and perform the same computation as procedures FFT2 and REVFFT2 given for use on a system with virtual memory. The transform procedures given are organized without regard to the problem of memory overlay.

A truly general purpose programming language, GPL, is described which contains facilities for constructing (within the language) new data types as well as facilities for operations performed upon them. The basic language is minimal in the sense that no basic element can be derived from the others with high efficiency in the object programs. Constructs like the ALGOL 60 for-statements, and if-statements are not basic; they are special types of procedures. New "symbols" (underlined words in ALGOL 60) are implicitly defined by usage in other declarations. As part words are definable, packed words are handled as easily as full words. "Address" variables (pointers) are included in full generality. [ABSTRACT FROM AUTHOR]

By means of the primitives insymbol, outsymbol and length, as requested by this journal's Algorithms Policy [Comm. ACM 10 (Nov. 67), 729] a basic set of input-output procedures is defined aiming at quality and flexibility. outreal, for instance, is written as a derived procedure; it outputs using the fixed point or the floating point representation, and rounds properly. Variants can easily be written because of the explicit call of the procedures decompose integer and decompose real. The highly recommended practice of echoing input is made easy with one subset of derived procedures (ioi, ior, iob, ioa). The documentation of output in the form of equivalent ALGOL statements is also provided when use is made of the subset oti, otr, otb, ota. The Berkeley style of providing information on the form of output using prior calls of procedures such as real format is defined. A use of the parameter outchannel to provide information for simultaneous output to several channels is suggested. Interrelationship between the declared procedures is furnished in tabular form. [ABSTRACT FROM AUTHOR]

A new programming language facility for symbol manipulation is described. String procedures may be declared and called in a standard ALGOL context. ALGOL procedures can in turn be called by string procedures so that numeric and symbolic processes may conveniently be programmed together. Concatenation and a variant of SNOBOL's pattern matching make up a set of primitive commands. These are assembled together into conditional expressions which are to be used to provide alternative computational patterns. Arrays of strings are processed using quantifiers. The class of things which may be assigned to an identifier can be restricted by a procedure expressed in the notation. The language facilities have been implemented in the ALGOL compiler for the Burroughs B5500. [ABSTRACT FROM AUTHOR]

Describes a dump technique for programs written in ALGOL 60. Intelligible analysis of an unsuccessful computation process in terms of the original source program; Compromises between the completeness of the analysis and the cost in computer time and programming effort; Design of the ALCOR Illinois 7090/7094 Post Mortem Dump.

Discusses the ambiguities remaining in the ALGOL 60 programming language. Impact of ALGOL 60 on many areas of computer science; Contradictions in the interdependent elements of ALGOL 60; Proposed solutions to ambiguities in ALGOL 60.

An experimental processing system for the algorithmic language EULER has been implemented in microprogramming on an IBM System/360 Model 30 using a second Read-Only Storage unit. The system consists of a microprogrammed compiler and a microprogrammed String Language Interpreter, and of an I/O control program written in 360 machine language. The system is described and results are given in terms of microprogram and main storage space required and compiler and interpreter performance obtained. The role of micros programming is stressed, which opens a new dimension in the processing of interpretive code. The structure and content of a higher level language can be matched by an appropriate interpretive language which con be executed efficiently by microprograms on existing computer hardware. [ABSTRACT FROM AUTHOR]

An extension to ALGOL is proposed for adding new data types and operators to the language. Definitions may occur in any block heading and terminate with the block They are an integral part of the program and are not fixed in the language. Even the behavior of existing operators may be redefined. The processing of text containing defined contexts features a "replacement rule" that eliminates unnecessary iterations and temporary storage. Examples of definition sets are given for real and complex matrices, complex numbers, file processing, and list manipulation. [ABSTRACT FROM AUTHOR]

Methods of simplification that can be applied automatically to programs written in an ALGOL-like language are discussed. The simplifications are based on the form of the program and the knowledge obtained by a processor, without any understanding of what the program is supposed to do. These methods have been implemented in a processor called SURE that accepts a program written in JOVIAL and outputs an equivalent JOVIAL program that may be shorter and may be executed faster than the original. SURE is described, some of the problems encountered in automatic improvement at the source-language level are discussed, and further types of automatic program improvement are suggested. [ABSTRACT FROM AUTHOR]

The article reports on several algorithms with their specific computational dynamics. A specific algorithm with its corresponding formula which provides for the procedure for deriving a certain value is provided. The algorithms include, among others, algorithm 290 for linear equations, algorithm 291 for logarithm of gamma functions, and algorithm 178 for direct search. Moreover, the algorithms are written in the ALGOL 60 Reference Language, Standard FORTRAN, and Basic FORTRAN. Specific instructions on how to submit algorithms are also included.

Presents a final solution of the dangling else problem of the ALGOL 60 related languages. Description of concept; Approaches to resolve the ambiguity of syntax equations; Effects of incorrect syntax equations.

A programming language similar in many respects to ALGOL 60, but incorporating a large number of improvements based on six years' experience with that language, is described in detail. Part I consists of an introduction to the new language and a summary of the changes made to ALGOL 60, together with a discussion of the motives behind the revisions. Part II is a rigorous definition of the proposed language Part III describes a set of proposed standard procedures to be used with the language, including facilities for input/output. [ABSTRACT FROM AUTHOR]

Presents several letters to the editor. Discussion on the problem of time table construction; Information on facilitating parallel and multi-processing in ALGOL; Focuses on the usage of primal simplex method.

An ALGOL translator has been prepared and integrated into the IBSYS Operating System, Assembly and "go" features of IBSYS permit immediate execution with optional listings, decks and debugging information. Using the chain feature of IBSYS, links written in MAP or FORTRAN as welt as ALGOL may be called by the ALGOL main program. In addition, procedures coded in MAP may be included in any ALGOL program. Although assembly plus loading time exceeds compilation time, the total time is satisfactory and the user gets ease and facility which are fully compensating. [ABSTRACT FROM AUTHOR]

Part II. Focuses on the characteristics of Algol computer language. Correlation between Euler and Algol 60; Description of Euler language; Efficiency of Algol.

Studies the performance of a system for automatic segmentation of programs within an ALGOL compiler for the GIER computer. Division of the translated program into a sequence of segments; Determination of the amount of core storage available for program segments.

Examines several combinatorial problems requiring selection of n elements from a set of m elements. Utilization of a recursion process analogous to that for computing binomial coefficients; Development of an ALGOL program for one of the problems.

Presents the idea of constructing a computer design language by making use of an ALGOL-like programming language. Purposes and requirements of the design language; Need for a translator to translate a design of computer logic into a set of Boolean equations.

Describes some techniques used in the ALGOL compiler written by the ALCOR group for the IBM 7090. Compiler writing; Organizational details of the compiler; Timing estimates.

The article discusses an algorithm related to computing. This algorithm mechanizes a modified form of the Graeffe process designed to avoid an expanding number range. This algorithm has been tested with polynomials of degree up to 10 and compiled by using both the Oak Ridge ALGOL Translator for the Control Data 1604 and the SHARE ALGOL Translator for the IBM 709/7090. Quantities used in the process are similar to those of ordinary root-squaring process. Introduction of arithmetic divisions at each step helps in avoiding expanding number range.

Describes the result of a compiler project launched in fall of 1962 that produced in spring 1963 a one-pass ALGOL compiler for the Maniac III computer at the University of Chicago in Illinois. Plans for operation on a CDC 3600 computer; Method of syntax analysis; Data structures at run time; Bookkeeping for block structure; Translation of arithmetic expressions; Implementation of recursive procedures.

A letter to the editor is presented in response to an article on the specification of syntax and the generalization of ALGOL 60.

Deals with two automatic grader programs. Computer evaluation of student ALGOL programs; Test of the reliability and efficiency of an integration procedure; Statement of essential properties of a computer system.

Part II. Presents a formal mapping of ALGOL 60 into imperative applicative expressions (IAE). Presentation of the correspondence between ALGOL 60 and IAEs; Elaboration of the notion of a parenthesized text; Similarity to a syntax-oriented compiler; Structure definition of ALGOL 60 COs.

In the latter part of 1952 and 1953, people began to experiment with symbolic programming systems that can now be recognized as the remote ancestors of modern high-level programming languages. However, the first major landmarks in the development of programming languages were the announcement of Fortran in April in 1957 and the issuing of the Algol 60 report in 1960. The Fortran group worked within IBM Corp. and was in close touch with users of IBM 704 computers in industrial and university environments. Although the group broke new ground, both in language design and in compiler technology, they never lost sight of their main objective, namely, to produce a product that would be acceptable to practical users with real problems to solve. Algol 60 was the work of an international group with members from Germany, Switzerland, the U.S., England, Denmark, etc. The spade work had been done as a result of an earlier initiative taken by a small group of mathematicians in Switzerland and Germany with a background in numerical analysis.