bluuebunny/crossref_metadata_2025 huggingface dataset:
Unbounded computational structures
Authors: Friedman Daniel P. , Wise David S.
Published: November 2006

The 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

Binary 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.
Another look at type compatibility in pascal
Authors: Tennent R. D.
Published: November 2006

Two approaches to type compatibility in Pascal, which were discussed briefly in an earlier paper by Welsh, Sneeringer, and Hoare, are analysed in detail.
A monitor for small computers
Authors: Thorelli Lars‐Erik
Published: November 2006

A 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

Remote 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.
Software design representation: A case study
Authors: Freeman Peter
Published: November 2006

In on attempt to improve the representation used for software design, this paper describes the representation used on an actual project. Improvement through the use of case studies such as this one requires explicit analysis; this is presented in the following paper, so that the two should be read together.
Scheduling for immediate turnround
Authors: Larmouth J.
Published: November 2006

This 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

A 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

This 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

The 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

This 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

Debugging 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

Structured 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

The 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

Algol 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

The 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.
Unrolling loops in fortran
Authors: Dongarra J. J. , Hinds A. R.
Published: November 2006

The technique of ‘unrolling’ to improve the performance of short program loops without resorting to assembly language coding is discussed. A comparison of the benefits of loop ‘unrolling’ on a variety of computers using an assortment of FORTRAN compilers is presented.
Non‐recursive top‐down syntax analysis
Authors: Setzer V. W.
Published: November 2006

Using 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

A 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.
An interpreter‐minded benchmark
Authors: Yuval G.
Published: November 2006

A short benchmark program is suggested, which may be less artificial than most benchmarks in common use.
A software trace facility for OS/MVT
Authors: Bowie William S. , Linders J. G.
Published: November 2006

This 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

A 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

Some 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

An 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

When 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.
A structure for access control lists
Authors: Stiegler Helmut G.
Published: November 2006

In order to obtain concise specifications of access rights, the possibility of granting access rights to groups of users was introduced. This gives rise to the problem of forming specifications which refer to arbitrary unions and intersections of groups. The problem is solved by means of a special list structure. The resulting access lists are short and their administration is flexible.
Assemblers for micro‐computers
Authors: Panchapakesan S. , Venkateswaran H. , Subramanian S.
Published: November 2006

An 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

A 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

This 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

The 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.
Translator design to support run‐time debugging
Authors: Johnson Mark Scott
Published: November 2006

Designers and implementors of high‐level language translators can, with relatively little extra effort, greatly facilitate run‐time symbolic debugging. Practical suggestions are presented, based on experiences gained from interfacing several compilers with a run‐time debugging system.
The implementation of concurrency for a PL/I‐like language
Authors: Nehmer J.
Published: November 2006

The 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

The 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

A 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.
A heterogeneous dual processor
Authors: Marsland T. A. , Sutphen S. F.
Published: November 2006

Details of a computer‐computer communication facility are presented. The primary feature of the system is the use of a single terminal to monitor and control processes on different machines simultaneously, working together on the solution of a common problem. Experience with an application, error handling and maintenance of synchronization are described.
The standardization of RTL/2
Authors: Barnes J. G. P.
Published: November 2006

This 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

In 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

Electrostatic 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.
Compiler testing using a sentence generator
Authors: Celentano A. , Reghizzi S. Crespi , Vigna P. Della , Ghezzi C. , Granata G. , Savoretti F.
Published: November 2006

A system for assisting in the testing phase of compilers is described. The definition of the language to be compiled drives an automatic sentence generator. The language is described by an extended BNF grammar which can be augmented by actions to ensure contextual congruence, e.g. between definition and use of identifiers. For deep control of the structure of the produced sample the grammar can be described by step‐wise refinements: the generator is iteratively applied to each level of refinement, producing at last compilable, complete programs. The implementation is described and some experimental results are reported concerning PLZ, MINIPL and some other languages.
Modified Petri nets as flowcharts for recursive programs
Authors: Wendt Siegfried
Published: November 2006

The problem of graphic representation of recursive program structures is discussed. On the basis of the stack mechanism, modified Petri nets are introduced which only slightly differ from the common state machine flowcharts, but have much more representation power.
Microcomputers as protective interfaces in computing networks
Authors: James E. B. , Ireland D.
Published: November 2006

In a computing network environment, a user may have access to several different computers, each with its own command language. For the inexperienced user a uniform interface would be a great benefit. Since there is little possibility that a universal command language will ever be developed, we have devised a system in which a microcomputer is used to intercept all messages between the user and the orginal operating system, presenting a consistent interface to the user. This paper describes the design of such a protective interface and gives an account of experience with its use.
A viewdata interface for arbitrary computer programs
Authors: Palme Jacob
Published: November 2006

The report describes the main algorithms in a computer program for interfacing a viewdata terminal to arbitrary application computer programs, which were not specially written for this terminal. The interface handles the problems of partitioning the input and output to/from the application to suit the small and non‐scrolling screen of the viewdata terminal.
Pascal‐P, program structure and program behaviour
Authors: Hurst A. J.
Published: November 2006

This note describes some interesting results observed during the implementation of Pascal‐P upon a Data General NOVA computer. A significant performance improvement was obtained by altering the program structure of the Pascal‐P compiler to reflect the dynamic behaviour of the program. Some implications of this behaviour for the design of computer architectures are discussed.
Procedures for managing extendible array files
Authors: Knott Gary D.
Published: November 2006

Varieties of files are reviewed and the notion of a file space is discussed. A number of properties which characterize file spaces are listed. This modest theoretical framework has a clarifying influence on the subject of files. Certain file‐system primitives are introduced which are similar to those in most commonly‐known operating systems, and then these primitives are used in constructing a collection of routines for reading and writing extedible arrays. Extendible arrays are based on fixed page size randomly‐accessible files and they are a useful universal input/output (I/O) structure for many different storage and retrieval schemes. The routines for managing such files are similar to the mechanisms used in handling a paged address space in a virtual memory system. The contribution of this paper lies in the detailed implementation which is presented; these routines are well understood in principle, but tricky to construct in practice. Finally, these routines are used in a practical example which provides for managing a variable blocksize free space list within a extendible array.
‘Long return’: A technique for improving the efficiency of inter‐module communication
Authors: Stroustrup Bjarne
Published: November 2006

This paper describes a concept called ‘long return’ for use in inter‐module communication systems. First an implementation which implies a simplification of—rather than an extension of—traditional inter‐module communication systems is outlined. This implementation allows long returns to be used as an optimization technique without violating the commonly accepted principles of system structuring. Thereafter an experiment that provides an estimate of the improvements in efficiency of a particular operating system is described. In the SIMOS operating systems (based on the Cambridge CAP operating system) about 20 per cent of all inter‐process communication operations can be avoided by using long returns, and as a consequence the amount of useful work done in the system is typically increased by about 2.0 per cent.
On the access‐control mechanism of the program component manager
Authors: Silberschatz Abraham
Published: November 2006

This paper examines various issues that pertain to the access‐control mechanism of the program component manager. We examine such questions as what constitutes an access‐right, what kind of information about managed resources does one need, how revocation keys, right‐sets, and exception conditions are handled, etc. It is argued that most of these issues can be handled by the compiler with no explicit programming required. This simplifies the task of programming and enhances reliability. A possible method for handling these issues which was adopted in our implementation is also described.
Handling type information when compiling a language with user‐defined types
Authors: Wallis Peter J. L.
Published: November 2006

A discussion of the handling of type information by the translator for the Portable Programming Language is broadened to include some related details of the PPL design and the way in which type information is used during storage management. No knowledge of PPL is assumed and the presentation is sufficiently broad‐based to provide insight into the compiling actions needed for more complicated languages such as Algol 68 and Ada; some design details of the three languages are contrasted. The implemented type‐handling in the PPL translator takes many details from a denotational semantics for a forerunner of the language.
Editors: Two for the price of one
Authors: Charlton C. C. , Leng P. H.
Published: November 2006

Text editors designed for interactive use on visual display units offer significant advantages, particularly in simplicity of use, but non‐visual editors can provide facilities which are difficult to incorporate into a VDU editor without undermining these advantages. This paper describes a text editing system which offers both a visual and non‐visual mode of use, via two user interfaces to a common set of editing primitives, and allows the user to switch freely between modes during the course of an edit. The visual editing interface consists of a set of single‐key control functions which require no unusual VDU characteristics, while non‐visual editing is provided by a set of context editing commands which both duplicate these control functions and offer extra facilities, particularly for repetitive editing.
Edison programs
Authors: Hansen Brinch
Published: November 2006

This paper describes three sample programs written in the programming language Edison. These programs illustrate the practical use of modules, concurrent statements, and input/output operations. The paper concludes with a brief overview of the Emono operating system and the Edison compiler both of which are written entirely in Edison.
A design language for the definition of a retrieval system interface for casual users of a relational database
Authors: Thomas P. G. , Staff B. E.
Published: November 2006

A design language is described that enables the information analyst to produce a tailor‐made interface for the casual user of a relational database system. The ideas are extended to show howad hocretrieval systems can be constructed from the building blocks incorporated in the relational model.
Software transferability: A practical approach
Authors: Lemoine M. , Mullor J.
Published: November 2006

Based on several experiments in transferring a large CAD system, an automated method of software transfer is defined. This method uses two general tools to describe the language translation programmes.
CHEF: A versatile portable text editor
Authors: Maclean M. A. , Peck J. E. L.
Published: November 2006

CHEF is an interactive text editor for use with both printing and display terminals. Its prime field of application is computer source program editing but it has some word processing capabilities that make it useful for documentation and general text editing work. There is a comprehensive set of whole‐line operations, including block moves and the insertion of text from external files, together with substring replacement and line segmentation based on a flexible pattern‐matching algorithm. There is a set of one‐line buffers for temporary storage of lines or command strings and complex command sequences can be built up by macro substitution. Considerable effort has been made to design a command syntax that is flexible and consistent and, at the same time, minimizes effort during the editing process. CHEF copies the user's file into an internal work‐space so that the original is not disturbed until the user is satisfied with the results of the editing session. A virtual memory technique is used to provide a work‐space that can be almost any desired size, with random access to any part and efficient editing operations. CHEF is written in BCPL and has already been implemented on four different machines.
Modularization of large programs
Authors: Henderson Peter , Gimson Roger B.
Published: November 2006

This report describes a macroprocessor, ‘Supermac’, and its use for modularization of large programs. The development of the macroprocessor and its application to program modularization was undertaken in a research project sponsored by GEC Telecommunications, Coventry, and this document forms the final report of that project.

The project arose from the wish to be able to structure large pieces of software, written in a conventional programming language, in order to make them more easily understood and hence more easily constructed, maintained and modified. In this report the use of the specially developed Supermac macroprocessor to achieve better structured programs will be described in detail. A full definition of the Supermac notation.
Error reporting and recovery in Sangrah
Authors: Prakash Naveen , Gejji P. N.
Published: November 2006

In Sangrah, exception conditions of CODASYL have been replaced by fatal errors and by boolean valued functions. Fatal errors can occur either because all the preconditions necessary for a DML statement are not fulfilled or because of the state of the data base at the time when this statement is executed. A mechanism which anticipates the former situation and thereby saves the data base from corruption is presented. Another recovery scheme which protects the data base from an abnormal termination of the user program is also described. This scheme uses a differential file.
How to make your own simulation system
Authors: Lindstrom Hans , Skansholm Jan
Published: November 2006

A simple way to make a simulation system based on any language is described, in fact, the system was designed and implemented on a minicomputer by the authors in less than one week. A simulation program that uses the system looks almost like a SIMULA program. All subroutines and functions in SIMULA (except input and output routines) are included in this system.
Considerations for the design of array processing languages
Authors: Perrott R. H. , Stevenson D. K.
Published: November 2006

This paper summarizes the major results of a formal survey of array processor users and indicates how these results were used in the design of a language suitable for array and vector processors. A comparison is also given with an informal survey of other large‐scale computer users, which concluded that the best plan was to extend Fortran 77 to meet the requirements for array processing.
Partitioned and prioritized access to timesharing services: The reserved availability method
Authors: Hunter Geoffrey
Published: November 2006

The Reserved Availability Method is a software mechanism for allocating a non‐sharable machine resource such as multi‐access ports according to different user catagories and priorities. The method avoids the queuing of user requests for allocation. Instead, some of the available resources are reserved for allocation to high‐priority, or particular categories of users. The resources reserved vary with machine usage in order to optimize machine utilization with user demand. The method is applied to the partitioning of a machine's ports between different user groups, and to access according to user priority.
The consequences of one's first programming language
Authors: Wexelblat Richard L.
Published: November 2006

After seeing many programs written in one language, but with the style and structure of another, I conducted an informal survey to determine whether this phenomenon was widespread and to determine how much a programmer's first programming language might be responsible.

This paper discusses my observations, gives informal results of the survey and suggests the need for a more formal study.
Recursion in small storage
Authors: Goldschlager Leslie M.
Published: November 2006

An implementation method for procedure calls is discussed which can lead to significant storage space reductions for recursive algorithms.
Eliminating recursion from combinatoric procedures
Authors: Rohl J. S.
Published: November 2006

The problem of eliminating linear and binary recursion has received quite a deal of attention. Less has been given to the elimination of the more general form of recursion that arises in combinatorics. In this paper we extend earlier work and produce two pairs of equivalent schemata. The correspondences between these schemata and the classical combinatoral problems are given and two applied examples: topological sorting and the set covering problem, are discussed in detail.
Dynamic program building
Authors: Brown P. J.
Published: November 2006

This paper argues that programs are better regarded as dynamic running objects rather than as static textual ones. The concept of dynamic building, whereby a program is constructed as it runs, is described. It also describes the Builder system, which is an implementation of dynamic building for an interactive algebraic programming language. Dynamic building aids the locating of run‐time errors, and is especially valuable in environments where programs are relatively short but run‐time errors are frequent and/or costly. It is a good method for non‐specialist programmers.
MROS‐68K, a memory resident operating system, for MC68000
Authors: Pohjanpalo Hannu
Published: November 2006

The operating system described has been designed and implemented for use in dedicated one‐purpose applications, typically in real tihe. Specific attention has been paid to flexible intertask contkol. In the first installation the application system was the steering and controlling of large hydraulic devices. Typical subtasks involved were measuring, coordinate transformations, control, teaching and following robotic paths and evaluating daily material transfkrs.

As a programming effort, developing the operating system was fairly reasonable being of the order of three or four months for one person, including design, coding, testing and documentation.
An Interactive Manager for Pascal Software
Authors: Oldehoeft R. R. , Ralph W. D. , Tindall M. H.
Published: November 2006

An interactive facility for development and maintenance of Pascal programs is described. Features include interactive addition, deletion and modification of modules, independentcompilation of groups of procedures, and automatic recompilation of an entire program only if global declarations are modified. The implementation required modification of a Pascal compiler to process an arbitrary number of programs in a single run and to compile correctly if the main program is missing. Overall processing is managed by a parameterized control statement procedure that invokes several system utilities. The facility has been used successfully in instructional and research computing situations. Significant remaining problems are errors caused by mismatched parameters between independently compiled procedures, and interpretation by users of error messages generated by system utilities.
RNFREE— keyword free‐format input
Authors: Grayson Martin
Published: November 2006

This paper describes experience with a standardized data input system used in scientific FORTRAN programming, which to some extent duplicates the facilities of NAMELIST. It suggests ways a better system could be formulated and points to problems associated with current conventional input to FORTRAN programs.
Improving the structure of large Pascal programs
Authors: Young S. J.
Published: November 2006

This paper describes an extension to Pascal in the form of an encapsulation mechanism aimed at improving the structure of large Pascal programs. It is based upon the module structure of Modula but extended to include a more detailed specification of module interfaces and to allow the definition of a module body to be deferred. Called Pascal/M, the extended language is implemented via a preprocessor. It has been successfully used in large programming projects and been found to both aid in the application of top‐down design methods and to greatly improve the documentation of the final product by breaking up the program text into a hierarchy of short readable modules. The use of Pascal/M is illustrated by a program example and aspects of its design and implementation are discussed.
Dynamic analysis of COBOL programs
Authors: Torsun I. S. , Al‐Jarrah M. M.
Published: November 2006

This paper describes results obtained from a dynamic analysis of 22 typical COBOL programs. The analysis was performed by COBOL DYNAMIC ANALYSIS SYSTEM (COBDAP) which collected data and reported on the dynamic behaviour of COBOL programs.
Full‐screen editing in a hostile environment
Authors: Cargill T. A.
Published: November 2006

This paper describes a simple full‐screen editor which operates effectively in a very restrictive hardware and software environment in which dumb CRT terminals run half‐duplex at 1200 baud to the line buffering front‐end of a timesharing mainframe. The use of such an inappropriate system is dictated by other considerations and the experiment with screen editing was motivated by the frustration encountered in manipulating highly formatted text with a line‐oriented text editor. Early success with a crude editor lead to an improved version which functions acceptably for a several types of text. The particular constraints of this environment, how they were overcome or avoided and their influence on the editor are addressed. The paper demonstrates that successful full‐screen editing in this environment calls for software that differs in its basic design from other full‐screen editors.
Experience with software conversion
Authors: Samet Hanan
Published: November 2006

Experience with a program to convert from LISP 1.6 to INTERLISP is described. The conversion program was designed with two goals in mind. First, it had to be capable of being executed in either of the languages's environments and it had to yield identical results. Second, the speed of the converted program was to be approximately the same as the original program. This meant that the conversion process must be completed prior to execution of the converted program. The various constraints and considerations imposed by these goals are examined. In addition, aside from problems in finding INTERLISP analogs for various LISP 1.6 constructs, careful consideration must also be paid to input/output functions, escape characters, global variables, representation of numbers and different string implementations.
Breaking paragraphs into lines
Authors: Knuth Donald E. , Plass Michael F.
Published: November 2006

This paper discusses a new approach to the problem of dividing the text of a paragraph into lines of approximately equal length. Instead of simply making decisions one line at a time, the method considers the paragraph as a whole, so that the final appearance of a given line might be influenced by the text on succeeding lines. A system based on three simple primitive concepts called ‘boxes’, ‘glue’, and ‘penalties’ provides the ability to deal satisfactorily with a wide variety of typesetting problems in a unified framework, using a single algorithm that determines optimum breakpoints. The algorithm avoids backtracking by a judicious use of the techniques of dynamic programming. Extensive computational experience confirms that the approach is both efficient and effective in producing high‐quality output. The paper concludes with a brief history of line‐breaking methods, and an appendix presents a simplified algorithm that requires comparatively few resources.