bluuebunny/crossref_metadata_2025_split huggingface dataset:
Does APL really need run‐time checking?
Authors: Bauer Alan M. , Saal Harry J. 
Published: November 2006

AbstractAPL 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

AbstractIn 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.
A software teletype exchange
Authors: Jones D. A. , Partington N. J. 
Published: November 2006

AbstractThis 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

AbstractThe 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.
Some statistics on the reasons for compiler use
Authors: Kulsrud H. E. 
Published: November 2006

AbstractThis 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

AbstractA 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.
Implementation of a graphics and text output retrieval system
Authors: Girard P. M. , Rose I. H. , Scott D. B. 
Published: November 2006

AbstractThis 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

AbstractThe 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

AbstractThis 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.
The design of a real‐time operating system for a minicomputers. Part 1
Authors: Purser W. F. C. , Jennings D. M. 
Published: November 2006

AbstractThe 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

AbstractThis 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.
A transportable extendable compiler
Authors: Basili Victor R. , Turner Albert J. 
Published: November 2006

AbstractThis 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

AbstractAn 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.
Towards the design of secure systems
Authors: Jones Anita K. , Wulf William A. 
Published: November 2006

AbstractWithin 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

AbstractA 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

AbstractThe 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

AbstractRecently 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

AbstractThe 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

AbstractThe 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

AbstractSURGE, 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

AbstractThis 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

AbstractThis 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

AbstractThe 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

AbstractA 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.
Application of accounting data in evaluating computer system performance
Authors: Sreenivasan K. 
Published: November 2006

AbstractA 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

AbstractThis 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

AbstractThis 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.
An implementation of monitors
Authors: Lister A. M. , Maynard K. J. 
Published: November 2006

AbstractMonitors 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

AbstractA 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.
Indexing with coded deltas—a data compaction technique
Authors: Visvalingam M. 
Published: November 2006

AbstractThe 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

AbstractA 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

AbstractThis 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

AbstractThe 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 environmentThe 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 PASCALThe 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

AbstractA 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 documentThe 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

AbstractA generalized system for language analysis is describedA 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 analysedPeriodically, 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 hierarchyThe system was applied as a recognizer for statements written in the FORTRAN language by programmers working within five different environments.