bluuebunny/crossref_metadata_2025_split huggingface dataset:
The viscom—a system of ‘soft’ video‐terminals
Authors: Coleman M. J. , Godliman G. S. , Leonard G. L. 
Published: November 2006

AbstractThe 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

AbstractThree 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

AbstractThis 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

AbstractIn 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

AbstractSince 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

AbstractCOMLNK 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

AbstractThe 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.
A non‐general‐purpose operating system
Authors: Bernstein N. , Knobe B. 
Published: November 2006

AbstractA 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.
Exploiting the least recently used page replacement algorithm
Authors: Innes Donald B. 
Published: November 2006

AbstractMany 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

AbstractThe 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

Abstract‘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

AbstractWe 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

AbstractA 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

AbstractThe 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.
Structured debugging using a domain specific language
Authors: Leavenworth B. M. 
Published: November 2006

AbstractA 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

AbstractA 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.
More on the re‐creation of source code from reverse polish
Authors: Brown P. J. 
Published: November 2006

AbstractA 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

AbstractBy 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

AbstractThis 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.
RATSNO—an experiment in software adaptability
Authors: Hanson David R. 
Published: November 2006

AbstractAdaptable programs are one of the benefits of structured programming. The adaptability of a program is the degree to which it can be transformed into another program that performs a similar, but slightly different, function. While it is clear that the aims of structured programming are best satisfied by the use of modern programming languages, a great number of programmers must use languages such as Fortran. To alleviate this situation, a number of preprocessors have been introduced that give Fortran a more structured facade. This paper describes an experiment performed to test the adaptability of programs written in RATFOR, one of these preprocessors. Judging from the results, the use of a good preprocessor can significantly increase the adaptability of Fortran programs.
SOBS—an incremental BASIC system
Authors: Rees M. J. , Oppenheimer A. W. 
Published: November 2006

AbstractThe design and implementation of a conversational BASIC system for ICL 1900 machines is described. The University of Southampton BASIC System (SOBS) is an incremental BASIC interpreter which runs under a variety of operating environments. Fundamental requirement for extensive diagnostic and debugging aids are listed, and their implementation in SOBS is discussed. A brief summary of language features is also incorporated.The use of SOBS over a number of years has proved its usefulness in the construction of production programs for small‐ to medium‐scale applications as well as in the field of education. A number of enhanced features have gradually been added, and it is to the credit of the original design that the necessary amendments did not significantly alter the initial internal structure of the system.
Planning the software for a personal research contract
Authors: Craddock J. M. 
Published: November 2006

AbstractAn account is given of the strategic planning and development of the software needed by one scientist to support a 3‐year research investigation involving judicious use of an electronic computer. An attempt is made to establish principles on which software development should proceed if the lone worker is to be able to produce something near the largest possible output of useful work in the three years.
Sequential file processing in fortran IV
Authors: Benediktsson O. 
Published: November 2006

AbstractThe standard I/O facility for sequential disk/tape file handling in a Fortran IV IBM 360/370 Disk Operating System environment has some marked shortcomings, the most serious of which is that blocking of records is not provided for.This paper describes SAMFOR4 (Sequential Access Method in Fortran IV), a set of Fortran callable subprograms and a file declaration facility that enables the Fortran programmer to access and create ‘standard’ sequential files. Thus inter language compatibility of files is obtained. A manyfold increase in effectiveness may also be achieved.
IDL: A machine‐independent data language
Authors: Atkinsonidl M. P. 
Published: November 2006

AbstractA Low‐level data language, IDL, is presented as a machine‐independent medium for representing data structures. It is used to transfer structures generated by SLP, a compact list processing language, across the boundaries imposed by differing machines, operating systems and languages. Translation overheads are minimized and use of the language reduces data and machine dependence in programs. Translation algorithms and their performance statistics are presented. The use of the representation for the formation and manipulation of libraries of data structures in demonstrated.
Implementing LISP in a high‐level language
Authors: Fitch J. P. , Norman A. C. 
Published: November 2006

AbstractThe problems of producing an efficient but robust implementation of a high‐level language by building on existing compilers are discussed with reference to a LISP system consisting of an interpreter, a compiler and a large collection of support routines.In retrospect it can be seen that almost all of the major difficulties encountered were facets of a general problem concerned with the global control of the use of store. The garbage collector, originally intended solely to manage the LISP heap, extends its scope to simplify the solution of many of these problems.
MPL1700—a high(er)‐level microprogramming language
Authors: Fisher Richard N. , McQuarrie Gordon W. 
Published: November 2006

AbstractA machine‐dependent, microprogramming language for use on the Burroughs B1700 range of computers is described. It is a relatively high‐level language, containing a data‐structure definition facility and a control structure with sufficient power to enable structured microprograms to be written. However, the microcode compiled from a given program is reasonably transparent to the user, thus enabling efficiency to be maintained. It is designed primarily for writing microprogrammed interpreters for given abstract machines and a simple example of this use is illustrated.
Monitoring the run‐time activity of algol 68‐R programs
Authors: Foxley E. , Morgan D. J. 
Published: November 2006

AbstractA program profiling system for the language Algol 68‐R is described. The system provides deterministic information concerning the run‐time behaviour of certain Algol language constructs. This is accomplished by preprocessing program texts prior to compilation using a syntax analyzer for Algol 68‐R.
How i fought with hardware and software and succeeded
Authors: Palme Jacob 
Published: November 2006

AbstractThis is the story of the development of a utility program to simplify the writing of programs using alphanumeric display terminals.The basic program is very simple, and most of the programming time was not spent on this, but in a cloak‐and‐dagger game with other hardware and software products involved, trying to induce or cheat these products into doing what was needed, and not perform various unwanted and disruptive ‘niceties’.
Error‐checking compilers and portability
Authors: Pyster Arthur , Dutta Amitava 
Published: November 2006

AbstractOne of the major purposes of a high‐level language is to provide a large measure of machine‐Independence in the specification of algorithms. Definitions of languages such as FORTRAN IV and ALGOL 60 encourage compatibility between various implementations. Language specifications are inadequate in that they normally underdefine a language. In particular, the specifications do not normally demand a response to a language violation. The freedom normally given to an implementor to decide the degree and nature of error detection and response hinders portability and may lead to‐unexpected results when moving code from one machine to another or even when changing implementations on the same machine. To support the contention that languages should specify a response to violations, an analysis of four FORTRAN IV implementations and a FORTRAN IV verifier was conducted. The study showed that different implementations often lead to different results for the same illegal program. A study of programmers also revealed that they cannot be relied upon to avoid language violations without compiler aids.
Self‐compiling compilers: An appraisal of their implementation and portability
Authors: Lecarme Olivier , Peyrolle‐Thomas Marie‐Claude 
Published: November 2006

AbstractSelf‐compiling compilers are compilers written in the programming language they are made to compile. They constitute a very interesting case of portable programs, and are rapidly gaining in popularity. This paper is an attempt to classify and evaluate the different methods which have been used for writing and transporting such compilers, according to numerous and various criteria. The potential implementor is then given an idea of the important factors to be considered when selecting one of the many implementation methods available. The study is centred around a specific case, the programming language Pascal and its many compilers.
Rational arithmetic for minicomputers
Authors: Horn Berthold K. P. 
Published: November 2006

AbstractA representation for numbers using two computer words is discussed, where the value represented is the ratio of the corresponding integers. This allows for better dynamic range and relative accuracy than single‐precision fixed point, yet is less costly than floating point arithmetic. The scheme is easy to implement and particularly well suited for minicomputer applications that call for a great deal of numerical compulation. The techniques described have been used to implement a mathematical function subroutine package for a minicomputer as well as a number of applications programs in the machine vision and machine manipulation area.
CONVERT‐A language for program and data file conversions
Authors: Wolberg John R. , Rafal Marshall 
Published: November 2006

AbstractCONVERT is a computer language for facilitating program and data file conversions. The source file (i.e. the program or data file to be converted) is modified according to a set of rules written in the CONVERT language. Normally the entire source file is modified by the first rule, then the modified source file is further modified by the second rule, etc. Once processed by the entire set of rules, the converted source file can be displayed and/or saved. The main features of the language include a high‐level pattern recognition capability, a variety of string manipulation macros (e.g. ALIGN, BREAK, COMBINE, DELETE, INSERT, REPLACE, etc.), table building and manipulation tools, logical qualifiers and features for storing and operating upon numeric data. In addition, a number of parameters are automatically saved and can be referenced symbolically within a given set of rules. The language features have been developed with the specific needs of converters in mind. Thus converters programmed in CONVERT are much simpler to write than the same converters programmed in a higher level language such as PL/I or SNOBOL 4.
SCRUB‐systematically clean and renumber users BASIC
Authors: Lawrence A. R. 
Published: November 2006

AbstractSCRUB is an aid for programmers using BASIC. It lists programs in a uniform layout and provides programmers with a concordance of all simple variables, arrays, functions, subroutines and line numbers used as labels. Full syntax checks are made so that SCRUB may be used as an aid to program development and standardization.