bluuebunny/crossref_metadata_2025 huggingface dataset:
Programming by successive refinement of data abstractions
Authors: Morris James B.
Published: November 2006

The Model Programming Language implements a form of data abstraction that has been used in a large programming project, the Demos Operating System. The use of the abstraction mechanism suggests a particular programming style that has evolved over an extensive period of gaining experience with the language. The programming style and Model's approach to data abstraction are both documented here using an example designed to illustrate several of the more important issues. The goal of the paper is to demonstrate a programming style and an approach to data abstraction in a programming language that has proved useful in a significant systems programming application.
High speed data acquisition: Running a realtime process and a time‐shared system (UNIX) concurrently
Authors: Harland David M.
Published: November 2006

A technique is outlined by which a normal time‐shared operating system may be modified to permit concurrent processing of a realtime data sampling operation and the typical time‐insensitive operations of the time‐shared system.

Guidance is given regarding the implementation of such a proposal and it is discussed in relation to the UNIX operating system.

It is pointed out that concurrent processing of a multi‐user time‐shared system and a single‐user time‐dependent sampling routine offers a more efficient use of the computer processor, when realtime sampling must be undertaken, while still offering a service to other users. Such a scheme may be an alternative to implementing a full‐scale realtime operating system for the exclusive use of the sampling operations.
Domain architecture and the ICL 2900 series
Authors: Izatt W. T.
Published: November 2006

The resilience of large operating systems has been of concern since their inception. Out of this concern has arisen a general approach to protection, here described as the Domain Concept. In this paper, after summarizing the concept and some interpretations of it, the architecture of the large operating system VME/B on the ICL 2900 series is described and examined to discover how near to that concept is its approach. The consequence of a domain architecture, that such a machine should be suitable for the implementation of subsystems, is investigated with emphasis on subsystems written by a user for his own private purposes.
Stabdump—a dump interpreter program to assist debugging
Authors: McGregor D. R. , Malone J. R.
Published: November 2006

Program development can be greatly speeded by a dump analysis program which makes the state of a program more visible to the programmer. A single comprehensive analysis presenting as much of the relevant material in as concise a manner as possible has proved superior in use to the alternative of interactive analysis one item‐at‐a‐time. The methods adopted in the STAB utility to achieve comprehensive and concise output are described. The system and compiler modifications necessary to support this type of system are discussed.
Bibliographic manipulation
Authors: Lee Martin P.
Published: November 2006

Four systems of bibliographic manipulation are described and evaluated. Two are interactive programming languages which provide key word information retrieval in real time, while two are batch packages which produce catalogues, indexes and bibliographies. Two are specifically designed for text analysis, while two are general purpose software. It is considered that the former provide a more flexible and more powerful tool than the latter.
UNIX with satellite processors
Authors: Barak Amnon B. , Shapir Amos
Published: November 2006

The steps necessary to extend the UNIX

UNIX is a trademark of Bell Laboratories.

time sharing system to a network which includes a central processor and a set of satellite processors is described. Software interfaces permit a program in the satellite processor to behave as if it were running in the central processor. Tasks are executed in parallel in several processors resulting in improved reliability and response time. The economics of such systems becomes more feasible with the reduction of the cost of CPUs and memories and the increasing demand for dedicated local computers.
Code generation with a recursive optimizer
Authors: Stevenson Gordon
Published: November 2006

This paper describes a general purpose optimizer used to construct a new code generator for an existing Coral 66 compiler. The optimizer is recursive and gives the one pass code generator some of the advantages of a multiple pass scheme by ‘pipelining’ short sequences of linear intermediate code at each activation level.
Pattern analysis as a tool for inventing algorithms
Authors: Hart Richard
Published: November 2006

A method for inventing algorithms and several examples are presented. The Julian conversion is useful for all date calculations and for switching to daylight saving time. The algorithm rotates the calendar by 2 months and performs a few straightforward calculations on the new month‐day‐year to produce the Julian date (and back again).

The butterfly sort is based on the work on Woodrum. The algorithm repeatedly delivers two linked lists to a merge machine that produces a single linked list for further use. The length of the two lists going into the merge machine never differs by more than one. This accounts for the theoretical minimal number of comparisons5.

The algorithm uses patterns within a simple binary counter to schedule the delivery of these lists. This accounts for the minimal number of steps between each comparison3.
A portable trace for the Pascal heap
Authors: Schach S. R.
Published: November 2006

Debugging aids for high‐level languages supporting structured data types should provide diagnostic information in a form terminologically as close as possible to that of the original source code. In addition, it is desirable that such software be portable.

The package HEAPTRACE satisfies both the above criteria. It is a precompiler for Pascal programs which enables the user to trace the heap, selectively dumping dynamically‐created records in a high‐level format. It is portable as it is written entirely in Pascal; furthermore, since it is implemented as additions and modifications to a well‐known compiler, its principles may easily be built into any Pascal compiler or diagnostics system.

However, there is a small price to pay for achieving portability in that three possibly desirable features cannot be satisfactorily implemented in a machine‐independent manner.
SUPERMAC—A macro facility that can be added to existing compilers
Authors: Brown P. J.
Published: November 2006

SUPERMAC is a macro facility that can be added to an existing high‐level language as a runtime library. The design aim is to make macros significantly easier to use; this is done by employing a programming language and an environment already familiar to the user.
A critical comparison of several programming language implementations
Authors: Boom H. J. , de Jong E.
Published: November 2006

The implementations of Algol 60, FORTRAN, Pascal and Algol 68 provided on the CDC Cyber 73 of the Stichting Academisch Rekencentrum Amsterdam are compared on both qualitative and quantitative aspects. This paper concentrates on those aspects which are likely to be of interest to language designers and implementers, and to users of other computer systems.
Checking cyclic pointers
Authors: Radford P.
Published: November 2006

Variables which are incremented modulo‐M are a feature of many resource control schemes, where the resources are allocated and released in strict sequence. If resources pass through several phases of use, again in strict sequence, then several variables may be used to keep track of the resources.

Because of the modulo‐M arithmetic checking the consistency of a set of variables may be thought sufficiently difficult to warrant the exclusion of checking. There is a simple technique for checking consistency however and this note describes it.
Multiprogramming and memory contention
Authors: Smith Alan Jay
Published: November 2006

We study memory contention during multiprogramming when programs are free to compete for page frames. A random walk between the possible partitions of memory over the set of active programs is used to model memory contention and calculate throughput. Our model of contention takes into account program characteristics by using miss ratio curves, and also considers memory size and page fetch latency. With the aid of numerous trace‐driven simulations, we are able to verify our model, finding good agreement both in the observed distribution of memory among competing programs and in CPU utilization. We find that for high ratios of secondary to primary memory access time and under conditions of high memory contention, small programs with compact working sets are able to run with far less than expected interference from larger, more diffuse programs. In the case of multiprogramming the same program several times, we find that observed partition distributions are not necessarily even and that higher than expected levels of CPU use are observed. Lower ratios of access time are found to yield different results; programs compete on a more even basis and partition memory relatively more evenly than with higher ratios.
An assessment of modula
Authors: Holden J. , Wand I. C.
Published: November 2006

Wirth has recently published a new programming language called Modula which he suggests is suitable for the programming of process control systems, computerized laboratory equipment and input/output device drivers. The authors have written a compiler for Modula running on a PDP‐11 and generating object code for the same machine. Their experience in writing device drivers for a number of PDP‐11 devices is reported, including simple mains frequency clocks, disks, CAMAC and a graphics processor. Some difficulties arose during the writing of these programs; these are investigated and solutions proposed, either within the existing language or by minor modifications to the language. The study shows the extent to which Modula meets the requirements for a general purpose real‐time systems‐implementations programming language; areas of deficiency are noted.
A portable file directory system
Authors: Hanson David R.
Published: November 2006

A portable file directory system that provides a machine‐independent method for specifying files is described. The portable directory system, or PDS, facilitates uniform usage of portable software by supplying a standard for file specification. The PDS supports a hierarchical directory structure, similar to that in UNIX and Multics, and a set of primitives for manipulating the structure and preparing files for input/output. While the PDS participates in file specification, it does not participate in the actual i/o; it has no impact on i/o efficiency. The implementation, which is easily extended to include additional capabilities, is described. Experience in using the PDS as a part of command interpreters and preprocessors is also discussed.
A framework for modelling graphic interactions
Authors: Gangopadhyay Dipayan
Published: November 2006

In the present‐day graphics field, a proper methodology for designing input constructs of a general purpose graphics system is needed. In this direction, this paper proposes a framework where the graphics interaction programming is formulated as event‐driven procedures. The end‐user actions on the input tools are represented as events and the programreactions to these events as action‐processes. The constructs for programming in this framework are implemented as a part of a graphics package SODDI. The resultant programming facilities are compared with the other existing proposals, based on the conceptual differences of the respective frameworks as well as on the experiences in using the constructs. The data‐structures used for implementing these constructs are also presented.
Uses of the SIMULA process concept
Authors: Palme Jacob
Published: November 2006

The class concept of the SIMULA programming language is well known as the father of the concept of abstract data types. A SIMULA class can however also act as a process. This paper illustrates by some examples for existing programs how the process aspect of the class concept can be used to structure programs in neat ways. All the examples are taken from real production programs in heavy usage today, but the examples have been simplified in this paper to illustrate the main ideas.
A function for generating nearly balanced binary search trees from sets of non‐random keys
Authors: Frost R. A. , Peterson M. M.
Published: November 2006

A function for generating nearly balanced binary search trees from sets of non‐random keys is described. This function can be used in hashing organization where collisions are resolved by construction of binary trees. In particular it can be used as the secondary function in the relatively new technique of dynamic hashing.
The design and implementation of parametric types in Pascal
Authors: Hennessy John , Elmquist Hilding
Published: November 2006

Parametric types offer an attractive solution to the problems of dealing with arrays in Pascal. These problems arise from the use of strong, static type checking, especially of array‐type procedure arguments. Parametric types provide solutions both for the array procedure argument problem and allow the consistent inclusion of arrays with dynamic bounds. A parametric type mechanism is proposed and design issues are discussed. The inclusion of parametric types has major effects on the implementation of a language like Pascal. The implementation issues and implementation versus design tradeoffs are examined. The implementation strategy used can be extended to accommodate the standard and generic types in Ada.
Parsing an extension to CODASYL FORTRAN DML
Authors: Hinxman A. I. , Tate Austin
Published: November 2006

The FORTRAN data manipulation language specified by CODASYL requires that parameters be identified by keywords and appear in a prescribed order. These restrictions can largely be removed. A method of parsing the resultant data manipulation language using database structures is described.
The transfer of a BCPL compiler to the Z80 microcomputer
Authors: Cowderoy Richard I. , Wallis Peter J. L.
Published: November 2006

We describe the transfer of a BCPL compiler installed on a PDP‐11 to a hobbyist's home Z80 microcomputer. The design of the Z80 support software needed is explained in some detail. The development of a debugging Ocode interpreter and of an Ocode loader featuring code compression proved particularly helpful.
A high‐level debugger for PL/I, Fortran and Basic
Authors: Elliott Brig
Published: November 2006

Dartmouth College has implemented a single debugger for several languages sharing a common runtime environment: PL/I, Basic and Fortran. The debugger is fairly powerful; users set breakpoints and traces which occur whenever the values of given variables change, or whenever certain relational expressions become true, for example. All debugging is carried on in a syntax similar to that of a high‐level language.

This debugger was implemented in about a month. It should be fairly easy to implement on most timesharing systems. This paper describes the debugger's user interface and gives a rough sketch of its implementation.
Triplex: A system for interval arithmetic
Authors: Cole A. J. , Morrison R.
Published: November 2006

Triplex is a language which supports interval arithmetic. The interval is represented by a triple. That is, the end points of the interval plus the value that real computer arithmetic would calculate. The intervals are used to bound the errors that occur in real calculations. The paper describes how they may be implemented.
A machine‐independent linker
Authors: Fraser Christopher W. , Hanson David R.
Published: November 2006

Linkers, although a well‐established component of language translation, are typically machine‐dependent, idiosyncratic, and hard for many users to understand. This paper describes a machine‐independent linker and object language. The linker embodies those linking functions that are machine‐independent and centralizes them in a single tool, simplifying compilers, assemblers, and loaders. Included are descriptions of its operation, implementation, and application.
Exploiting machine‐specific pointer operations in abstract machines
Authors: Fraser Christopher W. , Hanson David R.
Published: November 2006

Increasingly powerful machine instructions complicate abstract machine design for portability. Abstract machine instructions must be “larger” than the target machine instructions that they are to exploit, but they must not grow so large as to complicate the realization of the abstract machine on real machines. This paper presents related techniques for low‐level yet machine‐independent access to typical stack and string‐processing instructions.
Design of a simple screen editor
Authors: Elliott Brig
Published: November 2006

This paper describes a simple screen editor, which could be implemented fairly easily on most interactive computer systems. A screen editor shows whole pages of text on a video display terminal; text is modified by moving the cursor and overtyping mistakes. Screen editors are significantly more pleasant to use than conventional (hard copy) editors for most editing tasks. In this paper, one editor is described in some detail, then design goals and implementation problems for all editors of this type are discussed.
Another program for drawing diagrams
Authors: Lang T.
Published: November 2006

Most installations provide a program to assist in drawing stylized diagrams which can illustrate structures, relationships and flows. The DRAUGHTSMAN program was written to overcome shortcomings in earlier examples of this type. Firstly, drawing movements can be specified in relative terms, and positions on the diagram can be labelled, giving the advantages of flexibility for subsequent modification equivalent to those of relative addressing over absolute addressing in programming. Secondly, the program will, unless instructed otherwise, make its own selection of a reasonable paper size and orientation. Thirdly, the inclusion of text within boxes and along lines is flexible and unrestricted; this is combined with a wide range of drawing styles. A specification of the drawing language is given and an illustrative example provided.
A multiprogramming system for a microcomputer
Authors: Smith A. , Bell D. H.
Published: November 2006

A multiprogramming operating system nucleus has been constructed for a microcomputer. An account is given of the implementation, analysing the problems encountered, the magnitude of the effort required and the performance characteristics. The aim is to aid other implementors by drawing attention to those aspects of the work likely to be characteristic of microcomputer implementations in general.
Implementation of a CORAL66 programming environment
Authors: Yip C. K.
Published: November 2006

CORAL66 programming environment has been implemented on a host environment of a Nova real time disk operating system. It consists of a CORAL66 C‐compiler, a program for compilation error code summary, a c‐code assembler, an interpreter as well as utilities from the host environment. In this paper, details of the implementation are discussed and we argue that such an implementation on mini‐computer systems can be used as an important and flexible tool for teaching and research purposes in software engineering.
An alternative approach to arrays
Authors: Andrews Gregory R.
Published: November 2006

This paper presents a new approach to the treatment of arrays in Pascal and Pascal‐like languages. The proposed mechanisms allow arrays to be used flexibly in assignments and as parameters to procedures while at the same time preserving the benefits of strong type checking. Several examples to illustrate the mechanisms are presented. Their implementation is also described.
A system to assist survey analysts
Authors: Williams M. H.
Published: November 2006

The researcher who knows little about computers but wants to conduct a survey and analyse the results by computer can land himself in some difficulty if he does not appreciate some of the problems of computerization. This paper describes a system which is designed to aid such a person by providing assistance with the design of the questionnaire, the capturing of the data and the final analyses.
A design medium for software
Authors: Leathrum J. F.
Published: November 2006

A design medium for software is proposed and illustrated. The medium, which employs rectangular, embedded contours, provides a high level of scale independence. Module specifications, logic design and program elements are easily intermixed in a design. The proposed module formalization includes interface specification, exceptions, logic design and effects in an order which will ultimately be exhibited by the program code as well.
A pattern matching system
Authors: Sommerville Ian
Published: November 2006

This paper describes a pattern matching system which has been implemented as a set of library procedures. The system provides a concise and consistent method of pattern definition and facilities for defining context sensitive pattern matching, defining repetitive patterns and defining alternatives. The operations available to the user allow him to identify if a substring matches a pattern, to extract that substring, to replace that substring and to associate a name with that substring. The system has applications in information retrieval, text manipulation and language processing.
Optimizing two‐state case statements in Pascal
Authors: Atkinson L. V.
Published: November 2006

Some recent work implies that user‐defined two‐state scalar variables, as available in Pascal, are a significant improvement on booleans. Accordingly, alternative ways of expressing conditionals suggest themselves.

Four different way of expressing the same simple conditional are presented. Two widely available compilers are tested and it is discovered that neither produces the same object code for all four cases. It is argued that the same code should be produced, for at least three of the cases, and the feasibility of this is examined.
The design and calibration of a simulation model of a star computer network
Authors: Gomaa H.
Published: November 2006

A simulation model of the CERN (European Organization for Nuclear Research) SPS star computer network is described. The model concentrates on simulating the message handling computer, through which all messages in the network pass. The paper describes the main features of the model, the transfer time parameters in the model and how performance measurements were used to assist in the calibration of the model.
A programmable text‐editing system
Authors: Levison Michael
Published: November 2006

A full‐screen text‐editor is described which has been augmented with a programming facility. The facility consists of an interpreter which inspects a program and generates output to drive the editor. This bridges the gap between text‐editing and text‐processing and allows the editor to carry out complicated operations. The features of the editor are described briefly, and the programming language employed by the interpreter is presented. Several applications are discussed to show the range and versatility of the system.
Verifying abstract data types with SNOBOL4
Authors: Fleck A. C.
Published: November 2006

The presentation of an abstract data type by a series of equational axioms has become an accepted specification mechanism. Verifying the correctness of such specifications has been recognized as a problem troubling their use. A means is presented for experimenting with a directly executable version of the axioms without having to choose representations for the data structures or describe algorithms for the operations.
The kernel of the EMAS 2900 operating system
Authors: Rees D. J. , Stephens P. D.
Published: November 2006

The role of the kernel of the operating system EMAS 2900 and the implementation of its functions are described in some detail. The significance of local scheduling policies and their implications on the design of the kernel are discussed with particular reference to paging management and scheduling control. It is shown that the concept of local and global control of resources can lead to a considerable simplification in the structure of an operating system kernel. The resulting operating system, EMAS 2900, provides interactive time‐sharing services very effectively and efficiently to a large computing community.
Hash‐bucket search: A fast technique for searching an english spelling dictionary
Authors: Comer Douglas , Shen Vincent Y.
Published: November 2006

When a document is prepared using a computer system, it can be checked for spelling errors automatically and efficiently. This paper reviews and compares several methods for searching an English spelling dictionary. It also presents a new technique, hash‐bucket search, for searching a static table in general, and a dictionary in particular. Analysis shows that with only a small amount of space beyond that required to store the keys, the hash‐bucket search method has many advantages over existing methods. Experimental results with a sample dictionary using double hashing and the hash‐bucket techniques are presented.
A unified theory for software production
Authors: Schach S. R.
Published: November 2006

The central problem of software engineering, namely an overall strategy for the successful production of large‐scale software, has not yet been solved. Various techniques do exist for separate sections of the production process, but largely owing to the huge costs involved, it is virtually impossible to perform controlled experiments to test their validity, or to compare competing methodologies.

One alternative way of deciding which techniques are to be preferred is to set up a science of software management, and to evaluate methodologies within its framework. This paper is a first step towards such a science. It notes similarities between certain techniques for structuring the programming group, the program modules, the testing process and the actual code itself. A theory is then deduced which enables programming managers to choose from among the wide selection of available techniques those which are applicable to the specific system to be written.
String searching in text editors
Authors: Davies D. Julian M.
Published: November 2006

Proposals have been made for fast string search algorithms that can search a string for a given pattern without having to examine every character of the text passed over. These algorithms are effective only if search patterns are in practice long enough, and enough text is traversed in a search to justify the costs of initializing the sophisticated search algorithm. We report observations of routine uses of an editor instrumented to determine the characteristics of use. It appears that many searches are indeed for patterns of 3,5 or more characters, and that these searches cover substantial amounts of text. However, searches for patterns of a single character are very common, while only moving a short distance on average. The implementation of a sophisticated search algorithm must take care to deal with short single‐character searches efficiently.
The distributed programming language SR—Mechanisms, design and implementation
Authors: Andrews Gregory R.
Published: November 2006

SR is a new language for programming software containing many processes that execute in parallel. The language allows an entire software system that controls a potentially large collection of processors to be programmed as an integrated set of software modules. The key language mechanisms are resources, operations and input statements. The language supports separate compilation, type abstraction, and dynamic communication links; it also contains novel treatments of arrays and procedures. This paper gives an overview of the language mechanisms, discusses some of the major design decisions and describes one implementation.
Computer‐aided production of language implementation systems: A review and classification
Authors: Lecarme Olivier , Pellissier Mireille , Thomas Marie‐Claude
Published: November 2006

The paper gives a classification of methods for producing translators, interpreters, and macro‐processors using source language, written language, and object language as characteristics. Possible configurations of these characteristics are discussed and documented with examples.

The paper starts with definitions of the terms used. It then presents the tools that are used for the description. These are the so‐called T‐diagrams, which are used to describe translators and interpreters, and some kind of flow‐charts, indicating the steps in the production of a translator or interpreter from a given configuration to a final product.

The next chapters of the paper give the classification of the possible and meaningful elementary configurations. Important and well known special cases are mentioned with examples. Further it is shown how these elementary cases are combined to a whole implementation system. Especially mentioned is self‐compilation. The final section gives some examples of actual implementation systems and their evaluation.
A case study of run‐time errors in Pascal programs
Authors: Leblanc Richard J. , Fischer Charles N.
Published: November 2006

The results of a case study in which over 100,000 Pascal program executions were monitored for run‐time errors are reported. A large number of run‐time errors in a wide variety of categories were observed. The data reported provided insight into the use and misuse of the features of Pascal by a large population of programmers. Some implications of these statistics on compiler implementation and programming language design are discussed. The number and variety of errors detected suggests that run‐time checking mechanisms are more important and useful than is generally recognized, judging by the incompleteness of such mechanisms in many compilers.
DASD sharing in DOS/VSE
Authors: Ottmann Josef S.
Published: November 2006

The first part of this report discusses DASD sharing in loosely‐coupled data processing systems. For the locking of shared files two design concepts are presented.

The second part describes DASD sharing in the IBM operating system DOS/VSE. The control program routines which serialize the lock requests within one processing unit and the cross‐system locking facility are discussed.
A network screen editor implementation
Authors: Hunter J. Alan , Hall Nigel F.
Published: November 2006

A screen‐based editor has been implemented by the authors. Starting from the view that the screen image should at all times reflect the intended contents of the file, a scheme has been developed which requires the minimum compromise from this philosophy but at the same time provides a sophisticated tool which can be accessed from unmodified low‐cost ASCII terminals connected via a local area network. Good performance is achieved by the adoption of a special buffer forwarding technique in the terminal concentrator machines. A further design goal was that the user's view of the editor should be independent of either the terminal type or of the host machine operating system.
Development methodologies for scientific software
Authors: Dodds Robert H. , Rehak Daniel R. , Lopez Leonard A.
Published: November 2006

Approaches to the development of scientific application software have matured over the past two decades and now constitute identifiable methodologies. Three software development methodologies are described, compared, and contrasted from the viewpoint of development effort, continued maintenance, and subsequent extension. Pertinent software aspects of the POLO‐FINITE system are described to provide an example of the software virtual machine approach to solve database, memory management, and processing module integration problems. Finally, possible extensions of the virtual machine concept are discussed as a means to further advance software development methodologies.
Meta‐assembly: A fresh assessment
Authors: Fiddian N. J.
Published: November 2006

An experimental software tool called FAST‐Fast Assembly Tool—has been used to evaluate the operational characteristics and range of application of the program translation technique known as meta‐assembly. It has been applied successfully in practice to a variety of different types of assembly problem and would appear to show some promise for the future in a microprocessor support context. The most significant aspects of the design, implementation and application of FAST are discussed.
On the power of traps and diversions in a document preparation language
Authors: Witten Ian H. , Bonham Mike , Strong Evelyne
Published: November 2006

This note illustrates the power of software interrupts (traps) and text diversions in document preparation languages by considering three difficult problems in typesetting: figure placement; setting text in arbitrary shapes; and balancing final columns in multi‐column layout. The solution of each of these in the nroff document preparation system is discussed, and an Appendix gives the nroff macros which accomplish the tasks.
An overview of the Yale Gem system
Authors: Levine John
Published: November 2006

The Gem system is an experimental computing facility that provides low cost, high speed, graphics‐oriented computing to between ten and sixteen simultaneous users. It provides many unusual facilities to its users and presents a user interface that is unique in its convenience and flexibility. The motivation for the system, its design and user experience are described. Possible future avenues of research are also outlined.
The newcastle connection or UNIXes of the world unite!
Authors: Brownbridge D. R. , Marshall L. F. , Randell B.
Published: November 2006

In this paper we describe a software subsystem that can be added to each of a set of physically interconnected UNIX or UNIX look‐alike systems, so as to construct a distributed system which is functionally indistinguishable at both the user and the program level from a conventional single‐processor UNIX system. The techniques used are applicable to a variety and multiplicity of both local and wide area networks, and enable all issues of inter‐processor communication, network protocols, etc., to be hidden. A brief account is given of experience with such a distributed system, which is currently operational on a set of PDPlls connected by a Cambridge Ring. The final sections compare our scheme to various precursor schemes and discuss its potential relevance to other operating systems.
A note on extension of Pascal by coroutines
Authors: Gerritse J. J.
Published: November 2006

In this communication, a simplification is suggested for the coroutine extension of Pascal described by Kriz and Sandmayr. In addition to being simpler to implement, it is also more user‐friendly and secure because most of the strict sequence constraints on procedure invocations are lifted. The scheme uses the Pascal‐P compiler, without modification except for the addition of a few built‐in procedures, together with a macroassembler for Pcode preprocessing.
Modelling of space‐efficient one‐pass translation using attribute grammars
Authors: Koskimies Kai , Räihä Kari‐Jouko
Published: November 2006

Automatic production of one‐pass compilers from attribute grammars is considered. An examination of a one‐pass grammar for the programming language Euclid shows that the present definition of one‐pass grammars is too general: the space behaviour of the produced compilers differs from that found in conventional hand‐written compilers. A new class of attribute grammars is defined. The class models naturally the use of space in a hand‐written compiler. This implies that the compiler produced automatically on the basis of the grammar uses space in the same way as a practical hand‐written recursive descent compiler. Furthermore, a graphical notation is introduced as a design tool for obtaining grammars in the proposed class.
Typesetting mathematics on multi‐access systems
Authors: Day Robert A.
Published: November 2006

A program giving facilities for the setting of mathematical expressions in running text is described. It acts as a pre‐processor to many of the commonly‐available text‐formatting programs running on current multi‐access systems. Particular attention has been given to designing a package that can easily be implemented on the wide variety of equipment in use on these systems, and emphasis has been given to the use of low‐cost, readily‐available peripherals. Equal importance has been attached to the ability to use the system over wide‐area networks, with potential applications in the computerized distribution of mathematical material. A comparison is made of the method adopted for entering mathematical expressions into the program with other methods that are currently available.
Adding classes to the C language: An exercise in language evolution
Authors: Stroustrup Bjarne
Published: November 2006

The C language is a fine tool for writing compact and efficient programs. It is relatively easy to produce good compilers for, and the number of tools available for supporting program‐ ming in C is large, especially in its ‘home environment’, the UNM system. However, C'S facilities for structuring programs were, until recently, rather limited. To remedy this situation, a data abstraction facility, called classes, was added. The class concept described here has benefitted from the experience gained through a year's use. It is now in use at close to a hundred installations.

The guiding principles of the design of C classes were simplicity both in concept and in implementation. Smooth blending of the new facilities into the existing C programming environment was considered essential. Classes can be used without sacrificing the run‐time efficiency expected from C. This paper presents some of the reasons why C classes are what they are.
Decision tables for general‐purpose scientific programming
Authors: Lew Art
Published: November 2006

Decision tables are shown, by example, to be a viable alternative to conventional algorithmic languages for general‐purpose scientific programming.
Editing mathematical formulae
Authors: Levison Michael
Published: November 2006

An editor is described whose purpose is to assist in preparing and printing complex mathematical formulae. A picture of the current formula is displayed on a screen, and changes are made by manipulating the picture. The user may introduce mathematical entities such as fractions and integrals, and their sizes and layouts are adjusted automatically by the editor. A prototype implementation is described.
A correctness proof of an indenting program
Authors: Mateti Prabhaker , Jaffar Joxan
Published: November 2006

The correctness of an indenting program for Pascal is proved at an intermediate level of rigour. The specifications of the program are given in the companion paper.1 The program is approximately 330 lines long and consists of four modules: io, lex, stack and indent. We prove first that the individual procedures contained in these modules meet their specifications as given by the entry and exit assertions. A global proof of the main routine then establishes that the interaction between modules is such that the main routine meets the specification of the entire program. We argue that correctness proofs at the level of rigour used here serve very well to transfer one's understanding of a program to others. We believe proofs at this level should become commonplace before more formal proofs can take over to reduce traditional testing to an inconsequential place.
Hierarchical multi‐level computer network for laboratory automation
Authors: Lindgård Anders , Oxenbøll Jørgen , Sørensen Ejvind
Published: November 2006

The design and implementation of a microcomputer network to support laboratory automation is described and discussed. It is a multi‐level hierarchical star network connected to a multiprogrammed computer on which all program development is done. The system is capable of supporting a large number of experimental setups. The microcomputers are either used as (1) local microcomputers for experiment control, (2) multiplexers for other microcomputers or (3) controllers for peripherals known in the multiprogrammed computer.

The system combines the advantages of a large multiprogrammed computer with those of a small cheap dedicated computer close to the experiment.

Character‐oriented peripherals are connected to the multiprogrammed computer only. This reduces the amount of system software to be written for the network by an order of magnitude and eliminates the need for interfacing to existing small computer software. The system software consist of three small programs (monitors) providing a process concept and multibuffering of data in the involved computers. The monitor establishes a hierarchy of control and they eliminate the need for any local load device for the microcomputers as their monitors are in a read‐only store.

The system developed is designed for control of experiments in an environment where the experiments and the control strategies change with time and where the data refinement required is beyond what can be done on the present generation of microcomputers.
An evaluation of throw‐away compiling
Authors: Robson D. J.
Published: November 2006

The performance of a throw‐away compiler for Pascal is compared with an interpreter, a threaded code compiler and a traditional compiler. In addition an evaluation is given of the performance of various strategies for dynamic and throw‐away compiling in a small workspace.
XERROR, the SLATEC error‐handling package
Authors: Jones Rondall E. , Kahaner David K.
Published: November 2006

The XERROR package is a collection of portable Fortran routines for processing of errors that occur in other routines. It was developed as the error‐handling package for the SLATEC Common Mathematical Library, which is currently in use at a number of U.S. Department of Energy and other facilities. This paper describes how to use the package, from the viewpoint of the writer of library routines that need to call the XERROR package to handle errors, and from the viewpoint of the user of those library routines.
CMS—A chunk management system
Authors: Atkinson M. P. , Chisholm K. J. , Cockshott W. P.
Published: November 2006

The chunk manager provides simple transaction management, concurrency control and allocates, administers and retrieves apparently contiguous chunks of data of arbitrary and varying size on disc. This system is designed to permit students and research workers to rapidly assemble and test their own DBMS, supporting any data model. Currently it is being used to support PS‐Algol, an implementation of DAPLEX, a relational system and student database exercises.

A chunk is similar to the common meaning of ‘record’ except that there is no implication of internal structure or consistent and static size. An efficient table processing capability is also provided.

Locking and access control are implemented at the bag level to prevent conflicting use of data without excessive operating cost. The problems associated with concurrent access of shared bags have been studied and the currently implemented and future proposed solutions are discussed.
The costs and benefits of lazy interactive input in pascal
Authors: Comer Douglas
Published: November 2006

The programming language Pascal was designed and implemented in a non‐interactive programming environment. This paper surveys proposals for incorporating interaction into Pascal, and focuses on a scheme known as ‘lazy evaluation’. It presents and compares performance measurements of two Pascal run‐time systems for the same compiler; a buffered, non‐interactive version, and a modification of that system to support lazy evaluation.
The supermac macro processor in pascal
Authors: Brown P. J. , Ogden J. A.
Published: November 2006

SUPERMAC‐Pascal is an implementation of the general‐purpose macro processor SUPERMAC. It allows the user to write macros using Pascal procedures and to compile these procedures using his normal Pascal compiler.

This paper describes how the macro processor was adapted to fit Pascal, and how the apparently intractable problems of performing string processing in Pascal were tackled.
The programming language ACTUS
Authors: Perrott R. H. , Crookes D. , Milligan P.
Published: November 2006

This paper describes, in an informal manner, the programming language ACTUS which was designed to facilitate programming array processing and vector processing ‘supercomputers’.

ACTUS extends the program structuring and data structuring facilities of Pascal to the synchronous parallel environment as represented by array and vector processor architectures. A knowledge of Pascal is assumed and only the parallel features of ACTUS are described.
OPTIMA—A portable PCODE optimizer
Authors: Wilk A. , Silverman W.
Published: November 2006

This paper describes the design and implementation of OPTIMA, a Portable optimizer for the PASCAL‐P4 compiler. The PASCAL‐P4 compiler generates code, called PCODE, for a hypothetical stack computer. The stack computer is easy to simulate or to emulate on a wide range of computer architectures. However, the code produced for it by PASCAL‐P4 is unoptimized and inefficient when emulated on conventional computers. OPTIMA improves the code which is produced by the compiler. It has three levels of optimization: PCODE transformations, TUPLE transformations and Code generation. Programs processed by the optimizer are substantially smaller and faster than before optimization. OPTIMA was implemented for the Weizmann Institute of Science GOLEM‐B computer.
Dynamic distributed systems
Authors: Whiddett R. J.
Published: November 2006

This paper introduces a new methodology for building flexible and programmable multiprocessor systems. It is based on a distributed implementation of monitors which is supported by a system‐wide address relocation mechanism. This provides the dynamic reallocation of processes and monitors within the system.

Methods of implementing the communications subsystem based on a number of common network architectures are presented.

An algorithm which effects dynamic resource allocation is presented. Its effect is that groups of processes which are interacting through a monitor will tend to accumulate at various sites in the system in a manner reflecting the dynamic interaction patterns of the program. This is accomplished without there being any centralized control, or even knowledge of the overall program interactions.

The feasibility of the system has been investigated using a model system running on a loosely connected dual processor system.
On the realization of extended control structures in FORTRAN
Authors: Haring G. , Schechtner O.
Published: November 2006

This paper gives a survey of methods used for the realization of extended control structures, FORTRAN is taken as an example language. A proposal is made whose concept is to extend a language dynamically by control structures which are composed from elements of an extendable set of structural components.
Comprehensive tools for assembler construction
Authors: Collins W. Robert , Noonan Robert E. , Gregory Samuel T. , Knight John C. , Hamm Roy W.
Published: November 2006

The Mystro Assembler Construction System (MACS) is a tool kit for assembler writers, based upon a parser‐generator for ambiguous attribute grammars, automatic text manipulation, and a skeletal assembler. Attention has been paid in MACS to aiding the assembler writer in employing the software methodology of iterative enhancement and in avoiding the more tedious aspects of assembler construction.
Syntax directed program editing
Authors: Allison Lloyd
Published: November 2006

A syntax editor provides alternative ways for manipulating programs (as opposed to text). Although not a new idea it has made only slow inroads into editing. This is because implementation is not easy and because of many practical considerations in the use of an editor. This paper covers the design issues of a syntax editor with particular reference to on—SED. Examples of different options taken by other editors are included.