bluuebunny/crossref_metadata_2025_split huggingface dataset:
A definition of abstraction
Authors: Ward Martin 
Published: November 2006

AbstractWhat does it mean to say that one program is ‘more abstract’ than another? What is ‘abstract’ about an abstract data type? What is the difference between a ‘high‐level’ program and a ‘low‐level’ program? In this paper we attempt to answer these questions by formally defining an abstraction relation between programs which matches our intuitive ideas about abstraction. The relation is based on examining the operational semantics of the programs, expressed as a set of traces (sequences of states) from a given initial state to a possible final state.
Developing a multi‐access system online
Authors: Poole P. C. 
Published: November 2006

AbstractCOTAN is a multi‐acess system designed to operate on linked KDF9–PDP8 computers. It supports 20 remote teletypes and provides the online user with both remote job entry and interactive capabilitiesThe development of COTAN relied heavily on the continuing availability of online access from an early stage in the project. Access was first obtained through the monitor console on the KDF9 and this was then used to ‘bootstrap’ the implementation of the multi‐access facilities. The new software was checked out in a real time, online test bed called an ‘environmental simulator’. This provided a close approximation to the ultimate operating conditions and enabled the system to be brought to a high degree of reliability before being placed in service.
An algol‐like assembly language for a small computer
Authors: Bell D. A. , Wichmann B. A. 
Published: November 2006

AbstractIn a classic paper1 Wirth describes a language which combines the readability of ALGOL 60 with the flexibility and degree of control of a conventional assembly language. This paper gives an outline of a similar language for a small 16‐bit computer—the Honeywell DDP‐516. Implementing the compiler in its own language by recoding an ALGOL version of the compiler has shown that the language is suitable for large systems. With the compiler written in a high‐level language, many enhancements have been possible even though these were not envisaged in the original codingThis use of the language clearly demonstrated that a high‐level assembly language can be a very effective tool for a small machine as well as for computers like the 360 series.
An empirical study of FORTRAN programs
Authors: Knuth Donald E. 
Published: November 2006

AbstractA sample of programs, written in FORTRAN by a wide variety of people for a wide variety of applications, was chosen ‘at random’ in an attempt to discover quantitatively ‘what programmers really do’. Statistical results of this survey are presented here, together with some of their apparent implications for future work in compiler design. The principal conclusion which may be drawn is the importance of a program ‘profile’, namely a table of frequency counts which record how often each statement is performed in a typical run; there are strong indications that profile‐keeping should become a standard practice in all computer systems, for casual users as well as system programmers. This paper is the report of a three month study undertaken by the author and about a dozen students and representatives of the software industry during the summer of 1970. It is hoped that a reader who studies this report will obtain a fairly clear conception of how FORTRAN is being used, and what compilers can do about it.
Some improvements to the MINIMOP multi‐access operating system
Authors: Rees M. J. 
Published: November 2006

AbstractThe MINIMOP Multi‐Access system provides a range of on‐line facilities particularly suitable for a university environment. Programs in ALGOL and FORTRAN can be written and tested under MINIMOP; a conversational subsystem, derived from JOSS, considerably enhances the usefulness of the Multi‐Access system. After one year's operation at the University of Southampton, it was considered desirable to attempt to expand the facilities of MINIMOP, and correct some of the faults still present in the system. This paper, after a brief description of the basic system, describes the modifications that have been made, and presents some extensions that may be possible in the future.
Answering datel telephone calls by PDP‐8
Authors: Harvey D. W. 
Published: November 2006

AbstractThis paper discusses the development of software to enable the PDP‐8 to handle Datel telephone calls automatically. The software treats the automatic dataphone equipment as a finite state machine. This treatment is compared to the more ad hoc approach which deals with each function of the equipment in an individual way. It is shown that the more formal approach has considerable advantages in shortening development time by reducing debugging and produces a system which is easy to extend.
The design of a pascal compiler
Authors: Wirth N. 
Published: November 2006

AbstractThe development of a compiler for the programming language PASCAL1 is described in some detail. Design decisions concerning the layout of program and data, the organization of the compiler including its syntax analyser, and the over‐all approach to the project are discussed. The compiler is written in its own language and was implemented for the CDC 6000 computer family. The reader is expected to be familiar with Reference 1.
Some comments on the portability of a large algol program—the implementation of SID on KDF9
Authors: Brown F. D. , Calderbank Valerie J. , Poole M. D. 
Published: November 2006

AbstractSoftware engineering research is facilitated by the availability of general purpose programs which aid the production of other programs. These may conveniently be termed ‘software tools’. Software tools in themselves often represent a significant amount of intellectual effort and so their portability between different computing environments is important. We consider the requirements on an ALGOL 60 system to enable it to act as a recipient of a software tool written in ALGOL. In particular, our experience of implementing the translator–writing system, SID, on KDF9 is discussed.
A display package for CAD of control systems
Authors: Hambury J. N. , Karniel S. , Barney G. C. 
Published: November 2006

AbstractA multi‐access computer system has been installed at the Control Systems Centre of the University of Manchester Institute of Science and Technology. The application of this computer to research into the computer aided design of industrial control systems involved the connection of two keyboard display terminals to the system. The ARDS storage tube displays chosen had the advantages of being teletypewriter compatible and not requiring the connection of a satellite computerA graphics package for the entry and structuring of data derived from the stability analysis of control systems was required as soon as possible after the installation was commissioned. The initial package enabled data to be entered by program and then selected and plotted by keyboard requests. Translation, scaling, alteration of the method of plotting (with points or vectors) and the selection of different items for the display were all carried out by keyboard interactionFor long term CAD work a more extensive graphics package was required, the specification was determined following feedback from users of the initial package. It provided additional facilities for graphic interaction, alphanumeric annotation of the displays, specialized drawing and data entry functions and the storing of any pictures built up by the user, as well as a more linked data structure. The structure and facilities of this package are described.
The evolution of job control languages
Authors: Barron D. W. , Jackson I. R. 
Published: November 2006

AbstractJob control languages are a feature of any large scale operating system. This paper traces the historical development of these languages, and compares two representative examples, OS/360 JCL and GEORGE 3 command language. The paper draws an analogy between job control languages and programming languages, showing that JCL is equivalent to an assembly language, whilst GEORGE 3 command language is like a simple autocode.
A high speed computer‐to‐computer data link
Authors: Cronin D. E. , Brandon J. P. 
Published: November 2006

AbstractThe ICL 1905E at Queen Mary College, London and the CDC 6600 at the University of London Computer Centre, have been linked by a 48 kilobaud Post Office line. Jobs can be transmitted from the 1905E to the 6600, and resuts returned to the 1905E. A modified CDC data terminal (the QSE 2815) is installed at QMC, and is connected to the 1905E through a peripheral channel via a British Standard Interface converter. Standard CDC data transmission procedures are used; the software system is based on the CDC IMPORT/EXPORT package, with a program in the 1905E simulating the operation of IMPORTThe 1905E software was written in two parts: an off‐lining package which writes batches of programs to magnetic tape, and subsequently prints off‐line output from tape, and a link control program which reads program batches from tape for transmission to the 6600, and writes to tape the output received from the link. This off‐lining technique ensures that the full capacity of the high speed line is realizedThe link system began operation at the beginning of 1970, and is now used regularly to transmit jobs to ULCC and other sites in the network. Work is continuing on the provision of network facilities, and an integration of the link system with the operating system in the 1905E.
A format editor
Authors: Teperman A. , Katzenelson J. 
Published: November 2006

AbstractThis paper describes a text processing program for producing documents that are to be reproduced. The program runs on a small (12K) computer with paper tape input, a storage scope display unit and an on‐line teletype. Formatting commands are inserted in the text. Compound commands may be formed form the basic ones. This feature aids the specification of complicated formats required for items such as tables and titles. The user can display a page of text before and after the page is formatted and correct it interactively.
Re‐creation of source code from reverse polish form
Authors: Brown P. J. 
Published: November 2006

AbstractA method is described where, by adding redundant operators when compiling into reverse Polish notation, it is possible to re‐create source code in exactly its original form. An algorithm for performing this re‐creation is outlined. The method is useful for incremental compilers since it permits partial (and in some cases total) compilation without the need to maintain a copy of the original program.
Diagnostic messages
Authors: Hahn K. W. , Athey J. G. 
Published: November 2006

AbstractAn algorithm is presented for the compiler diagnostic phase by the introduction of a dictionary concept with elimination of duplicate words, synonymous words and messages, special symbols and non‐uniform spellings. The result is compared with an American Standard COBOL Compiler. This concept can be extended beyond the compilers to all systems which issue extensive messages. It will simplify modularity design and aid in standardization of output format.
User‐like executives
Authors: Hamlet R. G. 
Published: November 2006

AbstractA complex executive may be written as a core of minimum size, plus processes indistinguishable from those run by normal system users except for heavily circumscribed special privileges. Such an executive defines its virtual machine in a recursive fashion, since the processes abide by rules they help to enforce, and is ‘user‐like’ because most executive processing takes places in the protected, user mode. The advantages of such an executive are compactness because of lack of duplication of user and executive routines, good documentation because the user‐process interface is well defined and stable and, most important, excellent protection of the system from the executive itself, which utilizes all of the hardware protection available whenever possible.Situations most appropriate for the user‐like technique are described, and a series of detailed examples is given to show its application to a multiprogramming executive's memory allocation service.
The systems programming language, Malus
Authors: Marcotty Michael , Schutz Henrik 
Published: November 2006

AbstractThis paper reports on the design and development of a high level language, Malus, for use in implementing a time‐sharing system. Emphasized are the ways that the language and its compiler accommodate the specialized requirements of systems programming and programmers. Among these are the need to generate highly efficient object code, to allow inter‐programmer communication by program self‐documentation, and to define and organize system tables and data. In addition, the Malus compiler is highly modular; thus the language may be modified or augmented in response to user needs unforeseen during langauge design. Systems programs cannot be machine independent and Malus allows explicit control of emitted code when an application requires particular efficiency or use of privileged instructions. There is also a facility allowing nested redefinition of identifiers. Efficient storage management and data access is effected by the availability of based structures, a register storage class and built‐in functions to facilitate their use. Malus is evaluated both in terms of some general criteria for systems implementation languages and by an appraisal of user reactions. While this assessment shows a few areas where the language might be improved, it is felt that Malus is a valuable and effective tool for systems implementation.
Handling asynchronous interrupts in a PL/1‐like language
Authors: Elshoff James L. , Beckermeyer Robert , Dill John , Marcotty Michael , Murray John 
Published: November 2006

AbstractA method of handling asynchronous interrupts, which are defined to be events, in a highlevel, block‐structured language is described. The language facilities are based on PL/1 conditions. The functions of an interrupt handler and its relationship with the execution time support for the language are defined and discussed.The development of the facilities being presented is also described. Solutions to design problems and implemenation details are stated. The use and benefits of the mechanism are discussed.
An exercise in resource allocation
Authors: Gomaa H. 
Published: November 2006

AbstractIn a large operating system, the probability that bottlenecks exist is high. The outcome of modifications to the system attempting to overcome these bottlenecks are often not easy to predict. It is frequently difficult to discover:Whether an improvement has actually been made to the system.Where exactly the improvement in system performance, if any, is occurring.How to adjust parameters of the system to achieve an improved performance.Performance tools are described in this paper which were used to help resolve these points in the implementation of a Peripheral Processor and Channel Scheduling mechanism in the operating system used at CERN on a CDC 6000 system. The paper shows how analysis of the performance data provided a clearer appreciation of the performance of the scheduling mechanism.
A storage mapping technique for the implementation of protective domains
Authors: Spier Michael J. , Hastings Thomas N. , Cutler David N. 
Published: November 2006

AbstractAs part of its effort to periodically investigate various new promising concepts and techniques, the Digital Equipment Corporation had sponsored a research project whose purpose it was to effect a limited exploratory implementation of a novel protective operating system framework, based on the kernel/domain architecture.The project was carried out in 1972, and its successful completion led to a number of observations and insights. This paper concentrates on the technological solutions which were developed for the translation of a theoretical model on to commercially available hardware (the DEC PDP‐11/45 minicomputer); specifically, the storage mapping technique and the intermodule call/return mechanism.We believe that we have made two contributions to the state of the art: firstly the identification of the doman's storage mapping properties which are expected to have an impact on the definition of storage class semantics for higher level programming languages to be developed for the domain environment, and secondly the development of a comprehensive intermodule communication mechanism combining all presently known forms of procedure activation within a single functional framework.
Use of a software monitor in the validation of an analytic computer system model
Authors: Wong K. , Strauss J. C. 
Published: November 2006

AbstractThe use of a software monitor in validating a cyclic server multiprogramming model of OS/360 is presented. Following a brief development of the analytic model, a sampling software monitor designed to track CPU and channel I/O activity in OS/360 is described. A procedure for fitting the model to the system based on measurements obtained by the monitor is developed and comparative results of the adjusted model and the actual system are presented for validation of the model principles.
List structures in SIMULA and PL/1—a comparison
Authors: Palme Jacob 
Published: November 2006

AbstractA typical list structurre application program was written in both SIMULA and PL/1. The program was executed using the IBM 360/370 SIMULA and PL/1 optimizing compilers.SIMULA was found to give shorter compile time, about the same execution time and larger memory requirement than PL/1. The source program for the same algorithm was shorter in SIMULA. The SIMULA system could discover semantic programming errors earlier and diagnose them better them PL/1.
DSOS—a skeletal, real–time, minicomputer operating system
Authors: Frailey Dennis J. 
Published: November 2006

AbstractThis paper describes a skeletal operating system which provides the services and structure necessary to implement real‐time applications. Features which would require a specific configuration or a non‐minimal computer are either omitted or optional. In particular, although some protocol is established, no peripheral devices are required. System features include dynamic storage allocation, memory protection, multiprogramming, pseudo‐clocks, and co‐ordination and communication primitives. Due to its simple design, the system ‘kernel’ has proven to be remarkably error free.
An in – core batching standard fortran complier for large ICL 1900 machines
Authors: Rohl J. S. , Ellison H. D. , Collins R. J. 
Published: November 2006

AbstractWe are accustomed to thinking that the requirements of different users of FORTRAN (or any other language for that matter) are so varied that they can only be met by a series of compliers: a standard one, an optimizing one, an in‐core batching one and so on. This paper describes a complier which, although its main aim was to process batches of small student jobs, was desinged to compete with all the manufacturer's compliers on their chosen ground.
Scheduling for a share of the machine
Authors: Larmouth J. 
Published: November 2006

AbstractThis paper describes the mechanism used to schedule jobs and control machine use on the IBM 370/165 at Cambridge University, England. The same algorithm is currently being used in part at the University of Bradford, and implementations are in progress at the Universities of Leeds, Salford and Liverpool for the ICL 1900 series machines. The mechanism relies on allocating a share of the machine to each user (or project), and then varying the turnround time for jobs according to whether the project in question is over‐ or under‐using its share of the machine. The approach is believed to be an original one, having a number of advantages over more conventional scheduling and control algorithms.
A technique for evaluation of user systems on an IBM S/370
Authors: Bergeron R. Daniel , Bulterman Henri R. 
Published: November 2006

AbstractAs applications systems grow in complexity, the optimization of their resource usage becomes more important. This holds true not only as an attempt to increase their own effectiveness, but also to reduce the impact of that system on resources shared by other users in the environment. The analysis and optimization of user systems can be simplified considerably by identifying commonly required evaluation facilities and implementing these facilities in a system‐independent manner.This paper examines existing techniques and describes a system, the SSD evaluation system, designed and implemented by the authors on an IBM System/370 for the purpose of monitoring the performance of applications systems.
Two simple windowing algorithms
Authors: Jarvis John F. 
Published: November 2006

AbstractTwo algorithms that solve the frequently occurring problem in computer graphics, windowing, are described. The primary distinction between the two algorithms is the need for multiplication and division in one of them. The algorithms are compared for running time and size on two commonly used minicomputer systems, the Digital Equipment Corporation PDP‐9/15 and PDP‐11. Not surprisingly the algorithm incorporating the extended arithmetic capability executes faster and the PDP‐11 versions are substantially smaller.
Debugging other languages in APL
Authors: Geller Dennis P. 
Published: November 2006

AbstractThe advantages (and disadvantages) of on‐line debugging have been discussed extensively in the profession. We propose to couple APL with the debugging process. Techniques for ‘translating’ other languages into APL are presented, and the trade‐off between the cost of this translation process and the benefits to be gained by debugging in APL are discussed in terms of an actual PL/1 programming project.
A multiprogramming nucleus with dynamic resource facilities
Authors: Shaw Alan , Weiderman Nelson , Andrews Gregory , Felcyn Mary‐Beth , Rieber John , Wong Gain 
Published: November 2006

AbstractThis paper describes a nucleus for controlling process interaction in multiprogramming systems. The nucleus has three components: a set of primitive operations and data structures for the management of processes and resources, a library of service routines for implementing a variety of resource management strategies and facilities for cleanly handling all input‐output and interrupts. The process management component is straightforward, but the resource facilities are novel in permitting the dynamic definition and control of classes of real or virtual resources. Resources are considered to be anything on which a process can be blocked and consequently encompass consumable (message‐like) as well as conventional, re‐usable objects. Applications of the nucleus as well as some implementation details are also presented.
Biomac: Block structured programming using PDP‐11 assembler language
Authors: Herman‐Giddens G. S. , Warren R. B. , Barr R. C. , Spach M. S. 
Published: November 2006

AbstractUsers of small computers must often program in assembler language. Macros are described which assist in the construction of block structured programs in assembler language. The macros are used in practical day‐to‐day programming in a cardiac electrophysiology laboratory in which the coarse grained control provided by the local FORTRAN compiler is not sufficient for, and even hinders, the writing of clear, easy to understand programs. The macros provide nestable control structures in place of the less structured transfers of conventional assembler language. The arithmetic and input/output control provided by the architecture of the machine is left fully available. The control structures implemented include conditional (IF, CASE), iteration (WHILE, REPEAT/UNTIL, FOR) and subroutine (PROC, CALL, etc.) constructs. No control of variable scope is provided. The macro implementation is discussed along with the code generated. There is a discussion of architectural features which allow the macros to be independent of specific register usage and addressing mode. Experience with use of the macros in a high‐speed, real‐time data acquisition and display environment is presented. We conclude that these macros are easy to use and assist in program readability and documentation.