bluuebunny/crossref_metadata_2025_split huggingface dataset:
Systematic programming of scheduling algorithms
Authors: Shrivastava S. K. 
Published: November 2006

AbstractThis paper applies the technique of systematic (or structured) programming for programming scheduling algorithms as encountered in operating system design. Monitors are used for structuring scheduling algorithms and a synchronizing method is proposed for process scheduling. Some fairly difficult scheduling problems are solved systematically to illustrate the usefulness of the monitor concepts and the synchronizing method. Certain implementation aspects are also discussed.
Experience from the standardization of the SIMULA programming language
Authors: Palme Jacob 
Published: November 2006

AbstractSIMULA is a high‐level language comparable in power to PL/I or ALGOL 68. SIMULA compilers exist for eight different computer series. SIMULA is standardized by a committee mainly consisting of one representative for each implementation. This has given good compatibility between the implementations and the efficient handling of standards problems. The fact that the SIMULA language is defined in such a way that there are no undefined constructs in the language has also helped compatibility and standardization.
Six PL/I compilers
Authors: Wortman David B. , Khaiat Phillip J. , Lasker David M. 
Published: November 2006

AbstractThis paper describes an experimental evaluation of the execution speed of object programs produced by six PL/I compilers. A set of 139 representative PL/I statements were compiled and executed under the PL/I Optimizing, PL/I(F), PL/C, PL/I Checkout, SP/k and PLUTO compilers. An analysis is made of the relative speed of the object code produced by each compiler and also of the relative execution speed of each statement.
Memoryless execution: A programmer's viewpoint
Authors: Gat Israel , Saal Harry J. 
Published: November 2006

AbstractA set of rules for memoryless execution on third‐gene ration computer systems is presented. These rules facilitate binary memoryless interactions within the context of a trustable operating system, without restricting the dynamic use of central processor general purpose registers. An estimate of the required machine support indicates that the firmware modifications required for an implementation based on a segmented microprogrammable computer are not extensive. It is shown that the impact of the solution on operating system design is modest. Moreover, programming generality among memoryless programs is maintained.
Linking a CYBER76 to a 3600
Authors: Austin B. J. , Ewens P. M. , Hudson R. H. 
Published: November 2006

AbstractIn mid‐1973, the Division of Computing Research, CSIKO, took delivery of a Control Data CVBER76 computer, which acts as the primary processing power of the CSIRO computer network (CSIRONET), replacing the Control Data 3600. The 3600, running under the DAD operating system, has been retained as a ‘front‐end’ to the CYBER76 and continues to support the following functions:
An interactive system allowing both editing and CYBER76 job submission
Input of job files centrally from 3600 input devices, remotely from CSIRONET devices, or from interactive console users, and output of results similarly
A permanent file (document) system, with tape archiving
This paper describes the linking of the CYBER76 to the 3600. Software for a CYBER76 PPU has been written and some changes to the 3600 and CYBER76 operating systems have been required.
A review of design techniques for programs and data
Authors: Shneidebman Ben 
Published: November 2006

AbstractThe proliferation of papers on programming methodology focus on the program development process but only hint at the form of the final program. This paper distinguishes between the development process and the program product and presents a catalogue of possible program organizations and data structures with examples drawn from the published literature. The methods for sharing data among modules and a classification scheme for programs and data structures is presented.
Modula: A language for modular multiprogramming
Authors: Wirth N. 
Published: November 2006

AbstractThis paper defines a language called Modula, which is intended primarily for programming dedicated computer systems, including process control systems on smaller machines. The language is largely based on Pascal, but in addition to conventional block structure it introduces a so‐called module structure. A module is a set of procedures, data types and variables, where the programmer has precise control over the names that are imported from and exported to the environment. Modula includes general multiprocessing facilities, namely processes, interface modules and signals. It also allows the specification of facilities that represent a computer's specific peripheral devices. Those given in this paper pertain to the PDP‐11.
Compaction of diagnostic messages for compilers
Authors: Heaps H. S. , Radhakrishnan T. 
Published: November 2006

AbstractThe use of a space optimal storage scheme for compiler diagnostic messages is described. The space reduction achievable through word coding may be predicted in terms of text length, vocabulary size and average word length. A method of word or phrase selection is discussed. Illustration is made by application to the FORTRAN FTN and COBOL compilers under the operating system KRONOS for the CDC 6400 computer.
On the use of integer arithmetic to achieve confirmably correct computation
Authors: Neely Peter M. 
Published: November 2006

AbstractAn example is provided from biostatistics to show that transformation to a unit normal deviate can be inadvisable. This is used to motivate a definition of commensurable units of measurement. An argument is presented to show that a unit cell size can be determined that is termed the ‘least distinguishable difference’. The recommended commensurable unit is obtained by reseating the least distinguishable difference to unity. Thus, the data are transformed to Integer‐valued variates.Since the transformed data are integer‐valued and optimally ranged for integer accumulation, this is recommended. On most computers integer overflow is detectable, therefore in the absence of overflow one is assured that the intervening computation is correct.A few concluding remarks are appended.
A simulation sequencing algorithm
Authors: Macewen Glenn H. 
Published: November 2006

AbstractIn the course of developing a programming project for a course in operating systems, a general purpose language (Burroughs B6700 Algol) possessing concurrency and semaphores was used to provide a process oriented simulation sequencing facility. This facility has been used successfully to simulate several simple operating systems. The facility comprises three procedures along with ‘simulation semaphore’ variables. The first procedure, when called, inserts a simulated time delay into the progress of a simulation model process: the latter two procedures provide a P and a V operation on simulation semaphores, and are used to synchronize processes in a simulation model. The P operation may insert a simulated time delay into the progress of a process. These procedures are explained and presented along with a simple example to show their use.
A fast approximation to the sine function
Authors: Colquhoun D. G. 
Published: November 2006

AbstractA function approximating the sine function is given which was designed for high speed when coded into a computer routine. The domain is divided into a small number of intervals and in each of these a straight line approximation is used. The slopes of the straight line segments have denominators which are powers of 2, and so an implementation needs no floating point multiplication or division operations. With [0, 1/2£] divided into only four intervals, an absolute error of about 0.013 is achieved by a routine taking just over a third of the time used by a more conventional one. Such accuracy is adequate for certain graphics applications, especially moving displays.
How to call procedures, or second thoughts on Ackermann's function
Authors: Wichmann B. A. 
Published: November 2006

AbstractVarious problems have been encountered in using Ackermann's function to measure the efficiency of procedure calls in System Implementation Languages. Although measurements have been made of some 60 systems, the ones presented here are included only when comparisons are possible. For conventional machine design, it is possible to draw some conclusions on desirable instruction set features. A surprising result from the analysis is that implementation quality is far more important than the overheads implied by language design.
A simple network interacting programs' executive (SNIPE)
Authors: Dawes N. W. 
Published: November 2006

AbstractA small operating system SNIPE has been developed to enable minicomputers on the National Physical Laboratory's Data Communication Network to be used from terminals anywhere on this network. The system allows users to load and run programs over the network and provides network input and output facilities (e.g. for file transfers) with terminals and other computers. SNIPE has been kept small enough to be readily used for many network‐based minicomputer, microprocessor and intelligent terminal applications.
A language for inquiring about the run‐time behaviour of programs
Authors: Cohen Jacques , Carpenter Neal 
Published: November 2006

AbstractThis paper describes a language for studying the behaviour of programs, based upon the data collected while these programs are executed by a computer. Besides being a useful tool in debugging, the language is also valuable in the experimental evaluation of the complexity of algorithms, in studying the interdependence of conditionals in a program and in determining the feasibility of transporting programs from one machine to another. The program one wishes to analyse is written in an Algol 60‐like language; when the program is executed it automatically stores, in a data base, the information needed to answer general questions about computational events which occurred during execution. This information consists (basically) of the list of labels passed while the program is being executed, and the current values of the variables. Since the list of labels is describable by regular expressions, these expressions can also be used to identify specific subparts of the list and therefore allow access to the values of the variables. This constitutes the basis for the design of the inquiry language. The user's questions are automatically answered by a processor which inspects the previously generated data base. The paper also presents examples of the use of the language and describes the implementation of its processor.
Implementation independent arithmetic: Speculation for discussion
Authors: Neely Peter M. 
Published: November 2006

AbstractThe specification of a truly portable implementation independent programming language requires that digital arithmetic be specified in an implementation independent manner.Variable length storage is proposed for digital numbers. Linked storage and linked overflow storage are proposed so as to enable the use of variable length numbers. It is suggested that significant digit arithmetic be used for single numbers and interval arithmetic be used for interval pairs. The question is put to numerical mathematicians to specify the decision rules to be used in deciding on the number of digits to be retained when computing in either the significant digit mode or in the interval mode. The question is also raised as to what other arithmetic modes should be provided for.The speculation is offered not for the purposes of suggesting useful hardware design techniques but rather to indicate feasibility of some design. If the implementation independent arithmetic is considered feasible, then language designers can design a language freed from present hardware restrictions.
An operating system for interactive terminals
Authors: Wiseman N. E. , Robinson P. 
Published: November 2006

AbstractConventional operating systems have for many‐years used the ideas of standard stream interfaces to peripherals. Multi‐tasking has been used in order to give an efficient response while maintaining simplicity and flexibility for the user. This paper describes an extension to an operating system which makes similar facilities available for the control of interactive workstations, and also provides a command dispatcher which enables the straightforward implementation of arbitrary user‐defined command languages. The current system has been written in BCPL to run on a PDP 11/45 handling a Vector General display, but the design is suitable for use with a variety of terminals, computers and languages.
Profiling a large program
Authors: Fitch John 
Published: November 2006

AbstractA profiling technique is used on a large algebra system, CAMAL, in order to determine where time is being used. The system is written in a machine‐independent language, and a machine‐independent measuring device is used. The end result is an improvement on various algorithms, which together save up to 70 per cent of the processor time when running user programs.
The evolution of a new discrete event simulation language for inexperienced users (WIDES)
Authors: Thesen Abne 
Published: November 2006

AbstractThis paper describes the evolution and use of the Wisconsin Discrete Event Simulator (WIDES). WIDES is a GASP‐based collection of ANSI FORTRAN subroutines and data structures designed as a discrete event simulation language for use on small machines by inexperienced users in an educational environment. A list of criteria for selection of a language for such use is presented. These criteria include considerations and constraints in areas such as the language's modelling capabilities, its programming ease, storage requirements, educational features, cost and availability. Among commonly available languages only GASP meets the postulated storage constraints. Unfortunately, this language exhibits a lacklustre performance in the other performance areas, and in our experience it is not an ideal language for the above‐stated audience and environment. However, GASP is based on a sound design, and it is extremely well implemented; thus, GASP was chosen as the basis for the development of a new language that meets the criteria stated above. This development is presented here. The resulting language is briefly presented and an example of its use is given. Program listings, users' guides and sample problems are available from the author.
EDIT—an interactive network service; design and implementation
Authors: Hillman A. L. , Schofield D. 
Published: November 2006

AbstractEDIT is a time‐sharing system which offers interactive services over the NPL network. These services include various kinds of editing, word processing, data movement and file control. The system is implemented on a PDP11/40 and can serve up to 30 users simultaneously, on high‐speed displays and other terminals. There is an attached background processor (PDP11/45) which supports graphics and background jobs.This paper describes the design and implementation of EDIT and relates this to the needs of the system and of its users.
The simulation and use of a TABLE data type in algol W
Authors: Shave M. J. R. 
Published: November 2006

AbstractThis paper reviews the role of RECORD and REFERENCE variables in Algol W, points out some restrictions in their use, and describes a method for simulating a new TABLE data type within the existing syntax. It is shown how the use of a few simple procedures generated in a preprocessor phase enable this new type to be used freely within dynamic structures of data. A comparison is made with some alternative methods of implementation in Algol W.
Steps to an efficient program for floating‐point summation
Authors: Ushijima Kazuo 
Published: November 2006

AbstractThis paper shows how helpful a tool for stepwise improvement of programs an execution profiler is. As a demonstration we develop an efficient program for getting the sum of n addends by using Huffman's algorithm. Rewriting an old version of a program step by step, using as a guide information about its dynamic behaviour obtained by the profiler, we finally get an efficient program whose CPU time is reduced to about 1/20 of the first version's for n = 200.
Some aids for program documentation
Authors: Scowen R. S. 
Published: November 2006

AbstractThe documentation of computer programs can be considerably eased and standardized using the programs described in this paper. They are basically machine‐ and language‐independent, possess a simple structure, use one serial input and one output stream, and require no backing store. The code size for each program is a few thousand bytes and the time for running them is dominated by that needed for input and output. The programs are:

INDEX (gives an index of all identifiers used in a program).
POLISH (paginates a program listing so that the global structure is evident).
WATER (helps find misprints in computer‐readable reports).
UNDOC (creates a live program from its documented form).
Also included are examples of the output from these programs.
The formal definition of human/ machine communications
Authors: Lawson Harold W. , Berthan Miquel , Sanagustin Javier 
Published: November 2006

AbstractThe specification of human/machine dialogues for general purpose terminals and special purpose consoles in a natural language is difficult and frequently leads to ambiguities and misinterpretations between terminal and dialogue constructors and users. In this paper, the problem of operator console definition is related to the problem of language and language translator definition. An efficient metalanguage tool (TBNF) for the handling of the latter problem is applied to the solution of the first problem. An example from the Telecontrol of a Power Network, being developed at ENHER (Barcelona, Spain), is described as an illustration.
Event associations in SNOBOL4 for program debugging
Authors: Hanson David H. 
Published: November 2006

AbstractAn event association facility for the SNOBOL4 programming language is described. This facility permits the execution of a programmer‐defined function to be associated with the occurrence of a specified event. The events with which associations can be made are those applicable to program debugging. Associations can be made with events such as variable referencing, statement execution, program interruption, function call and return, and execution‐time errors. By making event associations available at the source‐language level, debugging aids can be written in SNOBOL4 itself, using the full capabilities of that language. As illustrated by several examples, this approach facilitates the implementation of simple yet powerful debugging aids written in the same language as the programs to be debugged. Event associations provide a mechanism for the unification of the existing SNOBOL4 debugging facilities, and a basis for the addition of other events. The implementation of event associations is also described.
A study of machine‐level software profile
Authors: Barak Amnon B. , Aharoni Moshe 
Published: November 2006

AbstractThe instruction mix of a CDC CYBER/74 computer in a university environment was monitored, and in this paper frequencies of execution for the most commonly used instructions are given. From these measurements we make a number of observations about several aspects of computing patterns. One observation is the fact that if we exclude the idle loop of the operating system, the percentage of occurrences for each type of instruction over various time intervals is constant. This fact is used to define a machine‐level software profile (MLSP) for the type of machine operations in the given computing environment. It is shown that the MLSP could be used to find machine utilization and the extent to which software takes advantage of machine architecture, and as a consistent method to improve the performance of a machine configuration.
The use of a procedure‐oriented language for process‐oriented simulation
Authors: Stirling W. Douglas 
Published: November 2006

AbstractIt is fairly easy to use a language like ALGOL W1 for event‐ or activity‐oriented simulation. A method is described to use such a language for process‐oriented simulation. The illusion of co‐routines necessary in this type of simulation is maintained by low‐level language procedures which alter the run‐time stack. Two new scheduling procedures are also described.
Input/output facilities in LISP 1.9
Authors: Kurokawa Toshiaki 
Published: November 2006

AbstractLISP1.9 provides new input/output facilities, the conceptual channel and the current channel, which make program writing easier and execution faster. The channel attributes‐column‐setting, line number option, prompt‐string, user‐buffer, eol‐handler, eof‐handler and access rights‐are useful for program writing; the channel interaction attributes‐input‐memo, output‐memo and file I/O verification‐are useful for system development. Random file I/O, array I/O, record handling, array‐string conversion and Japanese character output are also provided.
Experiences with the portability of concurrent PASCAL
Authors: Neal David , Wallentine Virgil 
Published: November 2006

AbstractThe process of transporting Brinch Hansen's implementation of Concurrent PASCAL to another minicomputer is described. Applicable porting strategies are discussed with emphasis on the design decisions made for a specific transportation. Important design decisions include the use of a virtual code interpreter and implementation in an operating system environment. The problems of this transportation are illustrated with accompanying suggestions for a more portable system.
An exercise in program design using SIMULA class invariants
Authors: Cunningham B. J. , Kramer T. 
Published: November 2006

AbstractThe concept of an invariant assertion has been shown by Hoare to be central to the problem of proving correctness of data representation in a program. A consequent approach for program design is to establish the parts of an overall invariant which characterize the components of the design. In this way it is feasible to synthesize a verified program. There is a gulf between verification theory and practical reality in this area, but the SIMULA class concept is close to the data representation technique required for such an approach. Some of the benefits and problems of this approach to design have been explored by the development of a SIMULA program to simulate a bounded delay resource allocation strategy in a job scheduling environment.
Unbounded computational structures
Authors: Friedman Daniel P. , Wise David S. 
Published: November 2006

AbstractThe concept of suspended evaluation is used as an approach to co‐routines. Problems from the literature involving infinite data structures are solved in a LISP‐like applicative language to demonstrate that simple new semantics can enrich old and ‘friendly’ control structures. It appears that the very nature of these problems draws control structure and data structure together, so that issues of style may be studied at once for both.
Improvement of relocatable linkage editor (loader) input
Authors: Mucke F. U. , Trier W. 
Published: November 2006

AbstractBinary output of translators in many cases is of such a kind that a linkage editor (relocatable loader) needs an unnecessarily high amount of time for the construction of a core image. For the CONTROL DATA CYBER operating systems SCOPE 3.4 and 2.1 a program has been developed by the authors, which demonstrates the truth of the above statement quantitatively, and which may be used to improve relocatable load files as well as libraries.