bluuebunny/crossref_metadata_2025 huggingface dataset:
Software malpractice — a distasteful experience
Authors: Spier Michael J.
Published: November 2006

A sequence of events is described, leading to the severe deterioration of an initially well conceived and cleanly implemented compiler. It is shown how an initial “optimization” implanted a latent bug in the compiler, how the bug was subsequently activated through innocent compiler modification, and how the compiler then deteriorated because of the incompetent correction of the bus manifestation. This exceedingly negative case history is presented in the hope of conveying to the reader a better feeling for the complex problems inherent to industrial software production and maintenance. The difficulty in proposing any constructive (and complete!) software engineering methodology is known and acknowledged; the study of an episode such as described in this paper might help put the difficulties, with which we are confronted, into better perspective.
Designing a FORTRAN based system for meteorological statistics
Authors: Craddock J. M.
Published: November 2006

The problems of achieving efficiency in middle weight computation are discussed with reference to experience in the Meteorological Office with the operational and research computations which support work on long range weather forecasting. An account is given of the reasoning behind the latest form of the METOCODE system, and of the objectives it is intended to fulfil.
Quasiparallel programming
Authors: Kaubisch W. H. , Perrott R. H. , Hoare C. A. R.
Published: November 2006

This paper describes SIMONE, an extension of PASCAL,1 which provides the quasiparallel programming facility of SIMULA 67, but without classes or references. The language is intended to be suitable for the design, testing and simulation of operating system algorithms. It is illustrated by simple examples, suitable as project material in a course on operating systems. A simple, restricted, but efficient implementation is described. It is suggested that the language might be suitable for more general simulation purposes, and an example of a general job shop simulation is given.
Lektor‐a list‐oriented, machine‐independent programming system for conversational applications
Authors: Hummel Helmut
Published: November 2006

This paper introduces the machine‐independent programming system LEKTOR which has been used for research and developmental work in computer‐based learning since the beginning of 1974. The most important language elements and the system architecture are described. Emphasis is placed upon questions of implementation, particularly with regard to the data structures and the organization and administration of the workspace.
Macro SPITBOL—a SNOBOL4 compiler
Authors: Dewar Robert B. K. , McCann A. P.
Published: November 2006

A fast and compact compiler/interpreter for SPITBOL (a variant of SNOBOL4) has been written in a machine‐independent macro assembly language and implemented initially on the ICL 1900 range of computers. The interpreter uses a novel form of indirect polish code which assists portability. Compile‐time pre‐evaluation of constant expressions has proved to be a worthwhile optimization. A description is given in some detail of the simple but rapid scheme, requiring no marker bits, employed for garbage collection.
The design and implementation of the nag master library file system
Authors: Richardson M. G. , Hague S. J.
Published: November 2006

The NAG Master Library File System is described in terms of its structure and function, with particular reference to the rationale and design constraints adopted and to the actual functioning of the system within the NAG project.
Generating code for a hypothetical computer using a production assembler
Authors: Nutt Gary J. , Schulz Waldean A. , Williamson Karl H.
Published: November 2006

Production assemblers are often thought of as being useful only for generating machine code from a symbolic assembly language delivered with the system. Most production assemblers that have a macro capability can be used to create an assembler for an arbitrary target machine through the use of the technique discussed in this short communication. This approach has the advantages of quick construction, easy modification and a resulting assembler for the target machine that is nearly as powerful as the original production assembler.
Does APL really need run‐time parsing?
Authors: Strawn George O.
Published: November 2006

Most APL systems delay all parsing until run‐time. Because the APL expression language is inherently ambiguous and because identifier binding is delayed until run‐time, some runtime parsing is shown to be necessary. Nevertheless we argue that most APL statement parsing can be done at entry‐time and that there are several reasons for doing so. Then a technique is described whereby APL statements are partially parsed at entry‐time and are parse completed at run‐time.
The advantages of stream output procedures over format‐dominated record transmissions
Authors: Hunter G. , Kuriyan M. , Wallis A.
Published: November 2006

This paper shows that stream output procedures can produce well‐formatted printing, with the layout of each line being totally under program control to suit the particular data being processed. This capability for completely general and dynamically variable formats is not possessed by the more commonly used unit‐record output facilities. The distinction is illustrated by a simple example, which in terms of stream‐oriented procedures is an almost trivial programming exercise, but where the use of conventional unit‐record facilities leads to a combinatorial explosion. The corresponding input procedures are also discussed.
Using pascal in a fortran environment
Authors: Mohilner Patricia R.
Published: November 2006

The ability to use existing libraries is essential if a programming language is to be of practical value. This paper presents the experience gained in using Pascal in a Fortran environment and details the resolution of problems encountered in file communication, parameter passing and establishing default values under the condition of mixed language programming. It is concluded that Pascal is viable as a practical programming language, provided that EXTERN and FORTRAN procedures are implemented.
Success and failure analysis of a problem solving system implementation
Authors: Symes L. R. , Oldehoeft R. R.
Published: November 2006

The NAPSS (Numerical Analysis Problem Solving System) project was an attempt to develop an interactive system, with a high‐level language resembling conventional mathematics, for solving problems in numerical analysis. This report uses NAPSS as an example to discuss some aspects of the design and implementation of the programming languages and software which comprise problem solving systems. Successful features as well as failures (with alternative proposals) are detailed in the areas of general language management, specific language features and the operating system interface. In general, a massive, coherent implementation of theoretical work being done at the frontiers of research has abundant opportunity for failure.
On code generation in a PASCAL compiler
Authors: Ammann Urs
Published: November 2006

This report deals with code generation in a PASCAL compiler. It gives insight into the runtime organization of data and the use of the hardware registers of the underlying machine (a CDC 6400). It is shown how the compiler maintains a description of the register contents and uses this description to generate efficient code. Several examples of compiled code are discussed.
Real‐time BASIC for laboratory use
Authors: Ormicki Andrzej
Published: November 2006

The syntax and implementation of an interpretive method for handling interrupts within the context of a small foreground‐background BASIC system are described. The implemented system can be used on an 8K NOVA minicomputer without background storage and is designed for data collection and process control in the laboratory.

Non‐standard I/O devices can be easily serviced in the foreground.
Designing overlay structures
Authors: Gentleman W. Morven , Munro J. Ian
Published: November 2006

Although overlaying code segments is a very old technique, there is very little literature 68 on what the ground rules are, what the options are and how to select an overlay structure. As a result, the facilities provided by most linkage editors are much poorer than they need be. In this paper we define the problem, give an algorithm for obtaining ‘minimal’ overlay structures and describe the surrounding commands and environment that are necessary to turn this algorithm into a practical tool.
Hierarchical monitors
Authors: Lister A. M. , Sayer P. J.
Published: November 2006

A technique is presented for constructing an operating system as a hierarchical set of monitors. The hierarchy reflects and reinforces the system structure, and extends down to the system nucleus itself. The nucleus is in fact treated as a specialized monitor for handling the central processor. The technique has been used to write a small pilot system for a DEC PDP‐15, and experience with the system is reported. The mutual exclusion problem for monitor procedures is discussed, and a viable solution suggested.
Ambiguities and insecurities in pascal
Authors: Welsh J. , Sneeringer W. J. , Hoare C. A. R.
Published: November 2006

Ambiguities and insecurities in the programming language Pascal are discussed.
BASIC—an evaluation of processing methods and a study of some programs
Authors: Hammond John
Published: November 2006

The relative merits of compiling and interpreting BASIC are examined, and these methods are compared with the technique called throw‐away compiling. The comparison reveals that a throw‐away compiler has much to recommend it, and some reasons for its superior performance are explained. The BASIC programs used for the performance tests are analysed, both statically and dynamically, and certain features are picked out for comment.
Eliminate flowchart drawings
Authors: George Richard
Published: November 2006

The difficulties in creating clean programming flowcharts and of generating good code from them are reviewed, and the line of thought is shown which leads to the elimination of drawings from the programming process. Benefits are cited.
Design and implementation of a display oriented text editor
Authors: Macleod Ian A.
Published: November 2006

This paper outlines the design and implementation of a text editor which is designed for use on an alphanumeric display terminal with cursor control. Text may be edited directly on the screen by deleting, overstriking or inserting characters. There also exist commands to manipulate and search sections of text. A major design consideration was that the editor should be easily usable by untrained casual users.
The calibration and validation of a hybrid simulation/regression model of a batch computer system
Authors: Gomaa H.
Published: November 2006

Calibration and validation are two stages in the development of a performance model of a computer system during which the degree of confidence in the model is established. This paper describes a case study of the calibration and validation of a hybrid simulation/regression Load Adjusting Model of a batch computer system. During calibration, a given workload trace was applied to the Load Adjusting Model and the parameters of the model were adjusted using an iterative tuning procedure. During validation, the parameters of the model, established during calibration, were kept constant and the model was tested using different workload traces.
MOUSE4: An improved implementation of the RATFOR preprocessor
Authors: Comer Douglas
Published: November 2006

RATFOR is a preprocessor language for FORTRAN that supports structured flow of control statements and macrosubstitution. The RATFOR processor, written in RATFOR, is modular, carefully coded and portable, but extremely inefficient. A profile of the running time revealed that a linear search in the macroprocessor consumed over half of the CPU time. Running time was reduced by over 50 per cent when a binary search was used. Our observation is of interest primarily because it differs from previously reported measurements.

A more dramatic improvement in running time was obtained by rewriting the ad hoc lexical scanner using a standard method based on finite automata. For a 3,000‐line source program the standard RATFOR required 185.470 CPU seconds on a CDC 6500 while the automata‐based version needed only 12.723 seconds.

We conclude that, contrary to evidence exhibited by the designer of RATFOR, sequential search is often inadequate for production software. Furthermore, in the case of lexical analysis, well‐known techniques do seem to offer efficiency while retaining the simplicity, ease of coding and modularity of ad hoc methods.
An evaluation of the effectiveness of symbolic testing
Authors: Howden William E.
Published: November 2006

The effectiveness in discovering errors of symbolic evaluation and of testing sad static program analysis are studied. The three techniques are applied to a diverse collection of programs and the results compared. Symbolic evaluation is used to carry out symbolic testing and to generate symbolic systems of path predicates. The use of the predicates for automated test data selection is analysed. Several conventional types of program testing strategies are evaluated. The strategies include branch testing, structured testing and testing on input values having special properties. The static source analysis techniques that are studied include anomaly analysis and interface analysis.

Examples are included which describe typical situations in which one technique is reliable but another unreliable. The effectiveness of symbolic testing is compared with testing on actual data and with the use of an integrated methodology that includes both testing and static source analysis. Situations in which symbolic testing is difficult to apply or not effective are discussed. Different ways in which symbolic evaluation can be used for generating test data are described. Those ways for which it is most effective are isolated. The paper concludes with a discussion of the most effective uses to which symbolic evaluation can he put in an integrated system which contains all three of the validation techniques that are studied.
A symbolic system for computer‐aided development of surface interpolants
Authors: Feng David Y. , Riesenfeld Richard F.
Published: November 2006

The design and implementation of a symbolic input end computation package and its application to the development of several new surface interpolation schemes are described. Capabilities such as the composition of operators and symbolic differentiation have been incorporated into the system. This allows, in particular, the specification of Boolean sum projectors. The new schemes which have been implemented include an interpolant to randomly spaced data and a 'shape operator1 which has quadratic precision.
Software design representation: Analysis and Improvements
Authors: Freeman Peter
Published: November 2006

This paper analyses in detail the design representation described in the preceding paper. Two sets of dimensions are defined and both representations‐metacode and decision statements‐ are evaluated against them. Suggestions for improving design representations, both these and in general, are presented.
Implementation of a computer job scheduling algorithm: A case history
Authors: Gujar Uday G. , Fellows David M.
Published: November 2006

Multiprogramming systems require that a fair, equitable algorithm be used for the scheduling of jobs. This paper discusses some of the problems associated with this and proposes an automatic job scheduling algorithm. The major parts of the algorithm have been implemented and have been in use for over one year. The user interface is simplified and the operational complexities are minimized. The parameters used for the algorithm are the estimates of the central processor time and the memory required by the job. All types of jobs including those requiring operator attention during execution are covered under the scheme. Operational data and the reactions from the users indicate that the results have been as expected.
Introducing graphics capabilities to several high‐level languages
Authors: Ng Nam , Marsland T. A.
Published: November 2006

The development of basic support software for a graphics facility requires extensive programming effort, which is sometimes duplicated when the facility is made available from other languages. This paper explores an alternative, which has the advantages that only a single software package need be built for use by a variety of host languages, and no modification is necessary to their compilers. Fortran, PL/I and Algol W are the example hosts used in the feasibility studies, but the approach can be extended.
A highly reliable file system which supports multiprocessing
Authors: Barnett J. K. R.
Published: November 2006

A file system is described which should be proof against hardware and software errors of considerable severity, as well as overcoming the problems caused by a sudden system stop (due, for example, to power failure). An important aspect of the latter is preservation of logical integrity at arbitrary levels of abstraction. Multiprocessing is supported at a record‐locking, rather than file‐locking, level. The system allows highly efficient access to large (e.g. multimillion) keyed‐record files. The system is considered suitable for operating system file catalogues, and data bases.
Guidelines for software portability
Authors: Tanenbaum Andrew S. , Klint Paul , Bohm Wim
Published: November 2006

The areas in which programs are most unlikely to be portable are discussed. Attention is paid to programming languages, operating systems, file systems, I/O device characteristics, machine architecture and documentation. Pitfalls are indicated and in some cases solutions are suggested.
The UNIX™ programming environment
Authors: Kernighan Brian W. , Mashey John R.
Published: November 2006

The UNIX

UNIX is a trademark of Bell Laboratories.

operating system provides an especially congenial programming environment, in which it is not only possible, but actually natural, to write programs quickly and well.

Several characteristics of the UNIX system contribute to this desirable state of affairs. Files have no type or internal structure, so data produced by one program can be used by another without impediment. The basic system interface for input and output provides homogeneous treatment of files, I/O devices and programs, so programs need not care where their data comes from or goes to. The command interpreter makes it convenient to connect programs, by arranging for all data communication.

Complex procedures are created not by writing large programs from scratch, but by interconnecting relatively small components. These programs are small and concentrate on single functions, and therefore are easy to build, understand, describe, and maintain. They form a high level toolkit whose existence causes programmers to view their work as the use and creation of tools, a viewpoint that encourages growth in place of reinvention.

Tools interact in a limited number of ways, but can be used in many different combinations. Thus, an addition to the toolkit tends to improve the programming power of the user faster than it increases the complexity of interconnection and maintenance. Finally, tools are connected at a very high level by a powerful command language interpreter. The error‐prone and expensive process of program writing can often be avoided in favor of program‐using.

In this paper we will present a variety of examples to illustrate this methodology, focusing on those aspects of the system and supporting software which make it possible.
A new implementation technique for applicative languages
Authors: Turner D. A.
Published: November 2006

It is shown how by using results from combinatory logic an applicative language, such as LISP, can be translated into a form from which all bound variables have been removed. A machine is described which can efficiently execute the resulting code. This implementation is compared with a conventional interpreter and found to have a number of advantages. Of these the most important is that programs which exploit higher order functions to achieve great compactness of expression are executed much more efficiently.
The NAG library ‘machine’
Authors: Ford B. , Bentley J. , du Croz J. J. , Hague S. J.
Published: November 2006

If a reliable, high quality numerical algorithms library is to be developed then it is essential that we recognize the need for collaboration between different technical communities in the development of the library. This paper suggests an ultimate design for the library and describes the implications of that design for the people involved in the development of the library.
A heap‐based implementation of the programming language Pascal
Authors: Marlin C. D.
Published: November 2006

The implementation of Pascal known as Pascal ‘P’ was modified so that activation records for blocks (procedures and functions) were no longer allocated on a stack, but were instead allocated on a heap. This was done partly to test the feasibility of using Pascal ‘P’ for experimenting with extensions to Pascal, and partly to assess the efficiency of implementing Pascal procedures and functions in this way. The necessary changes to Pascal ‘P’ are described; where alternative strategies were possible, these are outlined and the reasons for the final choice given. The heap management algorithms used are presented and, in particular, their behaviour when managing the activation records of Pascal programs which do not involve dynamic variables is explained. Quantitative comparisons are made between Pascal ‘P’ and the version with heap‐allocated activation records, to assess their relative efficiencies; these comparisons indicate that the modified system uses more storage, but it gives rise to only slightly longer execution times. Alternative heap management algorithms are discussed. Finally, some advantages of heap‐allocated activation records are presented.
MAP: A Pascal macro preprocessor for large program development
Authors: Comer Douglas
Published: November 2006

The 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

This 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

This 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

The 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

Several 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.
File maintenance using a line editor
Authors: Carter B. S.
Published: November 2006

A small suite of programs has been developed which, when used in conjunction with a computer manufacturer's line editing program, may be used for the maintenance and updating of files where the number of data cards for each subject is not necessarily constant. The programs may also be used when there is only one card for each subject.
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

The 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.
Experience of transporting and using the SOLO operating system
Authors: Powell M. S.
Published: November 2006

This paper describes some of the problems incurred when transporting the SOLO operating system from a PDP 11/45 to a smaller Modular One. Some comments are made about the intrinsic portability of operating systems written in high level languages and their flexibility in use.
Resolving ambiguous identifiers
Authors: Sites Richard L.
Published: November 2006

In 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

This 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.
MUSS—a portable operating system
Authors: Theaker C. J. , Frank G. R.
Published: November 2006

This paper describes a technique for producing a machine‐independent operating system with a high level of performance. The technique is based on the definition of a hypothetical ideal machine, which acts as the target computer for the operating system. The characteristics of this ideal machine are described in detail.
Strings and the sequence abstraction in Pascal
Authors: Sale A. H. J.
Published: November 2006

This paper examines the sequence abstraction known in Pascal as the ‘file’, and shows how sequences of characters (‘strings’ in the SNOBOL sense) may be cleanly fitted into Pascal‐like languages. The specific problems of providing the suggested facilities as an experimental extension to Pascal are examined.
Automatic generation of aggregate operators in ALGOL 68
Authors: Middleton Tony
Published: November 2006

It is quite often necessary to write several variations of an ALGOL 68 operator to allow the dimensionality of the operands to vary from one variation to another. A system has been written which will automatically generate such variations. The system is a preprocessor written in SNOBOL.
A case for acquiring Pascal
Authors: Joslin D. A.
Published: November 2006

This paper is a copy of the case made by the author to his County Council for acquisition of a Pascal compiler for their computer. Its message is essentially that Pascal is the best thing since sliced bread.
Implementing strings in Pascal
Authors: Bishop Judy M.
Published: November 2006

Sale1 has proposed that strings be realized in Pascal using the existing sequence abstraction. This short note supports this proposal and shows how strings can be efficiently implemented in standard Pascal. The implementation is done in such a way as to leave existing programs undisturbed should strings be subsequently incorporated in the language and/or compiler.
Systems implementation languages and IRONMAN
Authors: Wand I. C.
Published: November 2006

The 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

Sequence 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

The 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.
An experiment in parallel program design
Authors: McKeag R. M. , Milligan P.
Published: November 2006

This paper describes the development of a program to solve the Henderson and Snowdon ‘Telegrams Problem’, the program being expressed as a set of communicating sequential processes (Hoare7).
Maintaining program variants by merging editor scripts
Authors: Fraser Christopher W.
Published: November 2006

The 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.
An overview of Ada
Authors: Barnes J. G. P.
Published: November 2006

This paper commences with an outline description of the development of the Ada programming language and its position in the overall language scene. The body of the paper is an informal description of the main features of the final language as revised after the Test and Evaluation phase of the DoD project. Comparison with the preliminary version is made where appropriate.
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

Four 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

In 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

The 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

The 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.
Edison—a multiprocessor language
Authors: Hansen Brinch
Published: November 2006

This paper defines a programming language called Edison. The language is suitable both for teaching the principles of concurrent programming and for designing reliable real‐time programs for multiprocessor systems. Edison is block structured and includes modules, concurrent statements, and when statements.
Message passing between sequential processes: The reply primitive and the administrator concept
Authors: Gentleman W. Morven
Published: November 2006

Message 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

The 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

Managers 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

A 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

This 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

This 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

Two 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

The 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

Continuing 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

Block 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

We 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

This 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.
Experiences with a status database
Authors: Bishop J. D. , Smith G. J.
Published: November 2006

Describes the STATUS free‐text information retrieval system and experiences with its use for a bibliographic database. Factors involved in the growth of the database such as updating times, frequency of word occurrence, and file sizes are discussed in detail, and reactions to the system's performance and reliability are given.
PIC — A language for typesetting graphics
Authors: Kernighan Brian W.
Published: November 2006

PIC 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 image

Most 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

In 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.