bluuebunny/crossref_metadata_2025 huggingface dataset:
p—a timesharing operating system for laboratory automation
Authors: Lindård Anders
Published: November 2006

An operating system supporting laboratory automation and interactive use of a computer has been designed and implemented for the multiprogrammed RC4000 computer. The emphasis in the design has been to give the user interactive access to as many system resources as possible, and to facilitate writing of process control programs in a high‐level language, i.e. ALGOL. The operating system is used to run control and data collection programs for a variety of experiments in physical chemistry. Laboratory automation programs can be started and removed dynamically, and may even be restarted automatically after a system failure. The operating system is a 1500 line ALGOL program. The first version was designed, implemented and debugged in about 4 person‐months. The operating system has been running day and night for approximately 5 years without errors despite heavy use.
Concurrent Pascal with backward error recovery: Language features and examples
Authors: Shrivastava S. K.
Published: November 2006

The programming language Concurrent Pascal has been extended to include some language features that facilitate the writing of fault‐tolerant software. As a result, it is possible now to (1) write operating systems with a measure of fault‐tolerance, and (2) for such an operating system to support fault‐tolerant user programs. The paper describes these language features and illustrates their use with the help of a few working examples.
Debugging methods in recursive structured FORTRAN
Authors: Arisawa Makoto , Iuchi Minoru
Published: November 2006

A version of structured FORTRAN named STAR is introduced. STAR allows recursive subroutines. Implementation problems such as parameter passing by value and local variable stacking are discussed. The major difficulty in the preprocessor approach is debugging. We claim that execution profiles are strong debugging aids, and demonstrate how to debug a STAR program at source language level with the clue in the profiles plus assertion statements. We make use of a quicksort program as an example.
Benchmarking a multi‐access system
Authors: Gay A. R.
Published: November 2006

This paper describes an attempt to test the multi‐access capabilities of three widely differing systems. Some of the difficulties encountered in trying to find a common approach are detailed.
Development of the ZED text editor
Authors: Hazel Philip
Published: November 2006

The development process which resulted in a new text editor is described. The reasons for undertaking this development are discussed, and in particular the increased amount of non‐interactive use of text editors is stressed. The approach taken to the project is described, including the involvement of users in defining the specification and testing prototypes. Finally the main features of the new editor, ZED, are covered.
A simple nucleus written in modula‐2: A case study
Authors: Hoppe Jiri
Published: November 2006

A simple nucleus for a single‐processor computer is considered. The entire nucleus program is written in the high‐level programming language Modula‐21 without assembly coding. The concepts of the nucleus and some simple applications are described. A complete listing of the nucleus is included. We conclude that programming of a nucleus in an appropriate high‐level language is simpler than in an assembly language. The resulting nucleus has a comparable performance with other nuclei written in assembly code.
A process oriented simulation model specification and documentation language
Authors: Frankowski Elaine N. , Franta W. R.
Published: November 2006

We present a language for specifying and documenting discrete event simulation models, designed to facilitate communication during model design, implementation and maintenance. The systems from which models are developed are viewed as collections of communicating elements. Each element is specified separately in a module consisting of attributes, axioms and a scenario. The model's specification consists of each model element's specification and some systemwide attributes and axioms. Synchronization among model elements (model dynamics) is specified within the model elements rather than globally. Each language control structure has a monitor associated with it. Appropriate changes are made in the model's state in response to a monitor's sensing an attribute change. The language contains a library of specifications for common simulation model entities such as the priority queue. The syntax and semantics of the language are presented through examples. Examples of a library specification and a model specification are included.
MM/1, a man‐machine interface
Authors: Schofield D. , Hillman A. L. , Rodgers J. L.
Published: November 2006

This paper discusses the software interface between a computer system and its users, and how it can be made convenient and practical for both the users and implementors of systems. Consistency of interaction is essential, though it is argued that it is too early to define true standards. Standards must be based on experience of actual systems, and must meet specifications that can be justified from the performance of the best of such systems. As one contribution to such a specification, a description is given of MM/1, a family of user interfaces which can be used as a basis for interactive dialogues. MM/1 is suitable for both large and small computers. The thinking behind the interface is given, together with experience of its use in three different systems.
A coroutine mechanism for BCPL
Authors: Moody Ken , Richards Martin
Published: November 2006

In recent years interest in coroutines has increased considerably and their usefulness is no longer in question. This paper describes a simple coroutine mechanism that fits neatly into the philosophy of the BCPL language. A few diverse applications of the mechanism are presented at the end.
Extension of Pascal by coroutines and its application to quasi‐parallel programming and simulation
Authors: Kriz J. , Sandmayr H.
Published: November 2006

This paper describes an extension of Pascal by coroutines as a basic tool to make quasi‐parallel programming possible. This extension is acheived by predefined procedures, i.e. by semantical means without modification of the syntax of the language. Process and simulation concepts are developed entirely in the extended Pascal. These concepts are suited for quasi‐parallel programming and for process‐oriented simulation of discrete‐event systems. The presented simulation system is easy to implement, it is flexible and modifiable. It retains the powerful facilities and the portability and availability of Pascal.
Experiences with a schematic logic preprocessor
Authors: Triance J. M. , Yow J. F. S.
Published: November 2006

A COBOL preprocessor to implement Michael Jackson's program design language, Schematic Logic, has been written and used in the Computation Department at UMIST. This paper investigates the problems inherent in using preprocessors of this type and details the advantages which accrue from the preprocessor when teaching and using the Jackson Method.
The design of an inter‐task communication scheme
Authors: Barnett J. K. R.
Published: November 2006

The paper describes an implemented inter‐task communication scheme, and its design motivation. The scheme provides a well‐defined environment for all situations, including abnormal ones, such as misuse of its facilities. The main design goal is that users of the scheme should be able to verify their communication logic by inspection. Methods are described for reducing the complexity of communication logic to a minimum. The analogy with inter‐CPU communication is discussed.
Infinite power series
Authors: Harrington Steven
Published: November 2006

The creation, manipulation and evaluation of univariate infinite power series is discussed. Unlike truncated power series, which store the first n terms of an expansion, infinite power series create a procedure for calculating a general term, and are thus a formal representation of the entire expansion. No term is calculated until it is actually needed. All results may be saved along with the environment in which they were evaluated in order to prevent repeated calculation. Laurent expansion is used, and expansion in rational powers is allowed to expand expressions containing poles and branch points. The formulas applicable to the manipulation of these extended series forms are presented. The system is implemented in MODE‐REDUCE with infinite power series a new data type, or mode, which allows interfacing with the usual algebraic operators including substitution, differentiation, and integration. A series may also be inverted. Examples of the capabilities and use of the system are presented.
FORALL: An extensible fortran system for conversationally accessing subroutine libraries
Authors: Kerr John D.
Published: November 2006

The implementation of a user‐extensible Fortran system is described. The control syntax, in which all arrays may be referenced by name, is outlined, including language‐like extensions. A summary of the algorithms implemented is tabulated. Facilities for the user to add algorithms to the system are described and the methods of handling arrays outlined. Features to facilitate portability are mentioned.
University computing advisory services: The study of the man—computer interface
Authors: Alty J. L. , Coombs M. J.
Published: November 2006

University research workers need to use the computer as a tool. They are not computer professionals and it is not possible for them to effectively exploit computer facilities without advice and guidance. We argue that amongst the various sources of information available in a University, the official Advisory Service of a Computer Centre plays a crucial role in assisting users. Moreover, its relation to other sources of information makes it a valuable ground for studying the general problems of guiding non‐professional computer users. Two groups of variables are isolated: those concerned with user expertise and those concerned with the quality of software. A gross measure of expertise is suggested and shown to generate behavioural questions which will need to be addressed by any theory of computing skill that is broad enough to apply to the design of computer guidance systems. An analysis is made of user queries and suggestions made for the improvement of applications software. A research programme is outlined.
The trio operating system
Authors: Hansen Per Brinch , Fellows Jon
Published: November 2006

This paper is an overview of the Trio system which enables users to simultaneously develop and execute programs at three terminals. The system consists of an operating system written in Concurrent Pascal and a set of standard programs written in Sequential Pascal. The system has been used on a PDP 11/55 minicomputer since spring 1979. This work concludes 5 years of experience with the first abstract language for concurrent programming.
Scanner design
Authors: Dedourek John M. , Gujar Uday G. , McIntyre Marion E.
Published: November 2006

The scanner is a subroutine which is frequently called by an application program like a compiler. The primary function of a scanner is to combine characters from the input stream into recognizable units called tokens. A method has been presented in this paper for designing such a scanner, also frequently referred to as a lexical analyser in the current literature. The major steps involved in this design process are: identification of tokens, construction of a state diagram, building driver tables and finally writing a scanning routine. The rules for generating the driver tables are described and an algorithm for the scanner, utilizing these driver tables, is included. The method has been successfully used to build the system scanner for a user oriented plotting language. It is concluded that the method is well defined, gives rise to a modular design and as such easily lends itself to language extensions.
An experimental study of relative throughput in a multiprocessor computer system
Authors: Sreenivasan K. , Nelson G. A. , Maksin J. A.
Published: November 2006

This paper describes the results of controlled experiments with a Honeywell H6000 series multiprocessor computer system, 212 experiments were performed using 14 test workloads on 8 H6000 configurations. The number of processors varied from 1 to 4, system controller units (SCUs) from 1 to 4, and main memory from 256K to 1024K words. The ratio (P) of I/O time and CPU time for the test workloads varied from 0.01 to 5.07. The improvement in throughput is expressed in terms of relative throughput (φ), defined as the ratio of elapsed time for a given test workload on a single‐processor configuration to that on a multiprocessor configuration. The relative throughput increased monotonically with an increase in the number of processors for test workloads in the range 0<P<0.4 (CPU‐bound) and φ exhibited an asymptotic behaviour for test workloads in the range 0.4<P<5.07 (I/O‐bound).
The evolution of the operating system EMAS 2900
Authors: Stephens P. D. , Yarwood J. K. , Rees D. J. , Shelness N. H.
Published: November 2006

As a result of experiencing problems with manufacturer's software on the early 2900 machines Edinburgh University took the bold step of attempting to move the general purpose timesharing system EMAS from an ICL 4–75 to an ICL 2970 computer. This paper describes the move together with the changes made and includes some preliminary performance figures from the new system. This implementation project has produced a major time‐sharing virtual memory operating system with a fraction of the effort required to implement the original system.
Transportable package software
Authors: Hamlet R. G. , Haralick R. M.
Published: November 2006

Package programs allow people who are not computer experts to use the power of machine computation for specialized purposes. Because the designers of scientific packages are more often experts in their scientific field than in computing, they may ignore issues of transportability and ease‐of‐use until too late, and produce a package that is difficult to use, and difficult to move to a different computer. In this paper we suggest some techniques to aid the scientific package designer.

We suggest a kernel of routines that interface to the peculiar operating system of each machine, providing sophisticated but standard operating system services. This kernel makes the operating system of each computer appear identical and does not pose a difficult implementation problem. Above this interface all code can be machine‐independent, without sacrificing power and ease of use on any machine.

We also suggest some novel organizations of processing routines designed to make the system easy to alter and extend. Complete independence of modules encourages centralization of tasks, which is both efficient and essential for easy extension. With this organization, the vast preponderance of package code can be written in machine‐independent ANSI FORTRAN. We suggest the use of a preprocessor like RATFOR to make this more pleasant.

The paper closes with an application to an image‐processing package, in which a major problem is the flexible sequencing of processing routines.
A case study in rapid prototyping
Authors: Zelkowitz Marvin V.
Published: November 2006

A case study in rapid prototyping of a new language processor is described. A quick version of the system was developed in SNOBOL4, revised in SNOBOL4, and then rewritten in Pascal. This led to an operational system very early in the development cycle where operational characteristics of the system could be tested easily. The goals of this experiment as well as some of the results are described.
A graphical pascal extension based on graphical types
Authors: Magnenat‐Thalmann Nadia , Thalmann Daniel
Published: November 2006

The goal of this paper is to present a graphical Pascal extension, named MIRA. This extension gives the user the means of defining and using specific graphical types. A complete vector arithmetic has been developed and a new structured type has been introduced: the figure type. Instructions to create and delete figures are discussed and it is shown how the graphical types can be used as other Pascal types. The implementation is carried out by a portable Pascal preprocessor.
The LTPL‐E tasking proposals
Authors: Kronental M. , Roberts J. W. , Timmesfeld K. H. , Wand I. C.
Published: November 2006

The Long Term Procedural Language Committee of the International Purdue Workshop for the Standardization of Industrial Computer Systems has studied, over a number of years, the design of a programming language suitable for use in industrial real‐time systems. Various parts of a language suitable for this kind of application have been designed during this period. This paper presents the results of part of this work. In particular it describes the tasking facilities that are seen to be necessary in the industrial real‐time environment. The paper concludes with a comparison of the proposed features with those in Ada.
Software cost estimation: Present and future
Authors: Mohanty Siba N.
Published: November 2006

The state‐of‐the‐art in software cost estimation is reviewed. The estimated cost of a software system varies widely with the model used. Some variation in cost estimation is attributable to the anomolies in the cost data base used in developing the model. The other variations, it is claimed are due to the presence or absence of certain ‘qualities’ in the final product. These qualities are measures of ‘goodness’ in design, development, and test‐integration phases of software. To consider quality as a driver of software cost, we have suggested an association between cost and quality and have proposed a way to use quality metrics to estimate software cost.
Forward‐declared procedures parameter‐lists and scope
Authors: Sale A. H. J.
Published: November 2006

This paper examines some issues which relate to the definition of scope in Pascal, and pressures which have been brought to bear on the draft international standard for Pascal for duplicate procedure headings for forward‐declared procedures. The causes for these pressures, and the conceptual integrity of Pascal are discussed. The interfacing nature of parameter lists is examined, and the concept of ‘detergent construct’ introduced, leading to ‘detergent scope rules’.
A case study in fault tolerant software
Authors: Black J. P. , Taylor D. J. , Morgan D. E.
Published: November 2006

The addition of redundancy to data structures can be used to improve the ability of a software system to detect and correct errors, and to continue to operate according to its specifications. A case study is presented which indicates how such redundancy can be deployed and exploited at reasonable cost to improve software fault tolerance. Experimental results are reported for the small data base system considered.
The architecture of the PLAIN data base handler
Authors: Kersten Martin L. , Wasserman Anthony I. , Wasserman Anthony I.
Published: November 2006

The programming language PLAIN has been designed to support conversational access to a data base, and incorporates relations as a built‐in data type. This paper describes the architecture of the data base handler for PLAIN, emphasizing the separation of the data base handler from other aspects of the language processor, and the modularization of the data base architecture to support modifications to the language and its implementation with minimal difficulty. The data base architecture is layered in order to provide the greatest possible degree of information hiding and separation of functionality. The paper shows the structure of the data base handler and the functions of the various modules of the system.
DIALOG: A scheme for the quick and effective production of interactive applications software
Authors: Negus B. , Hunt M. J. , Prentice J. A.
Published: November 2006

DIALOG is a collection of routines, including a main ‘driver’ program, which is used by an applications programmer as the user interface to interactive applications programs. The routines handle command analysis, data input and editing, as well as processing standard commands such as HELP. DIALOG offers, with no extra effort from the applications programmer, not only a simple interface for first‐time users which gives complete instruction in using the program, but also a ‘command driven’ interface for more experienced users. DIALOG permits the quick and effective production of interactive applications software by programmers with no previous experience of writing such programs. User reaction to the programs so far produced and offered as part of a university computing service has been extremely favourable.
A modula based language supporting hierarchical development and verification
Authors: Bernstein A. J. , Ensor J. R.
Published: November 2006

This paper describes a proposal for a modification to the language Modula. The modification was motivated by a desire to bring to the language the ability to build hierarchical systems and to support program verification efforts.

In the modified language, called SB‐Mod, modules are grouped into levels and calls are permitted from the modules of one level to those of a higher level. Verification is supported through a set of clearly described synchronization constructs and by restricting the flow of information between levels. A result of this is that levels do not interfere with each other and can be treated separately for purposes of verification.

In considering modifications, an attempt was made to provide the user with a variety of control mechanisms, while at the same time avoiding situations in which excessive run‐time overhead would be incurred.
A comparative study of task communication in ada
Authors: Welsh Jim , Lister Andrew
Published: November 2006

A previous paper compared the mechanisms for process communication in Hoare's communicating sequential processes and in Brinch Hansen's distributed processes, by both qualitative and quantitative analyses. This paper extends these analyses to the corresponding features for communication between tasks in Ada. The similarity between Ada's features and Hoare's proposals is confirmed, but some limitations on non‐determinism in Ada are noted.
Linguistic mechanisms for resource management strategies
Authors: Ancilotti P. , Lijtmaer N. , Boari M. , Natali A.
Published: November 2006

In this paper a unified set of linguistic features for providing a very flexible range of resource management strategies is presented. These features may be embedded in an object oriented programming language with abstract data type definitions. Firstly some of the more frequently used resource management strategies are illustrated and the related problems of resource allocation, access and synchronization are discussed. Then linguistic mechanisms to allow static and dynamic resource allocation, static access control and synchronization are presented. Finally some examples, reflecting a wide range of resource management strategies, are discussed in order to illustrate the application of the proposed linguistic features.
The design of Edison
Authors: Hansen Brinch
Published: November 2006

This paper describes the considerations behind the design of the programming language Edison including the reasons why a large number of well‐known language featuges were excluded. It also discusses the linguistic problems of writing a concise language report.
An experiment with Fortran and Pascal
Authors: Perrott R. H. , Dhillon P. S.
Published: November 2006

This paper reports on a programming experiment involving the languages Fortran and Pascal. The subject of the experiment was the simulation of the X‐ray department of a local hospital. The programming was carried out by two different programmers at different periods of time.

A static analysis was performed on both models to determine how the languages were used by both programmers. The compilation and execution speeds of both models were then determined when executed on an ICL 1906S computer. The results indicate that the Pascal program is substantially faster in both compilation and execution speed than an equivalent Fortran program.
SCENARIOS: An event management package
Authors: Singer D. W.
Published: November 2006

Programs in general are concerned with the changing of information. Sometimes it is desirable that some changes be undone, or that the effect of alternative sets of changes be observed. This paper describes a package designed to manage events that effect changes, so that such event management becomes easier to program.
A portable lisp compiler
Authors: Griss Martin L. , Hearn Anthony C.
Published: November 2006

The programming language LISP is usually implemented via an interpreter, and a compiler is added later as a LISP program. However, all such production compilers known to the authors produce explicit instructions for the given computer being used. This paper describes the development of a portable LISP compiler in the sense that only Standard LISP functions are used in its definition and the output is a sequence of abstract machine codes, easily mapped to instruction sequences on current computers. The resulting code is quite efficient, demonstrating once again the maxim that most compiler optimization is largely machine independent.
A stable quicksort
Authors: Motzkin Dalia
Published: November 2006

A sorting algorithm, called Stable Quicksort, is presented. the algorithm is comparable in speed with the Quicksort algorithm, but is stable. The experimental evidence presented support the theoretical evaluation of the performance of Stable Quicksort.
Construction of a peephole optimizer
Authors: Lamb David Alex
Published: November 2006

The design and construction of a peephole optimizer is described. The optimizer consists of a database of patterns, a translator that translates the patterns into an implementation language, and a pattern‐matcher skeleton into which the generated pattern code is inserted. it is argued that this three‐part split is a good way to approach the construction of certain kinds of programs.
A new fast and safe marking algorithm
Authors: Kurokawa Toshiaki
Published: November 2006

A new marking algorithm for garbage collection is presented. Although the method is a variation of the usual simple stacking algorithm, in practice this algorithm has quite improved both in stack space and processing time. One significant modification is to stack a node only when both the sublists are unmarked. The other innovation is a ‘stacked‐node‐checking’ method invoked after each stack‐overflow. With this method, a number of unnecessary nodes are eliminated, the stack is compacted, and the marking process can resume using the generated space in the stack. This algorithm has been used for LISP1.9 garbage collection for years, and succeeded in showing good figures.
A Fortran to Pascal translator
Authors: Freak R. A.
Published: November 2006

This paper describes some of the problems encountered in implementing an automatic Fortran to Pascal translator. The translator introduces a number of improvements to the Fortran program including the structured control statements of Pascal. It highlights the structure of both COMMON blocks and executable statements, and it nests the Fortran subprograms to their required level.
An analysis/synthesis interface for Pascal compilers
Authors: Waite W. M. , Carter L. R.
Published: November 2006

Many Pascal compilers are based upon a model which has two unpleasant properties: a large working set of procedures and lack of flexibility in object code structure. In this paper we analyse the source of these faults and describe an alternative model which avoids them. We then present the details of the key interface in the alternative model, as realized by a particular compiler.
COPAS—A conversational Pascal system
Authors: Atkinson L. V. , North S. D.
Published: November 2006

Terminal systems usually permit a user to interact with a running program, if only by using the terminal for input and output. It is possible to extend the interaction to include the compilation phase. Program text is translated as it is supplied and edits are checked immediately they are made. A system displaying these characteristics can be called conversational. COPAS is such a system.
Has the program been altered?
Authors: Wichmann B. A.
Published: November 2006

It is often essential to know if a computer program has been altered. If the text has been provided on magnetic tape and subsequently loaded onto another computer with possible changes in the character set, the problem becomes more difficult. This paper proposes the use of a ‘parity check’ as used in digital data transmission. An implementation of this algorithm in Pascal is given together with details of how a Pascal source text can be checked for alterations using the algorithm.
On sorting and counting
Authors: Heal J. G. B.
Published: November 2006

When performing an external sort, an extra integer field added to the sort key can be used to count subsequences, and make the counts available at the beginning of each subsequence.
A survey of some text editors
Authors: Scowen R. S.
Published: November 2006

Every computer system seems to have a different method of editing files. This survey considers the tasks, constraints and user interface for computer editors. Several editors are examined and reviewed. This paper also contains a glossary of some terms connected with editing and includes a reference to other surveys and bibliographies.
The implementation of case statements in Pascal
Authors: Sale Arthur
Published: November 2006

This paper examines the probable implementations of the case statement in Pascal, and analyses their consequences. A particular implementation for the Burroughs B6700/7700 series illustrates the necessary investigations. The techniques, although not new, are brought together to serve as a stimulus to improving the implementation of case‐statements in other compilers for Pascal, and to provide ideas for implementors. The architectural limitations of even high‐level computers in implementing the case statement are briefly discussed.
Design for a robust simple and highly reliable filestore
Authors: McGregor D. R. , Malone J. R.
Published: November 2006

This note describes a robust, simple‐to‐implement filestore. The filestore provides facilities for creating named, dynamically allocated files which can be accessed via a block level interface (both randomly and sequentially). The design is particularly well‐suited to the type of environment found on personal computers, word processors, and other stand alone systems where a high degree of resilience against hardware and software malfunction is required. It is ideally suited for use with floppy discs or any other cheap removable rotating medium, because of its high reliability and good performance, gained at the price of a slight reduction in available disc capacity.
Interpretation Techniques
Authors: Klint Paul
Published: November 2006

The relative merits of implementing high level programming languages by means of interpretation or compilation are discussed. The properties and the applicability of interpretation techniques known as classical interpretation, direct threaded code and indirect threaded code are described and compared.
Document preparation systems
Authors: Hansson Hasse , Steensgaard‐Madsen Jørgen
Published: November 2006

This paper gives an introduction to programs used to prepare the layout of a text for publication. It presents a suitable terminology, independent of any particular systems but in no way complete, for the description of documents. The basic characteristics of phototypesetting equipment are described. Finally, highlights of a particular system are given. Very little is said on the implementation of that system.
The community file station
Authors: Barnett Richard , Beckwith Richard C.
Published: November 2006

This paper describes the design and use of the Community File Station, an intelligent terminal system, at a college with a large central computer facility. The Community File Station allows functions such as text preparation, editing, local file management and rapid text display to be performed locally without any interaction with the central computer system. It is hoped that the combination of such a terminal system with a high speed campus network will have a significant impact on the way in which the user community uses the central system. Some examples of the way in which the terminal is used is given, along with the way in which the role of the central system changes for the user of the Community File Station.
Distributing viewdata and teletext services to a user community
Authors: Wood G. K. , Larmouth J.
Published: November 2006

The normal method of access to Viewdata and teletext services is via special TV sets, however it is possible to make these services available to terminal users of a computer system. This paper describes how the British Viewdata and teletext services were adapted to run at Salford University and also discusses some of the problems that were encountered in the implementation. In order to do this, certain relevant features of the Prestel and the broadcast systems are described and discussed in detail.
Task management in Ada—A critical evaluation for real‐time multiprocessors
Authors: Roberts Eric S. , Evans Arthur , Morgan C. Robert , Clarke Edmund M.
Published: November 2006

As the cost of processor hardware declines multiprocessor architectures become increasingly cost‐effective and represent an important area for future research. In order to exploit the full potential of multiprocessors, however, it is necessary to understand how to design software which can make effective use of the available parallelism. This paper considers the impact of multiprocessor architecture on the design of high‐level programming languages and, in particular, evaluates the language Ada in the light of the special requirements of realtime multiprocessor systems. We conclude that Ada does not, as currently designed, meet the needs for real‐time embedded systems.
Fortran 77 portability
Authors: Larmouth J.
Published: November 2006

This paper is the result of a study of the portability problems which might arise in the use of the Fortran 77 language. The study involved both an examination of the text of the Standard and discussions with a number of compiler‐writing teams. The paper identifies areas of Fortran 77 which are likely to cause problems, either because of an incomplete language specification, difficulties in compilation, or user inattention. It will be of interest not only to users writing large packages in Fortran, and to Fortran compiler writers, but also to those involved in language standardization and portability in general.
Ancilla—A server for the cambridge model distributed system
Authors: Shepherd W. D.
Published: November 2006

This paper describes the steps involved in writing a server for the Cambridge Model Distributed System (CMDS). The first part of the paper describes the essential components of the system and is followed by a description of the Ancilla server. Finally a number of conclusions are drawn.
Dynamically structured data
Authors: Madhavji N. H. , Wilson I. R.
Published: November 2006

While the control structures in recent programming languages are structured, the data structures are still primitive. This paper examines data structures and operations on them, and proposes some new features in programming languages. These new features are principally in the areas of data description and data usage. In data description, the emphasis is on a global view of dynamic data structures; in data usage, semantic relationships between data items are innate in the operations on these data structures. Finally, example data descriptions and algorithms using some of the new features are contrasted with those using conventional features.
LCCD a language for Chinese character design
Authors: Mei Tung Yun
Published: November 2006

One of the critical problems of Chinese data processing is to make a computer produce Chinese characters as output. This paper describes a language called LCCD, which is especially intended for high quality design of Chinese characters, although it can in fact be used for any kind of symbols. Special attention is given to the methodology of character design, using a parametric graphical approach. The underlying methods of implementation are also discussed.
Generalized non‐recursive traversal of binary trees
Authors: Kilgour A. C.
Published: November 2006

A non‐recursive algorithm for the traversal of a binary tree is presented in which the order of traversal is defined by an external data array, allowing any of the six possible orders to be selected without modification to the algorithm itself. The extra storage requirements are three pointer variables and two bits per node (or two bits per level if an auxiliary stack is used.) The algorithm is a generalization of the pointer reversal method of Schorr and Waite and is derived by transformation of a generalized recursive version. The algorithm is described using the notation and conventions of Pascal.
Micro MUMPS: An interactive database language for micro‐computers
Authors: Watanabe Tan , Ohsawa Tsuneharu , Kuma Hisao , Tsukada Wakunaga
Published: November 2006

A simple interactive language named Micro MUMPS has been implemented on a microcomputer system. Its powerful facilities for data base manipulation and character handling make programming easy for end users who are unfamiliar with computers. Micro MUMPS is a practical subset of the language MUMPS which has been implemented on many minicomputers, and it also has some additional capabilities indispensable to micro‐computer applications. A modified prefix B‐tree is used in Micro MUMPS database and its organization can be changed according to the requirements of space and time efficiency.

The design criteria of Micro MUMPS and micro‐computer based implementation techniques are discussed in this paper.
Backtrack search algorithms and the maximal common subgraph problem
Authors: McGregor James J.
Published: November 2006

Backtrack algorithms are applicable to a wide variety of problems. An efficient but readable version of such an algorithm is presented and its use in the problem of finding the maximal common subgraph of two graphs is described. Techniques available in this application area for ordering and pruning the backtrack search are discussed. This algorithm has been used successfully as a component of a program for analysing chemical reactions and enumerating the bond changes which have taken place.
A FORTRAN implementation of Concurrent Pascal
Authors: Kerridge J. M.
Published: November 2006

This paper describes the transportation of sequential and concurrent Pascal from the SOLO distribution tape to a non‐PDP‐11 like mainframe (IBM 370/145). An interpreter for the idealized virtual machine was written in FORTRAN. Subsequently the PDP‐11 dependencies were removed from the interpreter and compilers so that a more transportable version of concurrent Pascal could be generated. A FORTRAN system was then constructed which simulated an operating system environment in which the interpreter could run. Clock and device interrupts are simulated so that process scheduling can be undertaken as if real interrupts were being generated.

The system was constructed for a teaching environment so that several students could make use of the Polytechnic's interactive computer system each running their own concurrent system.
A comparison of three string matching algorithms
Authors: De V. Smit G.
Published: November 2006

Three string matching algorithms—straightforward, Knuth‐Morris‐Pratt and Boyer‐Moor—re examined and their time complexities discussed. A comparison of their actual average behaviour is made, based on empirical data presented. It is shown that the Boyel‐Moore algorithm is extremely efficient in most cases and that, contrary to the impression one might get from the analytical results, the Knuth‐Morris‐Pratt algorithm is not significantly better on the average than the straightforward algorithm.
A mainframe implementation of Concurrent Pascal
Authors: Dunman B. R. , Schach S. R. , Wood P. T.
Published: November 2006

An implementation of Concurrent Pascal on a UNIVAC1106 is described. Design decisions include the choice of compiled rather than interpreted code, as well as scheduling strategies. The advantages and disadvantages of a mainframe implementation are discussed.
‘My system gives excellent error messages’—or does it?
Authors: Brown P. J.
Published: November 2006

This paper describes a simple experiment concerning the quality of error messages for a syntax error in Pascal.
Performance figures for message‐passing over a Cambridge ring
Authors: Brereton O. P.
Published: November 2006

This communication provides performance measurements for message‐passing between LSI11/03s via a Cambridge Ring. The figures show interrupt‐driven Ring access to be intolerably slow.
A rapid lookup table method for trigonometric functions
Authors: Sewell B. T.
Published: November 2006

An algorithm for determining the values of sin 2πx and cos2πx, given x, is described. The value of the function is determined by a single masking operation. By storing 2n values in the table it is possible to exploit the periodicity of the two's complement representation to locate values for negative x and thus avoid treating negative values of x as a special case. The algorithm can be coded in some modern high level languages (e.g. PL/I) and is particularly suitable for use in structure factor routines for protein crystallography.
A static analysis of Pascal program structures
Authors: Brookes G. R. , Wilson I. R. , Addyman A. M.
Published: November 2006

Analytical techniques, which have been derived from a compiler have been developed for the static analysis of Pascal programs. The results of studies on some user programs are presented which show good agreement with comparable studies for other computer languages, and with the results of studies on the structure of compilers.
Implementing a compiler‐based test tool
Authors: McMullin Paul R. , Gannon John D. , Weiser Mark D.
Published: November 2006

DAISTS (Data Abstraction Implementation, Specification and Testing System)1 is a compiler tool‐base for program development. The compiler combines an automated ‘oracle’, which checks consistency conditions derived from algebraic specifications of modules, with run‐time routines that judge the quality of a user's test data according to statement and expression coverage criteria. This paper describes some of the implementation techniques used in DAISTS.
An algorithm for an efficient command interpreter
Authors: Gait Jason
Published: November 2006

The function of a command interpreter is to evaluate a command line, select an action according to the command entered and then execute the action, passing such parameters from the command line as required. Efficient run‐time behaviour is exhibited when the action is selected via a hash table, which provides constant time performance as the number of commands increases. Since the hash table is static and can be closely packed in an optimal fashion, the execution time can be limited to an average of less than two probes per selection even for closely packed tables.
A short note concerning lazy reduction rules for append
Authors: Sleep M. R. , Holmström S.
Published: November 2006

We show that informing a lazy evaluator that the APPEND operator is associative reduces the overall worst case performance from O(n2) to O(n).
The seismic kernel system — a large‐scale exercise in fortran 77 portability
Authors: Hatton Les , Wright Andy , Smith Stuart , Parkes Gregg , Bennett Paddy , Laws Robert
Published: November 2006

The portability of software has become a major commercial issue in recent times. Such portability does not come easily, as few if any computer languages are really portable in practice. An additional complicating factor, especially in the commercial environment, is that the resulting software must be efficient. This paper describes the design and successful implementation of a 500,000+ line portable FORTRAN 77 package for the processing of seismic data. The package exhibits demonstrably high efficiency on a wide variety of machines from minicomputers to the largest supercomputers. Experiences gained during this exercise throw much light on the integration of the various thought processes which occur during the software engineering cycle, especially the notion of locality.
A simple algorithm for clock synchronization in transputer networks
Authors: de Carlini Ugo , Villano Umbeeto
Published: November 2006

In a distributed system based on Transputer components there is one clock for each processing element, and the definition of the global system time requires the choice of a hardware or software synchronization method. This paper describes the RING_SYNC algorithm, based on a ring‐structured synchronization scheme. RING_SYNC has no provision for fault tolerance, but it introduces little overhead, thanks to the optimization of both the number of messages exchanged at sync time and the resynchronization frequency. The implementation of the algorithm together with the tests performed for measuring the synchronization error and their results are discussed extensively, and some typical applications are pointed out.
An interpreter for LOTOS, a specification language for distributed systems
Authors: Logrippo L. , Obaid A. , Briand J. P. , Fehri M. C.
Published: November 2006

LOTOS is an executable specification language for distributed systems currently being standardized within ISO as a tool for the formal specification of open systems interconnection protocols and services. It is based on an extended version of Milner's calculus of communicating systems (CCS) and on ACT ONE abstract data type (ADT) formalism. A brief introduction to LOTOS is given, along with a discussion of LOTOS operational semantics, and of the executability of LOTOS specifications. Further, an account of a prototype LOTOS interpreter is given, which includes an interactive system that allows the user to direct the execution of a specification (for example, for testing purposes). The interpreter was implemented in YACC/LEX, C and Prolog. The following topics are discussed: syntax and static semantics analysis; translation from LOTOS external format to internal representation; evaluation of ADT value expressions and extended CCS behaviour expressions. It is shown that the interpreter can be used in a variety of ways: to recognize whether a given sequence of interactions is allowed by the specification; to generate randomly chosen sequences of interactions; in a user‐guided generation mode, etc.
VIS: A virtual image system for image‐understanding research
Authors: Vernon David , Sandini Giulio
Published: November 2006

Image understanding is concerned with the elucidation of a computational base inherent in perceiving a three‐dimensional world using vision. This paper describes a low‐level (or early) vision software system, developed in the context of current collaborative research activities in image understanding, which goes some way toward fulfilling the goals of portability, ease of use, and general‐purpose extensibility. Since visual perception uses several types of disparate, but interrelated, information in some explicit cognitive organization, a central objective of the work is to represent this information in a coherent integrated manner which allows one interactively to investigate the properties of the interdependency between information types.
Experience with an object‐oriented virtual machine
Authors: Sandberg David W.
Published: November 2006

The implementation of a virtual machine for X2, an object‐based programming language, is presented. The X2 virtual machine, is similar to the Smalltalk‐80 virtual machine, but X2 does not perform message look‐up. The implementation differs from most Smalitalk‐80 systems in that objects are paged and in the ability to save changes to an image instead of the whole image. These differences allow larger images to be handled.