bluuebunny/crossref_metadata_2025_split huggingface dataset:
A monitor for small computers
Authors: Thorelli Lars‐Erik 
Published: November 2006

AbstractA monitor suitable for small computers is described. It implements processes and synchronization primitives. A time queue mechanism with the possibility of time‐limited waiting for signals is also provided. Processes have fixed priorities determining allocation of processor time. The monitor allows dynamic creation and deletion of processes. Each process has a local data area and access to the registers of the processor and a global stack on a temporary basis.
The structure and uses of the edinburgh remote terminal emulator
Authors: Adams J. C. , Currie W. S. , Gilmore B. A. C. 
Published: November 2006

AbstractRemote Terminal Emulation is an approach to the testing and evaluation of multi‐access computer systems in which a workload driver is implemented external to and independent of the system being tested.Remote Terminal Emulators may be used in many stages of system development, e.g. initial checkout, acceptance tests and tuning.The Edinburgh Remote Terminal Emulator (ERTE) is a system designed to exert a specified interactive workload on a multi‐access system such that it appears to the system that it is connected to live terminal devices. The emulator runs on a PDP 11/40 computer under the control of the DEIMOS operating system, which like the emulator is written in the high‐level language IMP.We describe the structure and development of ERTE with particular emphasis on its modularity, the use of a message‐based operating system and the IMP language, which provide a flexible and easily modified tool.Experiments, both current and projected, using ERTE are discussed and our experience of developing and using a terminal emulator is reviewed.
Scheduling for immediate turnround
Authors: Larmouth J. 
Published: November 2006

AbstractThis paper is a sequel to ‘Scheduling for a share of the machine’,1 and describes a new approach to the scheduling of work, now in service on the IBM 370/165 at Cambridge University, England. The new approach provides large amounts of immediate turnround while retaining the essential features of the older system, predictability, control of machine usage proportional to shares and ‘fairness’. The approach in this paper, whilst being a natural extension of the Share system, represents a fundamental change in scheduling philosophy from the usual ‘first in first out’ or ‘priority with ageing’ approach, to a ‘now or later’ system. It is believed to be original, and to represent an important development in optimizing waiting time, be it for computer time or for hospital beds.
The software tools project
Authors: Snow C. R. 
Published: November 2006

AbstractA project is described in which the software tools of Kernighan and Plauger1 are implemented on a Burroughs B1700 computer under a non‐standard operating system. A command language interpreter similar to that of the UNIX operating system has also been implemented to provide an environment in which the tools may be used. The project was completed by five first‐year postgraduate students in the remarkably short time of approximately 12 man‐weeks. A translation program for the tools is described, together with some of the associated software required to support them.
Embedding semantics in LR parser tables
Authors: Gillett Will D. , Leach Sandra 
Published: November 2006

AbstractThis paper addresses two of the problems commonly associated with LR parsing and syntax directed translation schemes, namely grammar stratification and excessively large table size, A solution is discussed which can eliminate stratification of the grammar by allowing the designer to embed semantics directly within the LR table (i.e., at shift and error entries instead of just at reduce entries) and to use global context to determine what semantics should be performed. The non‐stratified grammar can produce a significantly smaller LR table than the corresponding stratified grammar. The compatibility of this scheme with commonly used table compaction techniques is also discussed.
How to design and implement small time‐sharing systems using concurrent pascal
Authors: Graef Norwin , Kretschmar Horst , Loehr Klaus‐Peter , Morawetz Bernt 
Published: November 2006

AbstractThe programming language Concurrent Pascal can be used for the construction not only of small memory‐resident operating systems but also of moderate size swapping systems. If a few amendments are made to the kernel, it is possible to provide a virtual memory management as a part of the CPASCAL program. This approach was taken in the construction of a small time‐sharing system called MUSIC (Multi‐User System In Concurrent Pascal), the design of which is briefly sketched, along with some considerations about the language.
CCL—A high‐level command language
Authors: Madsen Johannes 
Published: November 2006

AbstractThis paper describes how a high‐level, machine‐independent Operating System Command (Job Control) Language, CCL, has been designed and implemented on top of an existing Operating System. An overview of the semantics of the language is given, including some examples giving the flavour of the syntax used. A description of the implementations of CCL under several IBM OS versions, emphasizing division of the implementation into several levels, is also included.
Debugging techniques
Authors: Lauesen Søren 
Published: November 2006

AbstractDebugging is efficient if it detects all program errors in a short time. This paper discusses several techniques for improving debugging efficiency. Attention is given both to the initial debugging and to acceptance testing in the maintenance stage. A main decision is whether to use top‐down or bottom‐up debugging, and it is suggested that top‐down debugging is more efficient if combined with some of the other techniques. All the techniques shown are independent of any particular language or debug software.
New techniques for COBOL programmers
Authors: Chvalvoský Václav 
Published: November 2006

AbstractStructured programming has become one of the most widely discussed topics among DP professionals. Despite this, however, COBOL programmers, responsible for the majority of ‘bread and butter jobs’, have been left mostly on their own. The article attempts to review the history of programming and list the areas essential for any future improvement and advancement of the programming profession, inclusive of systems analysis, education and training, and programming methodology. An alternative approach to structured programming in COBOL using decision tables is outlined and confronted with the concept of the so‐called functional programming.
Programs as higher level subroutines
Authors: Jones Douglas , Baskin A. B. , Chen Thomas , Bloomfield Louis 
Published: November 2006

AbstractThe subroutine call is one of the most fundamental of program control constructs. Despite this, it is rarely implemented at the job control or task level in existing commercially available software systems. When the feasibility of adding a general program calling mechanism to an existing system was investigated, it was apparent that there exist constraints on the amount of state information which could be saved on behalf of the calling program. A mechanism with low run‐time overhead which saves a minimal amount of state information has proven to be easily integratable into a commercially available operating system. This mechanism has had a significant impact on the ease of development and support of large systems of programs. Examples of the use of the new calling mechanism include a program development system and a recursive directory manager for hierarchical directories.
Arbitrary precision arithmetic in Algol 68
Authors: Schonfelder J. L. , Thomason J. T. 
Published: November 2006

AbstractAlgol 68 enables facilities for such things as arbitrary precision arithmetic to be provided in a particularly elegant and convenient way. The library segment mlaritha which provides such facilities is described. This segment enables numerical quantities to be stored and manipulated with almost the same degree of ease, or difficulty, as REAL quantities but with arbitrary and dynamically variable precision. The method of ‘NUMBER’ storage used in mlaritha is discussed in detail and the fundamental algorithms used for the arithmetic operations of addition, multiplication and division, etc., are described. Special attention is given to the ‘costs’ inherent in the use of the system; particularly in the time ‘costs’ of each of the operations and the dependence on precision.
A formalization and explication of the Michael Jackson method of program design
Authors: Hughes J. W. 
Published: November 2006

AbstractThe key to Jackson's Program Design Method is the definition of the inputs and outputs of a program as labelled trees and the recognition of a correspondence between them.This paper gives a more formal definition of the trees and the correspondence. These definitions are then used to explain his basic method and methods for ‘structure clashes’ by reference to formal language theory.
Non‐recursive top‐down syntax analysis
Authors: Setzer V. W. 
Published: November 2006

AbstractUsing a table‐driven top‐down syntactical analyser due to Wirth as starting point, we develop a table‐driven non‐recursive parser. We proceed then to make considerations about error recovery and how to generate non‐recursive executable code for the parser. The problem of linkage with ‘semantic’ routines, that is, those that treat context conditions and generate object code is also covered. An example based on a simple grammar is used throughout the paper in a didactical fashion.
A pattern matching macro processor
Authors: Sassa Masataka 
Published: November 2006

AbstractA general‐purpose pattern matching macro processor is described. Macro patterns can be defined using regular expressions. Macro calls are treated by balancing pattern matching at the token unit level, allowing options, alternatives and repetition. Thus, text in a language with a nested structure can be dealt with. In a macro body, Algol‐style macro‐time operations are allowed, which improves writing and reading. Our macro processor can also be used as a tool for language conversion since it incorporates a feature to declare language‐dependent constructs such as comments, string notations and parentheses pairs. Although our macro processor is not biased towards any particular language, it has successfully converted an Algol 68‐style text into a Fortran text. Problems of language conversion using macros are briefly discussed based upon the experience obtained through this macro processor.
A software trace facility for OS/MVT
Authors: Bowie William S. , Linders J. G. 
Published: November 2006

AbstractThis paper describes a software trace facility (STF) developed to provide data about the flow of control between modules of the IBM System/360 operating system OS/MVT. The motivation for STF is discussed and a brief Introduction to OS/MVT presented to show how STF interfaces with the operating system.The output of the program is illustrated and some details of the program logic are discussed together with the tracing options available to the user. The paper then describes some potential applications.
MUSS—the user interface
Authors: Frank G. R. , Theaker C. J. 
Published: November 2006

AbstractA common failing with many ‘general purpose’ operating systems is that they try to provide a single user interface to suit all applications. The approach adopted in the MUSS system is to provide a set of basic building blocks which can be used for the construction of tailor‐made systems. The system is novel in that the provision of facilities and the means of invoking them are regarded as two quite distinct problems.
Should if… then… else… follow the dodo?
Authors: Atkinson L. V. 
Published: November 2006

AbstractSome recent papers provide a psychological evaluation of two conditional constructs similar to those occurring in some popular computer programming languages. The findings indicate that the if… then… else… form is superior to the branch‐to‐label approach but that the former is not without disadvantages. The papers propose an alternative construction which has been evaluated and found to be superior to both the aforementioned styles. It is claimed that the preferred construct is not available in any language in practical use.This paper applauds the work done by these experimental psychologists and supports their conclusions but suggests that improvement of their favoured construct is possible. Further, it is shown that there is a widely available programming language which not only provides a construct closely resembling their own but also accommodates the improvement.
A poor man's realization of attribute grammars
Authors: Papakonstantinou G. 
Published: November 2006

AbstractAn approach is described in this paper for realizing attribute grammars. A system called STAR has been implemented according to this approach. The system is based on the STAGE2 macroprocessor. It is simple, portable, it can run even on small machines, it can be quickly implemented and it has a convenient to the user metalanguage. The system, however, disregards efficiency and is limited to small size problems.
Data metastructures
Authors: Sanders Alton F. , Gelernter Herbert L. 
Published: November 2006

AbstractWhen implementing large programs, it sometimes happens that the sheer size of the problem makes it difficult to apply recommended techniques for program designs. One example of this occurs when the size and complexity of a single data structure become great. It is naturally desirable that the details of the structure remain hidden from those modules which access it. For simple data structures this poses no problem since the data structure can be maintained by a separate data structure executive (effectively a cluster or class) which is the only module concerned with the physical details of the structure. However, for data structures which require very large executive procedures for maintenance and complex data declarations, it is necessary to partition the structure into substructures, each maintained by a separate module. If this is done in a straightforward manner, it will not be possible for other program modules to access properly parts of the structure unless that module can ‘see’ the various relationships of the substructures. Data metastructures are devices which, when properly employed, allow access to all parts of a partitioned data structure without the accessing module being aware of the partition.
Assemblers for micro‐computers
Authors: Panchapakesan S. , Venkateswaran H. , Subramanian S. 
Published: November 2006

AbstractAn assembler which provides facilities for programming in assembly language for the Intel 8080A micro‐computer is described. This assembler is a single pass self‐assembler and it requires a storage of 2K bytes. The assembler has been designed to be operated from a keyboard to develop programs in assembly language. It allows subroutine calls and nesting of subroutines to any depth. It flashes syntax errors, if any, while an instruction is being keyed in. The most important feature of the assembler is that it does not require costly peripherals such as floppy discs, cassette tapes, etc. It operates through a keyboard with letters (A‐Z), Arabic numerals (0–9) and some special characters to accommodate mnemonics used in label, opcode and operand fields of programs in the assembly language. A display facility will be greatly helpful.In this paper, design and implementation details of assembler are presented. The authors have the view that assemblers for other micro‐computers can be designed and implemented on similar lines. Though implementation may slightly differ from one micro‐computer to another, the design details will mostly remain the same.
A simple technique for controlled communication among separately compiled modules
Authors: Hanson David R. 
Published: November 2006

AbstractA simple technique for communication among separately compiled modules using the existing facilities of most operating systems is proposed. The access control capabilities of existing hierarchical file systems can be used to control access to shared objects (e.g. procedures, types, data structures). Information about shared objects, such as type and date/time of compilation, is stored in description files, and access to a description file implies access to those objects. Declarations cause the appropriate information to be maintained in the description files. The advantage of this approach is that it is based on existing mechanisms with which most programmers are well acquainted.
Pascal‐plus—another language for modular multiprogramming
Authors: Welsh J. , Bustard D. W. 
Published: November 2006

AbstractThis paper informally describes the programming language Pascal‐Plus. The language is an extended version of Pascal, incorporating the envelope construct which is an aid to program modularization and data abstraction, the process, monitor and condition constructs which provide a means for representing multiprocessing programs, and a simulation monitor which provides pseudo‐time control facilities for multiprocessing programs.
Overhead in FORTRAN preprocessors
Authors: Meeson Reginald , Pyster Arthur 
Published: November 2006

AbstractThe quality of code generated by two commercially available FORTRAN preprocessors is examined. These preprocessors augment FORTRAN with ‘structured’ control structures such as the IF‐THEN‐ELSE and WHILE statements. Two versions of benchmark programs were written and tested, one version produced by the preprocessor, the other, performing the same computation, produced by careful hand‐coding directly in FORTRAN. The code generated by the preprocessor and the code written directly in FORTRAN were then compiled. The resulting object modules were then compared for relative execution time and size. This experiment was repeated on three computers, and five compilers with various optimization levels. The results indicate that a substantial overhead in storage space may be paid by using a preprocessor rather than direct coding in FORTRAN, and that in some cases execution time may be increased somewhat by using a FORTRAN preprocessor.
The implementation of concurrency for a PL/I‐like language
Authors: Nehmer J. 
Published: November 2006

AbstractThe formulation of concurrency and synchronization has been recognized as a matter of growing importance in system programming languages in order to achieve well‐structured, reliable and easy to understand system software such as operating systems. Unfortunately, only experimental languages, such as Concurrent Pascal or MODULA, contain adequate linguistic constructs for support of such concepts as processes and monitors. The compilers for those languages are available only on a few machines and are devoted primarily to education. In this paper a simple method of extending a PL/I‐like programming language by concurrency features is described which is based on the usage of an existing compiler. The method has proven to be a cost effective way of adopting recent research results in existing software engineering tools, thus avoiding the need of switching over to a completely new programming environment.
Linguistic extension of abstract machine modelling to aid software development
Authors: Griswold Ralph E. 
Published: November 2006

AbstractThe traditional use of abstract machine models is to provide a conceptual framework for software design and to aid portability and machine independence. Access to the abstract machine model from the higher‐level system on which it is based provides a powerful tool for software development. This paper describes a technique in which the higher‐level system is interfaced to the underlying abstract machine, thus allowing use of the higher‐level system to analyse and debug its own implementation. The application of this technique in the implementation of SL5 is given as an example. Experience with the use of the facility and a discussion of basic design considerations are included.
A semiblock structure for low‐level languages
Authors: Kawai Satoru 
Published: November 2006

AbstractA simple block structure (called semiblock) suitable for low‐level languages is presented. This is not a language but a structure, and preserves the high efficiency of the programs written in the ‘host’ languages. The structure offers the localization of label scopes and the capability of constructing control structures such as selection and repetition. The self‐documentability of programs can be increased by the use of Algol‐like formatting of source texts, which the proposed structure allows and encourages the users to use. The relation between the proposed structure and a simple macro facility is discussed.
The standardization of RTL/2
Authors: Barnes J. G. P. 
Published: November 2006

AbstractThis paper describes the problems encountered during the standardization of RTL/2. It is presented as an object lesson to illustrate the care needed when first defining a programming language to ensure that the loopholes are few. As well as describing the minor alterations made to the definition of RTL/2, this paper serves as a historical record of some of the other possible changes which were considered and rejected.
RATMAC: A preprocessor for writing portable scientific software
Authors: Munn R. J. , Stewart J. M. 
Published: November 2006

AbstractIn preparing a revision of XRAY, a large scientific crystallographic software package, it was decided to use a structured language as the primary coding language. RATFOR was chosen as the most appropriate preprocessor. Initial implementation experience showed that while RATFOR improved the quality of the coding it did little to ease the problems of portability. By augmenting RATFOR with a powerful macro processor, a versatile tool for generating portable scientific software was developed. The resulting preprocessor, RATMAC, is portable and can be optimized, via macros, to a local operating environment. Its characteristics, strengths and weaknesses are described.
An algorithm for programming electrostatic plotter type devices
Authors: Gujar Uday G. , Fitzgerald J. Anthony 
Published: November 2006

AbstractElectrostatic plotter type devices, CRT or hardcopy, are basically printers which allow the ‘paper’ movement only in one direction. As a result, the entire display file has to be created before the process of generating the display can begin. This arrangement differs significantly from the X‐Y plotters where the ‘plotting pencil’ and/or paper may be moved in any direction. An algorithm for generating a display on the electrostatic plotter type devices is described in this paper. This algorithm is based upon creating and maintaining a vector file consisting of end points of visible vectors, sorting these vectors, and then generating the plot—a strip at a time. Only the points that lie within the strip are calculated. The details of implementation and the data structure used are discussed. There is no restriction on the size of the display that can be generated; in fact, plots of size 100 in by 20 in have been produced using this algorithm. No a‐priori knowledge of the extent of the plot is required. The algorithm has been designed to operate in a device independent computer plotting system and has worked very satisfactorily without imposing any restrictions on the users.