bluuebunny/crossref_metadata_2025_split huggingface dataset:
MAP: A Pascal macro preprocessor for large program development
Authors: Comer Douglas 
Published: November 2006

AbstractThe programming language Pascal was originally designed for teaching introductory programming. Currently, however, production systems use it as the primary implementation language. This paper describes extensions of Pascal intended to aid the large program developer. The extensions are implemented in a macro preprocessor MAP, which supports constant expression evaluation, source file inclusion, conditional compilation and macro substitution. While each of these features can be used independently, they are all implemented with a simple, uniform syntax. Furthermore, in keeping with the spirit of Pascal, an attempt has been made to make the facilities straightforward and simple. The design and implementation details are discussed.
Awk — a pattern scanning and processing language
Authors: Aho Alfred V. , Kernighan Brian W. , Weinberger Peter J. 
Published: November 2006

AbstractThis paper describes the design and implementation of awk, a programming language which searches a set of files for patterns, and performs specified actions upon records or fields of records which match the patterns. Awk makes common data selection and transformation operations easy to express; for example,

is a complete awk program that prints all input lines whose length exceeds 72 characters. The program

prints each input line with the first field replaced by its logarithm. The program

prints all lines in which the first field is different from the first field of the previous line.Patterns may include boolean combinations of regular expressions and of relational operators on strings, numbers, fields, variables, and array elements. Actions may include: the same matching constructions as in patterns; arithmetic and string expressions and assignments; if‐else, while, and for statements; formatted output; and multiple output streams.
An empirical analysis of COBOL programs
Authors: Al‐Jarrah M. M. , Torsun I. S. 
Published: November 2006

AbstractThis paper describes results obtained from a static analysis of 340 COBOL programs collected from commercial and industrial installations. The analysis was performed by a syntax analyser designed specifically to analyse source program statements, gather detailed information and produce a report on the definition and use of data and language in the programs analysed.
Organizing the description of a relational data base
Authors: Hutt Andrew T. F. 
Published: November 2006

AbstractThe design and implementation of the data structures used within a software system such as a compiler, an operating system or a data base management system are fundamental to the development of that system. Unfortunately, there are very few standard techniques for designing such data structures and for structuring the software used to support them.This paper proposes that it is possible to use data base techniques to design and implement such data structures. For this reason, it describes a methodology which is used to design large relational data bases, and then demonstrates how the methodology was modified and used to design the internal data structures of a relational data base management system.This paper concludes that this approach produces data structures which are better understood and easier to modify than those resulting from an ad‐hoc approach.
Queueing network software for systems modelling
Authors: Sauer C. H. , Macnair E. A. 
Published: November 2006

AbstractSeveral requirements are placed on queueing models of computer systems. These include credibility, accuracy, timeliness and cost. Modelling software can have critical impact on all of these requirements. We survey the characteristics of major pieces of queueing software. Based on this survey we synthesize a set of design objectives for queueing software. Finally, we discuss our own queueing network software, the Research Queueing Package (RESQ), in light of these objectives.
Practice and experience with BASIS: An interactive programming system for introductory courses in informatics
Authors: Van Riet R. P. De , Wiggers R. 
Published: November 2006

AbstractThe BASIS system is an interactive and conversational system, written in Pascal, to be used in the workshop of the introductory course in informatics. Its language is a subset of Pascal. Based on some years of experience with several versions of the system, we will discuss some implementational aspects.
Resolving ambiguous identifiers
Authors: Sites Richard L. 
Published: November 2006

AbstractIn some compilers, long identifiers are truncated, or lower case letters are converted to upper case. Such respellings can make two distinct identifiers appear identical, and under unfavourable circumstances no warning or error messages will be generated. The use of different respelling algorithms in different compilers is a hindrance to transporting software, and is a source of latent bugs. This short note suggests avoiding the problem by generating warning messages when a potentially ambiguous spelling is used in a declaration. The technique involves hashing the character and case‐shift bits that would otherwise be thrown away. A program that compiles without warning messages can be safely transported.
The design of the MUSS operating system
Authors: Frank G. R. , Theaker C. J. 
Published: November 2006

AbstractThis paper describes the design of a general purpose operating system called MUSS. One of the major objectives of the MUSS system is that it should be adaptable. The paper discusses the features of its design which lead to adaptability, in particular the method of structuring the system and the techniques and tools used in documenting it.
Systems implementation languages and IRONMAN
Authors: Wand I. C. 
Published: November 2006

AbstractThe U.S. Department of Defense has recently issued a set of requirements, which it called IRONMAN, for the design of a programming language that it will use for embedded computer applications. To date four competing languages have been designed and, after considerable debate and scrutiny, these have been reduced to two. It is expected that the winning language will be selected during 1979.This report compares the IRONMAN requirements against the state‐of‐the‐art in systems implementation language design in an attempt to see the extent to which IRONMAN can be met from existing technology. Particular emphasis is given to the areas of large‐scale program structuring, parallel programming, exception handling and hardware interaction.Finally, Dijkstra's criticism of IRONMAN and the competing languages will be examined. It will be argued that he may be justified in doubting the viability of a language with such diverse features.
Sequence error recovery considered misleading
Authors: Vaucher Jean G. 
Published: November 2006

AbstractSequence checking is such a common operation in commercial data processing that one assumes it no longer presents any programming problems; however, many examples presented in the current literature are either incorrect or misleading in as much as they do not state the necessary conditions for proper operation. Checking algorithms generally detect sequence errors and decide which record is in error based on a comparison between two successive record key values (current and previous). We show that identification of the record in error with any degree of certainty requires at least four successive key values and suggest that simplistic recovery in the face of sequence errors should not be attempted.
Concurrent Pascal with backward error recovery: Implementation
Authors: Shrivastava S. K. 
Published: November 2006

AbstractThe implementation of backward error recovery features requires the support of a run time subsystem (called the recovery system) that is responsible for performing the task of state restoration. The recovery system implemented to support the recovery features of Concurrent Pascal includes, for each process, a recovery cache for recording appropriate recovery data. This paper describes the details of the recovery system that was implemented as a part of the interpreter of Brinch Hansen's Concurrent Pascal system.
Maintaining program variants by merging editor scripts
Authors: Fraser Christopher W. 
Published: November 2006

AbstractThe proliferation of different versions of a program complicates maintenance: a change to the common ancestor of several versions requires a change to all versions. Some software distributors publish editor command scripts to automate these changes, but extensive modifications of the software by a remote installer can invalidate the scripts. This paper describes a program that alleviates this problem by merging editor scripts and shows how it has simplified a substantial version maintenance problem.
A comparison of programming languages for software engineering
Authors: Shaw Mary , Almes Guy T. , Newcomer Joseph M. , Reid Brian K. , Wulf Wm. A. 
Published: November 2006

AbstractFour programming languages (Fortran, Cobol, Jovial and the proposed DoD standard) are compared in the light of modern ideas of good software engineering practice. The comparison begins by identifying a core for each language that captures the essential properties of the language and the intent of the language designers. These core languages then serve as a basis for the discussion of the language philosophies and the impact of the language on gross program organization and on the use of individual statements.
FORTRAN routines with optional arguments
Authors: Gujar Uday G. , Fellows David M. 
Published: November 2006

AbstractIn designing a general purpose subroutine package to solve a class of problems, one often has to write subroutines with a large number of arguments. Although these arguments are required to cover a range of possibilities, many of these arguments have some commonly occurring values. The user is thus burdened with supplying a long list of arguments and making sure that the number and types match. An alternate solution is to write such subroutines in assembly language so that they could have a variable number of arguments. This approach is expensive and eliminates a large class of program designers who do not and do not want to know assembler language. This paper describes a facility which enables these program designers to write their routines completely in a higher level language (FORTRAN) and yet enjoy the ‘luxury’ of having a variable number of arguments in the calling sequence.
The structure of the MARY/2 compiler
Authors: Rain Mark 
Published: November 2006

AbstractThe MARY12 language implemented at Penobscot Research Center contains language differences from previous MARY implementations. These differences significantly increase the difficulty of implementing a compiler. Similar constructs have appeared in recent language proposals such as those for ADA. The methods of the MARY/2 compiler should be useful in compilers for these and other future languages. This paper discusses the language constructs which are the source of the difficulty; the implementation methods actually used; possible trade used; and the character of the programs which these constructs facilitate.
An experience in implementing abstract data types
Authors: Banatre M. , Couvert A. , Herman D. , Raynal M. 
Published: November 2006

AbstractThe abstract data type concept appears to be a useful software structuring tool. A project, called ‘Système d'Objets Conservés’, which was developed at the University of Rennes, (France), gave some experience in implementing this concept. The possibility of including abstract data type into a pre‐existing compiler is demonstrated, and desirable properties of the host language are exhibited. Provision of external procedures and data makes some type checking extensions necessary: these features increase software reliability.
Message passing between sequential processes: The reply primitive and the administrator concept
Authors: Gentleman W. Morven 
Published: November 2006

AbstractMessage passing as a method of synchronizing and communicating among sequential processes is not as widely understood as monitors, and there is greater diversity in the semantics of what is meant by message passing. This paper surveys some of the issues on which there are differences and gives the rationale behind certain choices and some examples of experience with them. Paradigms are presented for process structuring found to be commonly useful.
The construction of a portable editor
Authors: Peck J. E. L. , Maclean M. A. 
Published: November 2006

AbstractThe paper describes the implementation of an editor designed and constructed with portability in mind. We give first a brief introduction to the editor from the user's point of view, then we discuss the methods used to ease the problems of portability, and finally we explain some data structures used in its implementation, structures which, we believe, are interesting in their own right.
Software engineering: An example of misuse
Authors: Fisher Paul S. , Slonim Jacob 
Published: November 2006

AbstractManagers of programmers and designers are sometimes wont to adopt the new and shiny. This paper describes a situation in which managers at several levels grasped for the ‘new and shiny’ in the form of software engineering. This approach was not without its hidden dangers, especially when established guidelines were ignored or violated.The results of an experience with a large software project are reported. This project dealt with a sophisticated inventory control system. The effects on the project of ignorance and the violation of rules are described. Several measures of the final product are reported. Observations of the authors conclude the paper.
Uniform syntax for type expressions and declarators
Authors: Sethi Ravi 
Published: November 2006

AbstractA declaration mechanism is proposed that allows common type information to be factored into a type expression, yet allows related but distinct types to be declared together. The mechanism is a unification of declarations in Pascal and C. The choice of syntax is quite important. The proposed syntax uses a postfix operator for dereferencing pointers instead of the prefix operator * for pointer dereferencing in C.
Formatted programming languages
Authors: Rose G. A. , Welsh J. 
Published: November 2006

AbstractThis paper presents a systematic approach to formatted language design that incorporates formatting within the syntax of programming languages. The approach includes:

a metasyntax to ensure that program text is foldable, not only to avoid right margin overflow but also to preclude constructs which are visually confusing or ambiguous;
a set of guidelines for language designers to enhance readability within the constraints of the metasyntax; and
a folding algorithm which selectively folds a program text.
The resulting automatic formatting is consistent with current practice in program and text layout.The effect of this approach is to put program format decisions in the domain of the language's designer, rather than its several implementors or numerous users, which implies uniformly formatted programs of improved readability and therefore usability.
Message transport on the Cambridge ring—A simulation study
Authors: Lunn K. , Bennett K. H. 
Published: November 2006

AbstractThis paper describes a message transport policy for the Cambridge Ring which introduces contention for the receiver. A simulation model is presented which makes worst case assumptions for transmission rates. The results of running this simulation model are presented in terms of the delays experienced by messages crossing the ring given a certain discrete distribution of message sizes. Three variations of the policy are compared under different loadings of the ring caused by the number of nodes using the ring and by message creation rates at each node.
Decision tables in Algol 68
Authors: Ince Darrel C. 
Published: November 2006

AbstractTwo methods for extending Algol 68 to handle decision tables are described. One method allows an extension to Algol 68 to handle limited entry decision tables while the other method, which involves the use of a preprocessor, extends Algol 68 to handle mixed entry decision tables. Two systems have been constructed using the ideas outlined in this paper; these are described and examples of their use are given.
Parameter passing mechanisms and run time data structures
Authors: Kowaltowski Tomasz 
Published: November 2006

AbstractThe relationship between parameter passing mechanisms and run time data structures in languages with statically‐nested scopes is examined. It is shown that simpler data structures can be used in some cases, with increased efficiency in accessing non‐local variables. In particular it is true for the call‐by‐value‐result mechanism, where the usage of displays can be eliminated altogether; however there is some additional cost associated with procedure calls. Under certain conditions the same implementation applies to call‐by‐reference.
Designing storage management schemes for block‐structured languages
Authors: Wallis Peter J. L. 
Published: November 2006

AbstractContinuing the work presented in an earlier paper, we explain the design of the runtime storage management scheme for the Portable Programming Language (PPL). The design method uses three basic ideas‐the use of reduced type‐expressions, the classification of the components of an object according to the way their sizes vary, and the handling of stored objects as tree structures. It is illustrated by using it to derive a storage management scheme for the Portable Programming Language, and storage management schemes appropriate to Algol 68 and Ada that compare favourably with those already described in the literature.
Is block structure necessary?
Authors: Hanson David R. 
Published: November 2006

AbstractBlock structure is traditionally considered an a priori requirement for algorithmic programming languages. Most new languages since Algol‐60 have block structure. Reasons exist, however, to omit the general form of block structure‐nested procedure definitions in which references to identifiers defined in outer procedures are permitted‐from programming languages, especially those intended for systems programming applications. This paper reviews the concept of block structure and considers its advantages and disadvantages. It concludes that, in many cases, a module facility is superior to block structure and should be considered in lieu of block structure in future languages.
Compiling short‐circuit boolean expressions in one pass
Authors: Logothetis George , Mishra Prateek 
Published: November 2006

AbstractWe present a very simple scheme for compiling boolean expressions in the short‐circuit manner in one pass. The generated code is of very high quality and avoids most inefficiencies commonly associated with one‐pass code generation. In particular, redundant conditional and unconditional branches are kept to a minimum. The scheme is general enough to compile the boolean expressions of a typical high‐level language such as Pascal. It is presented in a format suited for syntax‐directed translation and can be used with both top‐down and bottom‐up parsing.
Design of a MUMPS interpreter
Authors: Brown Frank M. 
Published: November 2006

AbstractThis paper describes the basic design of Comp Consultants Standards Mumps system for Tano Corporation's Outpost 11 6800 based micro computer running under the Flex 2.0 floppy disk operating system with 64K bytes of random access memory. The Mumps system consists of an executive which includes I/O device handlers, and interpreter for Standard Mumps and a floppy disk storage system for global variables based on balanced trees with key compression by indexes and with 32 K of random access memory buffers to make up for the slow floppy disk access times.Comp Consultants Mumps involves some significant departures from previous Mumps implementations. In particular local variables and routine lines are stored in the same manner as global variables. For example the storage key for a routine consists of three parts: The routine name, a label, and a line offset number. Representing local variables and routines as global variables not only increases the available buffer space by eliminating special code to handle local variable storage, routine storage, and program editing; but also increases the utilization of the buffers by keeping in memory what is most often accessed regardless whether it is a local variable, a global variable, or program code. This unified representation of local variables and routines as global variables is described in detail in this paper.
PIC — A language for typesetting graphics
Authors: Kernighan Brian W. 
Published: November 2006

AbstractPIC is a language for specifying pictures so that they can be typeset as an integral part of a document preparation system. The basic objects in PIC are boxes, lines, arrows, circles, ellipses, arcs and splines, which may be placed at positions specified absolutely or in terms of previous objects, and labeled with arbitrary text. The example below illustrates the general capabilities of the language.magnified imageMost of the effort in designing PIC has gone into making it possible to specify the sizes and positions of objects with minimal use of absolute coordinates.This paper describes PIC, with primary emphasis on those aspects of the language that make it easy to use. The paper was typeset using PIC.
An alternative to young's module facility for Pascal
Authors: Comer Douglas , Williamson Keith 
Published: November 2006

AbstractIn an excellent paper1, Young describes a tool that aids the Pascal programmer by providing support for data abstractions. This paper compares Young's work to a similar tool for Pascal that has been designed and implemented by the authors. It demonstrates that parameterized module instantiations allow one to express some abstractions more naturally than does Young's method. The design goals and implementation details are discussed.
An experiment with the interchangeability of processes and monitors
Authors: Stroustrup Bjarne 
Published: November 2006

AbstractTwo styles of operating system implementation based on the use of monitors and processes, respectively, are identified, and arguments for a basic equivalence of these systems despite large stylistic differences are presented. The ‘Lauer‐Needham Duality Hypothesis’ states that the two styles are equivalent, both in terms of ease of programming and in efficiency of the resulting systems. A domain for which the first part of this claim holds is outlined, and data affirming the essential equivalence of performance within that domain are presented. An operating system based on the Cambridge CAP system, called SIMOS, was simulated for a wide range of hardware configurations and job loads. SIMOS is written using a module concept that allows an individual module to be interpreted as a monitor in one run and as a process in another. Runs using a monitor to control access to some data can be compared with runs using a process to control access to the same data. The throughput and response time for the two styles of system were found to be identical in most cases. However, a degradation in response time occurred in a process‐based system when the job load and the low level scheduling policy were poorly matched.