bluuebunny/crossref_metadata_2025 huggingface dataset:
Rainbow—a multi‐purpose CAD system
Authors: Wiseman N. E. , Cheney C. J. , Etherton M. , Hiles J. O. , Lemke H. U.
Published: November 2006

This paper describes RAINBOW, an integrated suite of programs for assisting in the specification and design of networks—electrical, logical or otherwise. Data input are primarily graphical and manual transcription of data for subsequent phases of the design analysis is virtually eliminated by the use of a uniform data base, generated at the time of input. The RAINBOW system depends heavily on the software support of a filing system with on‐line access; this is briefly described. A description of the internal structures used to model the data is given. The component programs of RAINBOW, in its present state of development, are listed and described. The paper concludes with some suggestions for improvements and extensions to the system.
An on‐line data collection system for film measurement
Authors: Bracher B. H. , Macewan J. F. , Abbott A. G.
Published: November 2006

This article describes the basic elements in the Rutherford Laboratory on‐line film measurement system, in which twelve film measuring machines are connected on line to an IBM 1130. The 1130 is linked to an IBM 360/195 by a parallel data link. The article mentions some of the lessons learnt in going on‐line and describes current and future developments.
The mobile programming system, Janus
Authors: Coleman S. S. , Poole P. C. , Waite W. M.
Published: November 2006

Janus is a symbolic language used to embody the information which is normally passed from the analysis phase of a compiler to the code generators. It is designed for transporting software: A program coded in a high level language can be translated to Janus on one computer, and the resulting output translated to assembly code on another. (The STAGE2 macro processor could be used for the second translation.) In this paper we present the principles upon which Janus is based, and show that it is suited to a wide range of source languages and target computers.
Optimization of structured programs
Authors: Zelkowitz Marvin V. , Bail William G.
Published: November 2006

The class of programs which do not contain goto statements has a structure which lends itself to optimization by an optimizer that is fast, efficient and relatively easy to program. The design of such an optimizer is described, along with some of the results obtained using this optimizer—one such result being that very little code optimization is achieved. The conjecture is made that this is true because gotoless programming languages lend themselves to more compact and concise object code at the source language level.
A simple interactive graphics facility
Authors: Milne W. J.
Published: November 2006

This paper describes the incorporation of a graphics facility into an existing interactive system. Emphasis is placed on the importance of an inexpensive system with a simple user interface. Details of some implementation considerations are given.
Design and implementation of an interactive test bed
Authors: Bate D. G.
Published: November 2006

An interactive test bed for programs written in the system development language CLSD is described. It consists of a compiler and an interactive interpreter. The test facilities and the internal design of the test and bed are described in detail.

Experience has demonstrated this to be a very valuable tool in program development.
Virtual storage on ICL 1900's
Authors: Farr G. L.
Published: November 2006

This paper deals with a simple and tested method of giving an ICL 1901A virtual storage with existing software. It is particularly concerned with the immediate processing of FORTRAN programs requiring more than 16K words of store on 16K machines.
Does APL really need run‐time checking?
Authors: Bauer Alan M. , Saal Harry J.
Published: November 2006

APL in its present interpretive implementations provides an ideal tool for the development of programs. The interpretive overhead, however, often prohibits the running of large production programs. Our results indicate that the overhead involved in checking type and size compatibility of the arguments of APL primitive functions during execution can be substantially avoided without loss of error detection.

Using a large sample of syntactically correct APL programs, a statistical analysis was performed on the required conformability checks for each function. We have compiled (for each type of conformability check in each program) statistics on the percentage of checks that could be eliminated by static analysis and verification. The programs analysed contained 1,454 primitive functions. Of the 2,412 rank, length, domain and value checks required by a ‘naïve’ interpreter, 1,966 (80 per cent) can be validated statically. Index checks were required only thirty‐one times, but essentially all must be evaluated at run time. This suggests that compilation of APL programs to conventional target codes may be feasible as a high performance implementation whenever the cost of such translation does not dominate.
A mixed language system POP‐2 and FORTRAN
Authors: Maccallum K. J. , Shafe L. T.
Published: November 2006

In designing a POP‐2 compiler for the CDC 6000 series machines, it became apparent that there was a requirement to link to precomiled FORTRAN subprograms in order to use the advantages of FORTRAN and to make use of the extensive liberaries available. This paper describes the design considerations, the principal problems involved and the subsequent implementation of the POP‐2/FORTRAN system. It is concluded that the general design aims were successfully achieved, that is: the system is primarily a POP‐2 system, calls to FORTRAN subprograms have exactly the same syntax as calls to POP‐2 functions and the restrictions on FORTRAN subprograms are minimal. The space overhead of having FORTRAN unused is about 10 per cent.
Dynamic data structure mapping
Authors: Desjardins Pierre
Published: November 2006

This paper describes a high‐level language construct representing two facilities: dynamic absolute addressing and dynamic overlaying of variables. Its implementation in the programming language PASCAL is described in some detail. It is shown to provide simple and effective ways of increasing the effeciency of in‐core data access and transfer, and attaining greater program transportability.
A software teletype exchange
Authors: Jones D. A. , Partington N. J.
Published: November 2006

This paper describes the design and implementation of a software teletype exchange for a multi‐access service using linked KDF9—PDP8 computers. The KDF9 can support up to 20 on‐line terminals and the PDP8, in which the software exchange operates, can support 32 terminals. This software operates like an automatic telephone exchange with a user‐optional waiting queue, and has been used at the Universities of Glasgow and Liverpool to widen the availability of the multi‐access system COTAN.

At Glasgow, using additionally a hardware exchange, about 50 terminals may compete for access to COTAN. At Liverpool a set of on‐line terminals has been specifically provided for undergraduate teaching.
Implementation of a management game
Authors: Thomas R. E. , Toll D. C.
Published: November 2006

The purpose of this paper is to describe the implementation of a management training game on two different computers. A brief description of the game is included, giving an idea of what the game looks like to the players and the controller. The two implementations are, firstly, on an Atlas I computer, with a multi‐access system provided by an XDS Sigma 2 computer, and secondly on an ICL 1906A runing under the control of the GEORGE 4 operating system. Mention is made of some of the difficulties encountered in each case, and of the techniques employed to solve these problems.
The definition of comments in programming languages
Authors: Scowen R. S. , Wichmann B. A.
Published: November 2006

This paper examines the concept of comments in programming languages and answers the questions: Why are they needed? How are they defined and implemented in existing languages? What should be provided in future languages?
On a loose communication between dissimilar CDC 6000 operating systems
Authors: Franta W. R. , Houle P. A.
Published: November 2006

This paper describes a system, known as LINK, which provides inter‐machine communication between like machines operating under significantly different operating systems. The methodology employed by LINK was selected from among several alternatives on the basis of effectiveness, complexity and cost.
Some statistics on the reasons for compiler use
Authors: Kulsrud H. E.
Published: November 2006

This paper describes a method for collecting statistics about the use of compilers as part of the programming process. Results of an application of this method to a time‐shared system are presented. A study of the data leads to conclusions about the relative numbers and computer times of compilations used for program writing, correcting and checking. A comparison of two languages surveyed is also made.
POP‐2 performance on a small 1900 machine
Authors: Barker P. G.
Published: November 2006

A simple benchmark is described which enables the performance of the programming language POP‐2 to be investigated. The benchmark, run using the Multiple On‐line Programming (MPO) facilities of the GEORGE 3 operating system, is used to investigate the effects of certain installation controlled running conditions upon terminal response. The results of some of the investigations are presented and an indication of future areas of study is given.
Rapid calculations of subscripted array addresses
Authors: Bell James R.
Published: November 2006

A software mechanism called a ‘multiply table’ is proposed to increase the speed of subscripted array address calculation. An analysis shows that it can sometimes provide a significant increase in speed at an acceptably low cost in space.
Implementation of a graphics and text output retrieval system
Authors: Girard P. M. , Rose I. H. , Scott D. B.
Published: November 2006

This paper describes the implementation of a disk filing facility, providing on‐line access to graphics and text output produced by jobs run in a batch environment. The introductory sections establish the general context in which the system is used and give some indication of the main facilities. The structure and properties of the files and the various implementation problems, such as multi‐access control and file security, are then outlined. The last section deals with the techniques used for diverting line printer output from batch jobs into the filing system. Finally, an attempt is made to assess the advantages and disadvantages of the principal methods.
Notes on the case statement
Authors: Barth C. Wrandle
Published: November 2006

The case statement is one of the newest and one of the least known of the ‘standard’ control structures in higher level languages. Its importance has increased with the greater use of structured and goto‐less programming. This paper surveys the development of the case statement and provides two extensions which are natural and intuitive and which, it is claimed, increase the intellectual manageability of the host language.
The University of Warwick modular one operating system
Authors: Footit R. M. , Whitby‐Strevens C.
Published: November 2006

This paper contains a description of an operating system development project undertaken in the Department of Computer Science at the University of Warwick. It describes in detail an operating system developed with the aims of aiding teaching by employing multiple‐access techniques, establishing a research environment, and providing practical insight into the problems of multiprocessor operating systems.
A general‐purpose text editor for OS/360
Authors: Hazel P.
Published: November 2006

The IBM 370/165 system at Cambridge provides batch and interactive computing facilities under OS 360/MVT with the Time Sharing Option (TSO). The Cambridge text editor, EDIT, provides comprehensive file manlpulation facilities in a unified manner for both batch and interactive users.
Solving synchronization problems using semaphores
Authors: Radue J. E. , Mullins J. M.
Published: November 2006

A brief account of certain extensions to the basic definition of semaphores is given. An implementation of semaphores as controllers of buffer queues is described and it is shown how this was used to solve an actual synchronization problem.
A high‐level job control language
Authors: Parsons I. T.
Published: November 2006

A high‐level language approach has been used to define a powerful, flexible and machine‐independent control language, in which many of the desirable facilities that are available in modern programming languages have been included. This paper describes the language and its application to the problems of job control, and suggests its further use in a multi‐machine environment.
The design of a real‐time operating system for a minicomputers. Part 1
Authors: Purser W. F. C. , Jennings D. M.
Published: November 2006

The design objectives of real‐time operating systems for minicomputers are considered. Simplicity, efficency and avoidance of superfluities are the main criteria. A typical multitasking structure is sketched and the executive elements to support it are analysed. Examples of their use in simple Input/Output are given. Filing systems are then discussed, followed by the interface with the operator. Finally, the problem of linking and loading the modules which make up a simple core‐resident real‐time system is reviewed.
An overview of a system for automatic generation of file conversion programs
Authors: Rin N. Adam , Brown Maxine
Published: November 2006

This paper describes a processor which automatically produces file conversion programs based on non‐procedural user specification. The processor accepts, as input, descriptions of a source file and a desired target file with some auxiliary descriptions of associations between the two. This is specified by a user in a Data Description Language (DDL). To specify validation criteria, complex conversions not built in to the system, security criteria or summary processes, the system also accepts specifications in a Data Manipulation Language (DML). It produces, as an output, a conversion program in PL/1 capable of converting the described source file into the desired target file. The paper describes the structure, system design, capabilities and applications of the DDL/DML language and processor, including an illustrative example.
Embedding non‐determinism
Authors: Self John A.
Published: November 2006

This note describes a method of enabling non‐deterministic algorithms to be written in conventional deterministic programming languages. The method involves a dynamic manipulation of stack contents, and is contrasted with standard techniques of implementing non‐deterministic programming languages.
A transportable extendable compiler
Authors: Basili Victor R. , Turner Albert J.
Published: November 2006

This report describes the development of a transportable extendable self‐compiler for the language SIMPL‐T. SIMPL‐T is designed as the base language for a family of languages. The structure of the SIMPL‐T compiler and its transportable bootstrap are described. In addition, the procedures for generating a compiler for a new machine and for boot‐strapping the new compiler on to the new machine are demonstrated.
Discrete event simulation in algol 68
Authors: Shearn D. C. S.
Published: November 2006

An outline of the three phase method of discrete event simulation is given, and problems in designing a language for this method based on ALGOL 68, together with the final form of the language, are discussed. An important area is seen to be that of lists or sets, and the necessity of devising facilities that are powerful yet simple to use is stressed. Operators are shown to be particularly useful for this.
Hints on distributing portable software
Authors: Waite W. M.
Published: November 2006

Would‐be implementors of portable software often encounter frustrating difficulties when attempting to enter the distributed text into their computers. This paper summarizes various problems which may arise, and indicates how the distributor can head them off. The conventions used by several successful distributors are given to illustrate possible solutions.
Towards the design of secure systems
Authors: Jones Anita K. , Wulf William A.
Published: November 2006

Within a programmed system, we may distinguish between different kinds of information in order to control the use of each kind by separate security policies, where each policy is tailored to the sensitivity and desired dissemination of that one kind of information. This paper analyses the implications of implementing security policies and describes mechanisms which can be used as the basis for constructing operating systems with the desired security attributes.
Evaluation of markov program models in virtual memory systems
Authors: Bogott Robert P. , Franklin Mark A.
Published: November 2006

A first order Markov model of program behaviour is developed from FORTRAN program instruction data. The program model is evaluated by using it to generate page references for input into a simple virtual memory operating system (VMOS) simulation model. The actual trace data are also used to drive the VMOS model. In both cases the fault probability is obtained for different replacement rules, memory sizes and page sizes. A comparison of fault probabilities is used to determine the effectiveness of the Markov program model.
Recent developments in machine‐independent job control languages
Authors: Rayner D.
Published: November 2006

The paper gives a general survey of recent developments in the field of Job Control Languages. Three high‐level portable job control languages (UNIQUE, GCL and ABLE) are presented in outline, and their merits and disadvantages are discussed. The approaches of the MU5 and of single‐language machines are discussed together with the question that these pose: ‘Is a JCL as such really necessary?’ In conclusion particular reference is made to the question of standardization and to the continuing work in this field.
The new programming discipline
Authors: Neely Peter M.
Published: November 2006

Recently there has been substantial interest in promoting ‘Structured Programming’ as a means of writing more nearly error free programs. However since the chief advocates of structured programming use ALGOL or PASCAL, and disdain FORTRAN, there is a difficulty in communication. Since it is my perception that structured programming and the lessons to be learned from proofs of correctness can be applied in any language, including FORTRAN, I feel that these ideas should be promulgated to applied scientific programmers.

Hence this paper will commence with a summary of the whole complex of ideas and practices that are subsumed under the term ‘Structured Programming’. Then some simple examples of top down design and programming will be given. Finally I will return to a discussion of some of the problems which are likely to be encountered in the use and promulgation of structured programming.
Computer system resource requirements of novice programming students
Authors: Nutt Gary J.
Published: November 2006

The characteristics of jobs that constitute the mix for lower division FORTRAN classes in a university are investigated. Samples of these programs are also benchmarked on a large central site computer and two minicomputer systems. The conclusion of this study is that a carefully chosen minicomputer system could offer service at least the equivalent of the service provided by the central site system, and that certain aspects of this service could be distinctly better.
The production of special function routines for a multi‐machine library
Authors: Schonfelder J. L.
Published: November 2006

The design requirements for special function routines in a multi‐machine Library such as the NAG library are discussed. The choices made and the conventions adopted to overcome some of the problems that arise in this type of project are outlined. A description is given of the semi‐automatic handling that is done to ease the problem of producing versions of the routines for any reasonable precision of arithmetic. The basic testing procedures are also covered briefly.
Cobol generation of source programs and reports
Authors: Peterson Norman D.
Published: November 2006

SURGE, a COBOL pre‐processor for the machine generation of source programs, is described. The article presents the coding procedure by which the user communicates with SURGE, and briefly introduces the general logic of both the pre‐processor and generated programs. The main capabilities of SURGE are described as file sorting, selective retrieval and tabular report preparation, including multiple levels of totals and a capability for certain other kinds of computation. Non‐proprietary and relatively machine‐independent, this package appears to reduce the need for hand‐crafted COBOL programs and to be remarkably easy to learn and use. It is suggested that SURGE also may offer a suitable prototype for extending the concept of source‐program generation to other goals such as file updating and the production of FORTRAN programs.
The solo operating system: Job interface
Authors: Hansen Per Brinch
Published: November 2006

This paper describes the interface between sequential Pascal programs and the Solo operating system.* A sequential program interacts with the operating system by means of procedure calls. A program prefix defining these procedures and their parameters enables the compiler to make complete type checking of calls to the operating system. The Solo interface permits Pascal programs to call one another recursively. This makes it possible to use Pascal as the job control language.
The solo operating system: Processes, monitors, and classes
Authors: Hansen Per Brinch
Published: November 2006

This paper describes the implementation of the Solo operating system written in Concurrent Pascal.* It explains the overall structure and details of the system in which concurrent processes communicate by means of a hierarchy of monitors and classes. The concurrent program is a sequence of nearly independent components of less than one page of text each. The system has been operating since May 1975.
Syntax‐directed correction of syntax errors
Authors: Feyock Stefan , Lazarus Paul
Published: November 2006

The systematic approach to compilation represented by syntax‐directed compilers makes possible a similarly systematic approach to the automatic correction of syntax errors. This paper describes the syntax‐directed syntax error correction system EXPL. Techniques for pinpointing the locations of syntax errors, generating sets of possible corrections and for choosing the best correction from such a set are presented. A particularly promising approach involves the use of semantic information to assist in the elimination of inappropriate syntactic corrections.
Multi‐dimensional summations in FORTRAN
Authors: Guttmann A. J.
Published: November 2006

A general method of calculating multi‐dimensional sums using the FORTRAN language is presented. In particular, a FORTRAN subroutine is given that calculates the required function arguments at each call. The usual arrangement of nested DO loops is discarded. The method makes it quite easy to change the dimensionality or range of the summation.
Minivital: A compiler case study
Authors: McClure Robert M. , Gauthier Richard L.
Published: November 2006

This paper is the case study of a compiler for a very large language implemented for a minicomputer. Although the language is special purpose and perhaps not of general interest, the techniques used and the performance obtained make the compiler itself somewhat interesting.
Application of accounting data in evaluating computer system performance
Authors: Sreenivasan K.
Published: November 2006

A method of determining the utiliaztion of the processor, the channel and the disk device using the accounting data is described. Controlled experiments are performed with an IBM 370/155 in a dedicated environment using a software monitor, Configuration Utilization Evaluator (CUE). The accounting data collected by Systems Management Facility (SMF) during these experiments are used to calculate the utilization of the processor, the channel and the disk device. The calculated values compare favourably with those measured by the software monitor.
Variable associations in SNOBOL4
Authors: Hanson David R.
Published: November 2006

This paper describes a new facility in the SNOBOL4 programming language that provides the capability to associate the execution of a programmer‐defined function with the act of assigning a variable a value or retrieving the value of a variable. The facility, called programmer‐defined variable association, subsumes the existing built‐in associations used for input, output and value tracing and provides, at the source‐language level, the protection and datatype coercion mechanisms used in keywords. Several applications are described that illustrate the usefulness of this addition to the language. The facility is especially useful for program monitoring and debugging. The implementation of this facility and the effect of implementation techniques on programming language design are also discussed.
JUMBO—a demonstration program to illustrate the use of BCPL in a real‐time graphics application requiring scaled arithmetic
Authors: Richards M.
Published: November 2006

This paper describes the key features of a simple program to simulate the flying characteristics of an aircraft and display in real‐time the flight instruments and pilot's view of the ground on a cathode ray tube. The program was written in BCPL using only 16 bit scaled arithmetic for all the numerical calculations.
Documentation for computer users
Authors: Newman N. , Lang T.
Published: November 2006

This paper describes the nature, purpose and importance of documentation for users of computers. The key factors in the good design of documentation are considered. Particular emphasis is placed on the matching of the presentation to the background and needs of the users. The problems of production and circulation are also outlined.
The design of a real‐time operating system for a minicomputer. part II
Authors: Purser W. F. C.
Published: November 2006

Part II of the paper discusses elaborations of the simple system described in Part I. These are aimed at making the system more secure, allowing it to support larger programs and lightening the drudgery of coding for it.
Implementation of a PASCAL compiler for the IBM 360
Authors: Russell David L. , Sue Jeffrey V.
Published: November 2006

The implementation of a compiler for a subject of PASCAL on the IBM 360 is reported. Some difficulties encountered using PL/I for the bootstrap are discussed.
An implementation of monitors
Authors: Lister A. M. , Maynard K. J.
Published: November 2006

Monitors and similar constructs have been suggested by Hansen1 and Hoare2 as suitable structuring concepts for operating systems. This paper describes an implementation of monitors in BCPL and shows how the scope rules of BCPL can be used to provide most of the requisite compile time checking. Some observations are made on problems of implementation, particularly in respect of mutual exclusion, and on the use and construction of monitors in practice.
Some features of a real‐time BASIC executive
Authors: Heher A. D.
Published: November 2006

A real‐time BASIC executive has been developed for process measurement and control. This paper describes two features of the executive which demonstrate that some of BASIC'S constraints are unnecessarily restrictive. The first feature permits alterations to a running program to be made on‐line. Either statements or commands can be entered. This provides a powerful debugging tool and enables an extended command language to be implemented with minimal effort. The second feature provides a number of documentation aids. These include variable names of unrestricted length and end‐of‐line comments.

The implementation of these facilities is described and examples of their use are given. It is shown that neither of the features is extravagant in its demands on either memory space or execution time. The features are therefore of interest for their simplicity and economy as well as their utility.
Portability—some experiences with FORTRAN
Authors: Sabin M. A.
Published: November 2006

During the development of a portable problem‐oriented language processor a number of unexpected difficulties and incompatibilities in various FORTRAN compilers were encountered. These are related, and an approach which minimizes the problems suggested.
Indexing with coded deltas—a data compaction technique
Authors: Visvalingam M.
Published: November 2006

The paper describes the coded delta scheme, which is one of the methods used by the Census Research Unit, University of Durham, for compacting the 1971 U.K. census data. It evaluates the merits and limitations of the technique in relation to the characteristics of the data set and other techniques available for compact encoding of numeric and string data.
Throw‐away compiling
Authors: Brown P. J.
Published: November 2006

A method of compiling called ‘throw‐away compiling’ is presented. This combines the merits of compilation and interpretation. If enough storage is available for a program, it can be compiled in the normal way; if not, the program is stored in a concise intermediate form and compiled dynamically at run‐time, making use of whatever storage is available. When this storage runs out, the previously compiled code is thrown away and the storage is re‐used. The technique is specially suitable for small machines, especially those without virtual memory. The paper explains the advantages and disadvantages of throw‐away compiling, and describes a project where a throw‐away compiler was implemented and tested for performance.
Dave—a validation error detection and documentation system for fortran programs
Authors: Osterweil Leon J. , Fosdick Lloyd D.
Published: November 2006

This paper describes DAVE, a system for analysing Fortran programs. DAVE is capable of detecting the symptoms of a wide variety of errors In programs, as well as assuring the absence of these errors. In addition, DAVE exposes and documents subtle data relations and flows within programs. The central analytic procedure used is a depth first search. DAVE itself is written in Fortran. Its implementation at the University of Colorado and some early experience are described.
A language‐independent system to aid the development of structured programs
Authors: Cunningham R. J. , Pugh C. G.
Published: November 2006

The GLIDE system is an effectively language‐independent aid of modest proportions for developing programs by stepwise refinement. The basis of the system is a suitable program file environment

The system has been implemented on the Imperial College Computer Centre Control Data machine and is currently available for the development of programs written in PASCAL, ALGOL, FORTRAN, SIMULA and JCL (Job Control Language). The program itself is written in PASCAL

The facilities obtained within the scope and limitations of the system conception suggest that this type of system could be given further attention.
A numerical profile of commercial PL/I programs
Authors: Elshoff James L.
Published: November 2006

A sample of 120 production PL/I programs from several commercial computing installations has been studied. Data about the programs in the sample have been extracted by a PL/I scanning program. The statistical results of the study are presented in this document

The paper concentrates on statistical data and not on general conclusions. The data are only interpreted to the extent that it is not ill‐defined and misleading. The data profile the use of basic PL/I elements and the structure of programs written in PL/I. The reader of this report will get a better understanding of how PL/I has been used in the commercial environment up to 1974.
Compiling techniques to exploit the pattern of language usage
Authors: Partridge D. , James E. B.
Published: November 2006

A generalized system for language analysis is described

A description of the language is provided as input data from which the system constructs 8 tree‐structured hierarchy. This hierarchy then directs the subsequent analysis. At the same time the system collects detailed information on the structure of all units analysed

Periodically, the normal process of analysis is suspended, and the analytic information is utilized by heuristic mechanisms to optimize the subsequent processing. The optimization derives from modifications to the tree‐structured hierarchy

The system was applied as a recognizer for statements written in the FORTRAN language by programmers working within five different environments.
The viscom—a system of ‘soft’ video‐terminals
Authors: Coleman M. J. , Godliman G. S. , Leonard G. L.
Published: November 2006

The Portsmouth Polytechnic Visual‐communication system, Viscom (vik‐om), has been designed to provide high‐speed Interaction with an ICL 4130 computer. A feature of the system is that its software device routine is used not only to facilitate data transfers but also to provide an open‐ended list of keyboard functions to augment those provided by the hardware.
The use of modula
Authors: Wirth N.
Published: November 2006

Three sample programs are developed and explained with the purpose of demonstrating the use of the programming language Modula. The examples concentrate on the uses of modules, concurrent processes and synchronizing signals. In particular, they all focus on the problems of operating peripheral devices. The concurrency of their driver processes has to occur in real time. The devices include a typewriter, a card reader, a line printer, a disk, a terminal with tape cassettes and a graphical display unit. The three programs are listed in full.
Design and implementation of modula
Authors: Wirth N.
Published: November 2006

This paper gives an account of some design decisions made during the development of the programming language Modula. It explains the essential characteristics of its implementation on the PDP‐11 computer, in particular its run‐time administration of processes and the mechanism of signalling. The paper ends with some comments on the suitability of the PDP‐11 for this high‐level multiprogramming language.
Interfacing the user
Authors: Van Meurs John , Cardozo Ernst Lops
Published: November 2006

In laboratory automation systems the user interface is that part of the software/hardware systems that provides for communication with the user. A new software approach is reported, consisting of a flexible interpreter combined with FORTRAN coded application modules. The interpreter (BACO) is built on a tagged data structure, comprising user variables, program lines as well as part of the language definition. A language dialect may be defined, tailored to the requirements of the application at hand. The structure of the system is described and an example of its application is given.
The implementation of synchronizing operations in various environments
Authors: Wettstein H.
Published: November 2006

Since E. W. Dijkstra's work on the mutual interdependencies of co‐operating sequential processes there has been much discussion on various synchronizing mechanisms. This discussion usually leads to abstract definitions of synchronizing primitives. However, their realization proceeds differently in various environments. Length of critical regions, number of processors, and dispatching strategy have to be taken into account. In this paper is presented a family of synchronizing operations, the members of which are all based on the same fundamentals. They have been designed with the concept of structured programming in mind.
Comlnk—a file transport and job entry utility for a communication link
Authors: Bos Jan Van Den , Thomassen Hendrik‐Jan
Published: November 2006

COMLNK is a software system designed to provide the user of a communication link between two processors with facilities for file transport and Job submission from one computer to another. It has been implemented for a high speed communication link between an IBM 360/370 running under OS/MFT, MVT VS1 or VS2 and a PDP 11 running under DOS. The various record formats which are supported by the operating systems for their file organizations can be handled in a straightforward manner, while conversion options from one format to another are possible. Files may be shipped, listed on the IBM printer, punched on the IBM punch or submitted to the jobqueue.
Storage management for an implementation of SNOBOL4
Authors: Hanson David R.
Published: November 2006

The implementation of the SNOBOL4 programming language requires some scheme for dynamic allocation and reclamation of storage. This paper describes the method used in a machine‐dependent implementation of SNOBOL4 called SITBOL. Available storage is divided into two regions: one for the allocation of storage for permanent or immovable objects and one for objects that are subject to reclamation. Reclamation is accomplished by a four‐phase algorithm, which includes marking, address adjustment and compaction. The reclamation process is supplemented by several heuristics that reduce the cost of reclamation and increase the amount of storage reclaimed. The storage overhead of the technique is analysed and compared with an alternate method. Some empirical measurements of actual SNOBOL4 programs are given that substantiate the results of the analysis.
Efficient storage for amorphous data
Authors: Botting R. J.
Published: November 2006

A changing collection of items to be chosen at random can be stored efficiently as an array. The method can be extended to maintain several sets and also to choose random samples without replacement. It is important to find such simple ways of structuring data.
Fooling the user of a programming language
Authors: Plum Thomas
Published: November 2006

Fooling the user' of a programming language by ‘natural’ constructions can cause completely unpredictable reliability defects in software systems. Numerous examples show the extent of the problem. Two methods of overcoming it are presented: simple languages devoid of user‐fooling powers, and explication languages to accompany the more powerful languages.
A non‐general‐purpose operating system
Authors: Bernstein N. , Knobe B.
Published: November 2006

A time‐sharing system was developed in order to improve a minicomputer's utilization. Because the facilities provided by the system are not identical to those of a general purpose time‐sharing system, additional advantages accrue:

The system is implement able on a small machine.

The implementation effort is small.

A certain class of programs can now be implemented more easily than would be possible under a general purpose time‐sharing system.
A graphical notation for describing system implementation
Authors: Rosin Robert F.
Published: November 2006

It is suggested that many important concepts in computer system implementation are more difficult to describe and understand than would be the case were there a suitable graphical notation available. Such a notation, which consists of five elements and two forms for composing these elements, is introduced. It is then used to illustrate some basic techniques in the implementation of programming languages.
Pictures‐68 MKI
Authors: Wyvill B. L. M.
Published: November 2006

PICTURES‐68 is a set of procedures written in ALGOL‐68R which enables picture variables to be defined and manipulated. The routines are intended to be used as a library prelude to an ALGOL‐68 program requiring pictorial output.
Exploiting the least recently used page replacement algorithm
Authors: Innes Donald B.
Published: November 2006

Many implementations of paged virtual memory systems employ demand fetching with least recently used (LRU) replacement. The stack characteristic of LRU replacement implies that a reference string which repeatedly accesses a number of pages in sequence will cause a page fault for each successive page referenced when the number of pages is greater than the number of page frames allocated to the program's LRU stack. In certain circumstances when the individual operations being performed on the referenced string are independent, or more precisely are commutative, the order of alternate page reference sequences can be reversed. This paper considers sequences which cannot be reversed and shows how placement of information on pages can achieve a similar effect if at least half the pages can be held in the LRU stack.
Supporting the structured development of complex PL/I software systems
Authors: White John R. , Anderson Richard K.
Published: November 2006

The methodology of top‐down (structured) programming has emerged in the last few years as a practical approach to the problem of developing reliable software systems. The methodology, however, places certain demands on the language used for actual system implementation. In this paper we discuss the implications of these demands on a specific language, PL/I. From this discussion the basic objectives of a PL/I support system are deduced. These objectives deal primarily with: (1) specifying intermodule relationships; (2) propagating module modifications; and (3) maintaining consistency in the realization of abstractions. Finally, the essential elements of a system that realizes these objectives are described.
Dynamic analysis of program performance (DAP) in a fortran batch environment
Authors: Robinson S. K. , Torsun I. S.
Published: November 2006

‘Frequency counts add an important new dimension to Fortran programs; indeed, it is difficult to express in words how “eye opening” they are’ (Knuth1). Given a source program as input, a DAP environment effects changes to the execution of the program so that when the object code is run, the output of the program includes a list of the executable statements and their execution counts (a profile). By extending this basic principle so that the analysis also includes a time estimate for the statement (generated from the code associated with the statement) and a measure of the relative importance of the statement (with respect to the total run time of the object) the DAP report not only becomes an effective user software aid, but, also, an invaluable research tool. This paper discusses the development of such a DAP environment within a Fortran Batch System.
System implementation in Algol 68‐R
Authors: Holdsworth D.
Published: November 2006

We illustrate the use of Algol 68 as a systems implementation language by reference to practical uses of the language. We argue that the code patch facility as implemented in Algol 68‐R is a good way of interfacing systems programs to their machine‐dependent environment, and does not violate the spirit of high‐level language programming.
Performance analysis of large systems
Authors: Storey Tony , Todd Stephen
Published: November 2006

A hybrid analytic and experimental approach to the analysis of large systems is described. The approach is iterative under the assumption that a correct analysis will not be made first time. It is primarily aimed at the analysis of the performance effect of proposed changes prior to coding them. The requirement is for a fairly approximate analysis that is easy to make. The approach is illustrated by an experiment on a relational database system but we believe it to be applicable to many kinds of large systems.

The different reasons for analysing performance of a system are discussed and then the ways of approaching the analysis, with an outline of our approach. The details of our approach are given, and illustrated by our experiment.
The systematic design of file‐processing programs
Authors: Coleman D.
Published: November 2006

The theory of formal languages is applied to the systematic top‐down design of file processing programs. A methodology is described which leads to well structured programs for a large class of data processing problems. The method leads to more reliable programs because it is easier to check the method steps than an intuitive program. The method and its limitations are illustrated by the design process for some data processing programs. The limitations of the method are explained as the result of a theorem about formal languages.
Array handling in cobol compilers
Authors: Williams M. H. , Bulmer A. R.
Published: November 2006

Since Cobol is essentially a byte‐oriented language, certain practical problems arise when implementing it on a word‐oriented machine. The particular problem of handling arrays with SYNCHRONIZED clauses is discussed here and a method put forward for solving it.
Structured debugging using a domain specific language
Authors: Leavenworth B. M.
Published: November 2006

A structured approach to debugging is presented based on restricting the class of programs that can be written. This is achieved by defining a domain specific language, eliminating control flow by using aggregate operations and eliminating side effects by using an applicative language as a base. The domain specific language is realized by defining domain specific operators as extensions to the base language; a set of operators are defined in the paper for data processing applications. The debugging strategy consists of setting up a sequence of input/output transformations; this process takes the input to the output in partial stages so that the correctness of each transformation relative to its input and output set can be verified. The approach is illustrated by a simple data processing problem.
Quasiparallel tracing
Authors: Perrott R. H. , Raja A. K.
Published: November 2006

A description of different methods of program tracing in a quasiparallel environment is given together with an automatic tracing facility implemented in SIMONE. 1 The methods are then compared and evaluated on the basis of their ease of use, flexibility, selectivity, trace output, space required and time overhead.
On detecting misspelt identifiers in fortran
Authors: Scowen R. S.
Published: November 2006

An insidious mistake in Fortran is to misspell a symbolic name and thus inadvertently create a new variable. This short note shows how the IMPLICIT statement can be used to detect this mistake easily.
More on the re‐creation of source code from reverse polish
Authors: Brown P. J.
Published: November 2006

A convenient way of processing BASIC and other interactive, incremental languages is to maintain the program in reverse Polish notation or the like, and to re‐create the source from this if needed. The properties of various algorithms for performing this re‐creation are examined, and a new algorithm, offering good generality and conciseness, is presented.
Dimensional flowcharting
Authors: Witty Robert W.
Published: November 2006

By introducing the idea of axes Dimensional Flowcharting clarifies the representation of sequential and parallel operations. Step‐Wise Refinement is added to give an improved method of representing and understanding the design of software. Many of the disadvantages of conventional flowcharting are removed. The dimensionality concept is carried through to the construction of working programs and a dimensional programming language is described.
A set of strategy‐independent restructuring algorithms
Authors: Kobayashi Makoto
Published: November 2006

This paper proposes a set of new program restructuring algorithms which can be used to reorganize programs so as to increase their performance under two typical memory management strategies. The new algorithms are based on a recently proposed program behaviour model called the bounded locality intervals model, which allows us to give a precise definition of the localities of a program. The paging activities of a program restructured with the new algorithms under working‐set and global LRU‐like memory management strategies are simulated to evaluate the new algorithms. Some of them are shown to have quite satisfactory performance.