bluuebunny/crossref_metadata_2025 huggingface dataset:
RATSNO—an experiment in software adaptability
Authors: Hanson David R.
Published: November 2006

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

The design and implementation of a conversational BASIC system for ICL 1900 machines is described. The University of Southampton BASIC System (SOBS) is an incremental BASIC interpreter which runs under a variety of operating environments. Fundamental requirement for extensive diagnostic and debugging aids are listed, and their implementation in SOBS is discussed. A brief summary of language features is also incorporated.

The use of SOBS over a number of years has proved its usefulness in the construction of production programs for small‐ to medium‐scale applications as well as in the field of education. A number of enhanced features have gradually been added, and it is to the credit of the original design that the necessary amendments did not significantly alter the initial internal structure of the system.
Planning the software for a personal research contract
Authors: Craddock J. M.
Published: November 2006

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

The standard I/O facility for sequential disk/tape file handling in a Fortran IV IBM 360/370 Disk Operating System environment has some marked shortcomings, the most serious of which is that blocking of records is not provided for.

This paper describes SAMFOR4 (Sequential Access Method in Fortran IV), a set of Fortran callable subprograms and a file declaration facility that enables the Fortran programmer to access and create ‘standard’ sequential files. Thus inter language compatibility of files is obtained. A manyfold increase in effectiveness may also be achieved.
IDL: A machine‐independent data language
Authors: Atkinsonidl M. P.
Published: November 2006

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

The problems of producing an efficient but robust implementation of a high‐level language by building on existing compilers are discussed with reference to a LISP system consisting of an interpreter, a compiler and a large collection of support routines.

In retrospect it can be seen that almost all of the major difficulties encountered were facets of a general problem concerned with the global control of the use of store. The garbage collector, originally intended solely to manage the LISP heap, extends its scope to simplify the solution of many of these problems.
MPL1700—a high(er)‐level microprogramming language
Authors: Fisher Richard N. , McQuarrie Gordon W.
Published: November 2006

A machine‐dependent, microprogramming language for use on the Burroughs B1700 range of computers is described. It is a relatively high‐level language, containing a data‐structure definition facility and a control structure with sufficient power to enable structured microprograms to be written. However, the microcode compiled from a given program is reasonably transparent to the user, thus enabling efficiency to be maintained. It is designed primarily for writing microprogrammed interpreters for given abstract machines and a simple example of this use is illustrated.
Effects of structured programming on PL/I programmers
Authors: Zelkowitz Marvin V.
Published: November 2006

A PL/I system has been implemented which automatically collects and saves information on every program compiled and executed. This note describes some of the analysis that has been performed on approximately 9,000 of these collected programs.
A note on computing multiple sums
Authors: Meyer Bertrand
Published: November 2006

In a recent paper, a method was given for computing multidimensional sums in FORTRAN in a particular case. We show that the general problem of computing multidimensional sums is best expressed by a recursive definition which can then be translated into a programming language. The method is applied to an example optimization problem.
Monitoring the run‐time activity of algol 68‐R programs
Authors: Foxley E. , Morgan D. J.
Published: November 2006

A program profiling system for the language Algol 68‐R is described. The system provides deterministic information concerning the run‐time behaviour of certain Algol language constructs. This is accomplished by preprocessing program texts prior to compilation using a syntax analyzer for Algol 68‐R.
Reliable software: A selective annotated bibliography
Authors: Anderson T. , Shrivastava S. K.
Published: November 2006

A total of 64 references to papers, books and conference proceedings on the subject of software reliability have been selected. Each of these references is provided with an annotation consisting of a paragraph of commentary. Sections of the bibliography are devoted to requirements definition, programming methodology, certification, fault‐tolerance and reliability modelling.
How i fought with hardware and software and succeeded
Authors: Palme Jacob
Published: November 2006

This is the story of the development of a utility program to simplify the writing of programs using alphanumeric display terminals.

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

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

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

A representation for numbers using two computer words is discussed, where the value represented is the ratio of the corresponding integers. This allows for better dynamic range and relative accuracy than single‐precision fixed point, yet is less costly than floating point arithmetic. The scheme is easy to implement and particularly well suited for minicomputer applications that call for a great deal of numerical compulation. The techniques described have been used to implement a mathematical function subroutine package for a minicomputer as well as a number of applications programs in the machine vision and machine manipulation area.
Sequential pascal with recovery blocks
Authors: Shrivastava S. K.
Published: November 2006

The programming language Sequential Pascal has been extended to include recovery blocks. This paper describes the modifications made to the kernel and interpreter of Brinch Hansen's Pascal system to support recovery blocks and the associated recovery caches needed for state restoration.
CONVERT‐A language for program and data file conversions
Authors: Wolberg John R. , Rafal Marshall
Published: November 2006

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

This paper considers features which are desirable in programming languages for the efficient description and processing of tables and other data types when the data are dynamically structured. It assesses the extent to which some familiar existing languages satisfy these criteria and suggests some ways in which more adequate facilities could be provided.
SCRUB‐systematically clean and renumber users BASIC
Authors: Lawrence A. R.
Published: November 2006

SCRUB is an aid for programmers using BASIC. It lists programs in a uniform layout and provides programmers with a concordance of all simple variables, arrays, functions, subroutines and line numbers used as labels. Full syntax checks are made so that SCRUB may be used as an aid to program development and standardization.
Job scheduling in multiprogrammed computer systems
Authors: Schwetman Herbert D.
Published: November 2006

The job‐scheduling function in a multiprogramming computer system plays a key role in the achievement of the performance goals for the system. It is possible and convenient to partition this scheduling function into a priority assignment function and resource assignment function. Implementation of a general purpose resource assignment module permits a large family of scheduling strategies to be implemented via different priority calculation schemes. The implications of this partitioning of the scheduling function are studied by use of a simulation model. A system embodying this approach to job scheduling is discussed as an application of the approach to other types of systems.
Threaded code for laboratory computers
Authors: Phillips J. B. , Burke M. F. , Wilson G. S.
Published: November 2006

An extension of the threaded code technique has been developed. This new development has been used to convert a typical minicomputer into a threaded code machine by the addition of a simple, fast interpreter implemented in microcode. When made directly available to the programmer, the threaded code programming technique is a very convenient and efficient means of structuring programs, particularly in systems where programs are continually being modified.
An effective program development environment for BCPL on a small computer
Authors: Atkinson M. P. , Jordan M. J.
Published: November 2006

The essential components of an effective program development environment are described. These assist in the interactive investigation of program behaviour and accelerate the rate at which programs are modified. The whole system is compact and simple, being designed for use on small machines. It is considered as important to understand how to use these tools as it is to provide them.
SLP: A paged processor for compact lists
Authors: Jordan M. J.
Published: November 2006

A list processor, SLP, is presented as a means for manipulating data structures represented as compact lists. The list space is both paged and segmented in order to handle large data structures on a conventional minicomputer. The list processing primitives arc provided as procedure calls embedded in a high‐level language, and the system includes aids for developing user programs. The implementation for a PDP 11/45 computer is presented along with a discussion of the use and performance of the system in practice.
Use and misuse of SPSS
Authors: Leece John , Parker Frank
Published: November 2006

This paper reports a survey of the use of SPSS at a major nationwide university computer centre. SPSS was modified to output a record each time it was used reporting:

who was using the program;

resource consumption;

size of data set;

SPSS commands used;

SPSS syntax errors which occurred;

job status at termination.

We found that SPSS was used 3,000‐4,000 times monthly by a user community from over 30 departments. Resource consumption varied greatly but the majority of jobs are quite small in our terms. Data sets also varied greatly but most were up to 300 cases by up to 20 variables.

The majority of users employ a subset of the SPSS command language and attempt only one ‘procedure’ in each run. About 30 per cent of jobs fail due to a user error in the syntax, and we found considerable consistency from month to month in the syntax errors made.

Our detailed observations have many implications for the ongoing development of SPSS and its documentation, for the users, and for those who teach or advise in SPSS.
An implementation of structured multiprogramming
Authors: Beaumont W. P.
Published: November 2006

The study of operating systems principles is greatly enhanced if processes can be expressed in language constructs that explicitly allow for multiprogramming. The enhancement is increased if such a system actually exists for practical use. This paper describes an implementation of such a system. The language used (a forerunner of Concurrent Pascal) is described briefly. The body of the paper describes the implementation method in some detail. In order to achieve multiprogramming with a single processor, a number of process descriptors are maintained, each associated with the execution point in the program of a parallel process. Control is distributed among the processes in a manner determined by the program environment. The design of the implementation, in itself, provides an interesting example of operating systems principles at work.
Pilot implementations of reliable systems
Authors: Ringland Gill , Trice A. R.
Published: November 2006

This paper describes the pilot implementation of a modifiable reliable system. On the basis of this work, we have been led to conclusions on necessary hardware and software features for supporting a reliable system, techniques for building such systems, and the scope of the results to be expected from a pilot implementation.
A simplification of code tables in a one‐pass PL/M compiler
Authors: Johnsen Kari
Published: November 2006

A two‐dimensional table containing code to be output for one binary operation is replaced by an algorithm and two one‐dimensional tables. This algorithm constructs the entries of the first table only whey they are needed. The algorithm is in fact an implementation of the thought process used in the hand construction of the first table.
A 1900 FORTRAN post mortem dump system
Authors: Ng P. H. , Young G.
Published: November 2006

This paper reports a FORTRAN post mortem dump system (PMD) for the ICL 1900 computers. The system, Jointly implemented by Birmingham and Liverpool Universities, can perform a core/storage dump In terms of the original FORTRAN source following the segment (subroutines, etc.) history of execution when the program falls to terminate successfully. The compilation overheads of the new system are very low and the execution overheads practically none.
Data mappings again
Authors: Hutt Andrew T. F.
Published: November 2006

Extracting data from a relational data base in order to respond to a request for information requires the use of a large number of algorithms. Some of these algorithms are responsible for validating data values, others support the relational operators while others still support the basic data structures used at the lowest levels of the system. This paper recognizes that the successful operation of a relational data base management system is dependent on the organization of these algorithms and emphasizes this point by describing a coherent architecture to embrace them.
User‐interface design for text editing: A case study
Authors: Sneeringer James
Published: November 2006

This paper describes the design of the user interface of a text editor named Occam with the goal of communicating by example the process of user‐interface design. An attempt is made to induce principles; where that attempt falls, the raw details are presented. First Occam Itself Is described, and then aspects of its user Interface are used to exemplify (1) power versus ease of learning, (2) the use of prototypes and user feedback, (3) the importance of planning and (4) error detection and handling.
Use of a formal notation for static semantics in compiler design
Authors: Williams M. H. , Bulmer A. R.
Published: November 2006

Formal notations for the specification of the syntax and the dynamic semantics of languages exist and are of great benefit to the compiler writer. However, formal notations for the static semantics of languages have tended to be tools of the language designer and of little practical significance to the compiler writer. This paper describes how a particular notation was used to assist in the implementation of a Cobol compiler and of an interpreter for a simulation language.
Experience with the universal intermediate language janus
Authors: Haddon B. K. , Waite W. M.
Published: November 2006

Janus is a symbolic language intended for use as an intermediate language in the transportation of software. Since its initial design four years ago, it has been used to implement a portable Pascal compiler, in the design of an Algol 68 compiler, and to realize a portable package of mathematical routines. These experiences, together with a critical re‐evaluation of the design criteria, have led to some modification of the specifications of Janus and an increased confidence in the viability of the approach. They have also indicated some problems yet to be solved. This paper reviews the significant lessons which we have learned, and quotes some results which support our confidence.
Experience with the pascal P‐compiler
Authors: Berry R. E.
Published: November 2006

The paper seeks to document the experience of a small group interested in implementing and using Pascal on a modest but perhaps typical minicomputer. The implementation was achieved by transporting the intermediate code produced by a CDC 7600 version of the Pascal P‐compiler to the minicomputer and producing an assembler and interpreter to execute this code on the mini. Some aspects of the performance of the resulting system are reported.
Comparison of different disk searching methods
Authors: Quittner P. , Kotsis D.
Published: November 2006

The efficiency of various disk file processing methods is compared. Serial search and activity frequency ordered list processing, direct access and merged sequential processing are compared and the increase in processing time due to overflow records is calculated. Relationships are given to decide which method is faster in practice for concrete data sets and devices.
CONA—a conversational algol system
Authors: Atkinson L. V. , McGregor J. J.
Published: November 2006

Each CONA user sits at a terminal and interacts directly with an Algol 60 system: programs may be input, edited and executed; a program is checked as it is supplied and any syntactic or semantic error reported immediately; a program may be interrogated during execution.
Design and implementation of data abstraction definition facility
Authors: Schwabe Daniel , Lucena Carlos J.
Published: November 2006

This paper describes the Implementation model of a data definition facility for abstract data types, implemented as an extension to PL/1. The facility is based on a modified version of the cluster mechanism for the implementation of types. The proposed version tries to address the issues of efficiency and portability in connection with the goal of systematic programming.
Reproducible testing of monitors
Authors: Hansen Per Erinch
Published: November 2006

This paper describes a systematic method for testing monitor modules which control process interactions in concurrent programs. A monitor is tested by executing a concurrent program in which the processes are synchronized by a clock to make the sequence of interactions reproducible. The method separates the construction and implementation of test cases and makes the analysis of a concurrent experiment similar to the analysis of a sequential program. The implementation of a test program is almost mechanical. The method, which is illustrated by an example, has been successfully used to test a multicomputer network program written in Concurrent Pascal.
A support system for interactive languages
Authors: Parsons I. T.
Published: November 2006

The implementation of a support system for interactive languages is described, which include a controlling routine, a macro processor, lexical and syntactic analysis routines, semantic actions, error handling and analysis, log and code generation routines. There are also utility programs for generating the state tables for the syntax analysis.

By using a structured programming approach these routines have been developed very quickly, but can still be developed and enhanced due to a well‐defined working environment, a simple approach to coding and reasonable internal documentation.
A fundamental approach to debugging
Authors: Tratner M.
Published: November 2006

We examine the costs and psychology of debugging. We propose a fundamental approach to debugging. We suggest that industry's outlook is perhaps not thorough.
A compact, portable CRT‐based text editor
Authors: Fraser Christopher W.
Published: November 2006

CRT‐based text editors offer a better user interface than most teletype‐based text editors but are more complex and less portable. Building a screen editor as a front end to a line editor exploits existing code, yields a more compact, portable result, and permits one computer to edit another's files. This paper describes such an editor.
Computer programming and the human thought process
Authors: Tracz William J.
Published: November 2006

This paper analyses certain human thought processes associated with computer programming and observes some limitations, inherent in the human mind, that affect the writing of good computer programs.

The thought processes associated with computer programming fall into two major categories: those associated with the nature of problem solving; and those associated with man/computer communication using conventional programming languages.

The questions raised in this paper bring to light the psychological and physiological implications of such programming tools and procedures as structured programming, code walkthroughs and top‐down design in support of their use.
Public online pool—a method for managing online direct access space
Authors: Spitz Eli , Yuval Asher
Published: November 2006

This paper describes a software system, implemented at the Weizmann Institute of Science Computer Center, for managing online direct access space in a heavy batch/time sharing environment. Appropriate background discussion of the problem is presented in general, yet practical, terms. We describe the ‘ideal’ solution along with its shortcomings as we see them, followed by the solution as implemented at our installation and successfully operating for 5 years. Finally, we point out the effect this system had on our installation and show where future efforts could be rewarding. The work this paper describes won the 1975 prize of the Information Processing Association of Israel.
A compiler model for a relational data base management system
Authors: Hutt Andrew T. F.
Published: November 2006

One of the chief difficulties which needs to be overcome during the early design stages of a system is that of establishing a satisfactory design for that system. From the time it was first conceived it was apparent that the Relational Data Base Management System is like a compiler in so far as it takes a succession of user requests for information formulated in an applied predicate calculus and translates each one into a series of calls which access an underlying data base and transform data from that data base into the form the user wishes to see.

This paper compares the architecture of the Relational Data Base Management System with that of a compiler, and then demonstrates the use of the architecture when processing a language based on an applied predicate calculus. Finally, the paper describes a number of extensions to that architecture which are required to solve the particular problems raised by the data base system.
Parallel processing in an adaptable application oriented language processor
Authors: Ellis T. M. R.
Published: November 2006

A framework for an application‐oriented language processor is described which is based on a series of independent modules operating in parallel. All intermodule communication is handled by means of monitor procedures. The way in which this allows modules to be added or removed at will is discussed, and the implications of this approach for adaptable processors are described, with particular reference to the numerical control of machine tools.
Microcomputer comparison
Authors: Hansen Per Brinch , Hayden Charles
Published: November 2006

This paper illustrates a precise method for comparing microcomputer instruction sets for the purpose of language implementation. The standard of comparison is the Concurrent Pascal interpreter for the PDP 11/45 minicomputer. The paper identifies the most frequent virtual instructions and their implementation on the PDP 11/45 computer. It then compares the speed and size of interpreters implemented on various 16‐bit microcomputers. It also includes the process switching times of these computers.
Long/short address optimization in assemblers
Authors: Williams M. H.
Published: November 2006

In a number of computer systems an instruction in symbolic assembly language may be translated as either a long form or a short form instruction in machine code depending on certain conditions. Assemblers which optimize the size of a program by using short form instructions wherever possible, sometimes require three or more passes to achieve this. This paper describes an approach to solving this type of problem which can be implemented in a two‐pass or even a one‐pass assembler.
Variable precision arithmetic on CDC 6000/7000 machines
Authors: Robertson D. A.
Published: November 2006

Suitable FORTRAN statement functions, and COMPASS OPDEFS are presented, to permit simulation of shorter precision arithmetic on CDC 6000/7000 machines.
Make — a program for maintaining computer programs
Authors: Feldman Stuart I.
Published: November 2006

Good programmers break their projects into a number of pieces, each to be processed or compiled by a different chain of programs. After a set of changes is made, the series of actions that must be taken can be quite complex, and costly errors are frequently made. This paper describes a program that can keep track of the relationships between parts of a program, and issue the commands needed to make the parts consistent after changes are made. Make has been in use on UNIX

UNIX is a trademark of Bell Laboratories.

systems since 1975. The underlying idea is quite simple and can be adapted to many other environments.
A highly‐structured interpreter for a SNOBOL4 subset
Authors: Pagan Frank G.
Published: November 2006

A highly‐structured and conceptually simple processor, written in Algol 68, for a basic but useful subset of SNOBOL4 is presented. It provides a significant, large‐scale demonstration of a particular methodology for constructing ‘master’, machine‐independent implementations of programming languages. The processor is closely related to a formal operational definition of the SNOBOL4 subset in that it incorporates an abstract machine, a high‐level abstract syntax (in the form of mutually recursive mode definitions) for the internal form of programs, and a set of mutually recursive interpretation procedures for programs in this internal form. The various aspects of the processor are documented in some detail. The experience of testing the processor is briefly discussed.
Design of software for text composition
Authors: Mudur S. P. , Narwekar A. W. , Moitra Abha
Published: November 2006

Text composition software is mainly used by compositors, who are usually not programmers, and who do not necessarily know much about the underlying technicalities of computer usage. It is important, therefore, that the text composition system be such that a compositor would have a minimum amount of learning to do. Factors such as flexibility of style specification and economical proof generation are important from a user's point of view. On the other hand, multilingual text input, output device independence and system portability are points of concern for the system designer. In this paper, a specific text composition software system designed on the basis of such considerations is briefly described. The way in which the above‐mentioned factors affect the design of the system is discussed in some detail.
Design and analysis of a hyphenation procedure
Authors: Moitra Abha , Mudur S. P. , Narwekar A. W.
Published: November 2006

A hyphenation procedure is described wherein the search list includes exceptional words, prefixes, suffixes as well as a probabilistic Break‐Value‐Table. The list of prefixes and suffixes is augmented with what are termed as root words to achieve greater flexibility and accuracy. Importance is given to a number of ways whereby the overall algorithm can be speeded up; in this connection a number of rejection rules are formulated so that only the likely candidates are processed. The order of searching of the various data tables is also considered. A further refinement is tried wherein the common suffixes and common prefixes are given preferential treatment. The algorithm developed was tested on approximately 2,700 common English technical words and an attempt is made to analyse the incorrectly handled words.
A draft description of Pascal
Authors: Addyman A. M. , Brewer R. , Burnett‐Hall D. G. , de Morgan R. M. , Findlay W. , Jackson M. I. , Joslin D. A. , Rees M. J. , Watt D. A. , Welsh J. , Wichmann B. A.
Published: November 2006

This paper provides a description of the programming language Pascal. It has been published to enable those without easy access to the official BSI ‘draft for comment’ to comment on the description.
Pascal scalars as state indicators
Authors: Atkinson L. V.
Published: November 2006

The significance of user‐defined scalar types in Pascal is often underestimated. Three distinct roles are identified and particular emphasis is given to one omitted by all currently available Pascal texts.
Macros without tears
Authors: Brown P. J.
Published: November 2006

The key to advancing the use of macro processors is not in providing ever more powerful facilities. Instead it lies in minimizing the effort needed to learn to use macros. This can be achieved by embedding the macros as extra run‐time facilities—not as compile‐time facilities—in existing programming languages.
A useful data‐structuring technique
Authors: Ellis T. M. R.
Published: November 2006

A data‐structuring technique is described which enables data of widely varying types to be stored in a simple tree structure, and which requires only the name of a variable for both its type and value to be retrieved. The method uses well‐established list‐processing concepts in an unusual environment and illustrates the advantages to be gained by their use in application‐oriented software. It has been used with some success in a modular processor for the storage of geometric and other data but is equally applicable to other fields.
Lattice structure segmentation of ALGOL‐like programs
Authors: Kawai Satoru
Published: November 2006

A segmentation scheme for ALGOL‐like programs is presented. This scheme, based on the separate compilation facility of the language ALGOL 68C, enables the programmers to use a branch‐and‐merge (lattice) structure in segmenting their programs, besides the tree which is the only one structure usable in ALGOL 68C programming. The necessity of this scheme is explained and the way of its implementation is described. The effectiveness of this scheme compared with tree structure segmentation is shown in terms of the recompilation cost of an example program of reasonably large size which has been resegmented from the tree to the lattice structure with no addition or duplication of codes.
A message distribution technique and its application to network control
Authors: Fjellheim Roar A.
Published: November 2006

The patterns of message exchange in distributed computer systems can become sufficiently complex to justify the construction of communication services that extend the basic message transmission mechanism. A simple method for implementing a copy distribution, or broadcast, service is described. It is shown how the method can support command and monitoring functions in a computer communication network.
TRIPOS—a portable operating system for mini‐computers
Authors: Richards M. , Aylward A. R. , Bond P. , Evans R. D. , Knight B. J.
Published: November 2006

There are several successful operating systems for mini‐computers written in high level languages and the time is now ripe for the development of portable systems for such machines. The system described in this paper is primarily designed to provide a friendly interactive multiprocessing environment for a single user. From his point of view, substantial parts of the system are completely machine independent. These include, for instance, the filing system, the command language, text editors, overlaying facilities and interprocess communication primitives. The system is suitable for many different application areas ranging over process control, data acquisition, data communication, text handling, data base systems and teaching.
A compact function for regular expression pattern matching
Authors: Richards Martin
Published: November 2006

This paper describes a simple compiler and interpreter for a finite state machine recognizer of patterns represented by regular expressions. The algorithm is designed to be compact and to require little work space.
Implementing data abstraction features in a stack‐based language
Authors: Gannon J. D. , Rosenberg J.
Published: November 2006

This paper describes SIMPL‐D, a stack‐based language with data abstraction features, and some of the details of its implementation. The language allows users to define new types that are parameterized by size and to perform system‐defined operations (e.g. assignment) on objects with user‐defined types. The use of object‐describing templates in the implementation of storage allocation, assignment and returning values from functions is discussed. Finally, the conflicts between automatic initialization and separate compilation are explained.
Choosing a tag‐list algorithm for a compiler with special application to the ALEPH compiler
Authors: Grune Dick
Published: November 2006

Requirements are formulated for a tag‐list algorithm, i.e. the algorithm used in a compiler for handling the symbol table or identifier list. Starting from a very general tag‐list algorithm, 18 practical versions are developed and their merits judged. Although the final choice (binary search in a diluted table) depends on the details of the application, the main part of this article is not devoted to that final choice itself but rather to ways of reaching it.
The portable compiling systems of MUSS
Authors: Barringer H. , Capon P. C. , Phillips R.
Published: November 2006

Portability of MUSS compilers is achieved by using an abstract machine model concept. Two different abstract models, both suited for multi‐language multi‐machine usage, have been developed and evaluated. These models differ mainly in the level of interface to the compiler. The form of these models and the performance of two compilers, each using both models, are presented.
An assessment of the MUSS operating system
Authors: Theaker C. J. , Frank G. R.
Published: November 2006

This paper presents a critical appraisal of the MUSS portable operating system. Development costs for the system are discussed, including the cost of transferring it to a new machine. Its performance is also examined, together with a description of the techniques used to assess performance.
Experiences with the UNIX time‐sharing system
Authors: Lions John
Published: November 2006

The UNIX

UNIX is a trademark of Bell Laboratories.

Time‐sharing System has been in use at the University of New South Wales since 1975, and favourable experience has led to its widespread adoption on campus for both teaching and research. It has proved very adaptable to the university's needs, and very usable in a situation where staffing levels are critically low. One important application area, the teaching of Computer Science, is now firmly based upon the use of the UNIX system.
On publication Pascal
Authors: Bishop Judy M.
Published: November 2006

Having recently read several new Pascal textbooks, I was struck by the multitude of ways in which programs are represented in print. Some of these are more pleasing to the eye than others, and with a typesetting machine, anything is possible. However, several books are being produced these days from typewritten copy and there seems to be no accepted second‐best to the italics‐and‐bold favoured by most publishers. It would also be desirable if the style used by books could correspond more closely to that which is handwritten or computer‐produced. This note summarizes the possibilities and makes a call for stability, if not outright standardization.
Synchronization under a commercial operating system
Authors: Jensen Jørn , Lauesen Søren , Ravn A. P.
Published: November 2006

Mutual exclusion and general synchronization of concurrent processes (‘tasks’) are well‐known principles for constructing reliable real‐time systems. This paper shows how to implement these principles under a typical commercial operating system which provides incomplete synchronization operations. The problem of synchronizing erroneous tasks is discussed briefly.
A human‐computer interface for non‐computer specialists
Authors: Palme Jacob
Published: November 2006

The COM teleconferencing system was designed to be easy to use for both beginners and people with much computer experience. A number of design choices in organizing the human‐computer interface were considered very carefully. These design problems are not unique for teleconferencing applications, but will appear in many other developments of human‐computer interfaces for non‐computer specialists.

This report discusses naming conventions, menu format, user commands, help facility and the treatment of ‘type ahead’ from the users.
Some aspects of concurrent programming in CCNPASCAL
Authors: Narayana K. T. , Prasad V. R. , Joseph M.
Published: November 2006

CCNPASCAL is a language derived from Pascal and Concurrent Pascal which has been used in the development of an operating system for a multiprocessor. This paper introduces some of the important features of the language and illustrates them with examples. The language provides mechanisms for interfacing separately compiled modules, for building abstractions of collections of resources and for efficient asynchronous communication.
Language issues in the implementation of a kernel
Authors: Natarajan N. , Sinha Mukul K.
Published: November 2006

In this paper we present some issues encountered in the implementation of a kernel for a multiprocessor system using a high level language called CCNPASCAL. We present the nature of the problem concerning each issue, the solutions we adopted and possible better alternatives which we could not adopt for various reasons.
An assessment of concurrent Pascal
Authors: Coleman D. , Gallimore R. M. , Hughes J. W. , Powell M. S.
Published: November 2006

This paper assesses Concurrent Pascal against its design aims. The language is shown to be suitable for writing reliable non‐trivial concurrent applications programs and operating systems. The major weakness of the language is its inability to provide an environment for other Concurrent Pascal programs. A new language construct, group, is proposed to remedy this difficulty.
Implementing strings in Pascal—again
Authors: Sale Arthur
Published: November 2006

Following an earlier proposal that strings be realized in Pascal using the existing sequence abstraction, two simulating implementations which support the concept via a package have been written. This short paper addresses two important questions regarding such implementations which are not fully covered by Bishop's paper3.
Using convert to transform source code
Authors: Wolberg John R. , Rafal Marshall
Published: November 2006

There are a number of reasons why one might wish to transform the source code of an operational program:

To make the program conform to a standard layout.

To make the program conform to syntax and semantics standards.

To improve the performance of the program.

The primary advantage of transforming source code into a standard form is that the programs become easier to maintain. The cost‐benefit of standardization is thus realized at a later stage in the lifetime of the programs. Alternatively the cost‐benefit of improving performance is immediate.

The desirability of transforming source code is affected by several parameters:

The benefit to be realized from transformation.

The cost of transformation.

The time involved in transformation.

The risk associated with transformation.

If the benefit of transformation is significant, the cost, time and risk associated with the process can be considerably reduced by automating the process.

In this paper, application of the CONVERT language to the transformation problem is discussed. CONVERT was developed as a vehicle for writing automatic language and dialect converters. Clearly, the features useful for converters are also applicable when the application involves transformation of source code.
MPLOT3—A system‐independent plotting package
Authors: Sethi H. R. , Paul D. H.
Published: November 2006

This paper describes a general purpose plotting package which enables sets of data points to be plotted on a variety of output devices by simply specifying the mnemonic name and without any programming on the part of the users. A plot can be produced with the default options from a simple data file which can be expanded to call in many extra facilities. Options include scaling, automatic selection of axes and their markings, and identification of curves/shapes by varying‐length dashed lines, different symbols or colours. English and Greek characters can be written at any angle and size. Clipping or voiding facilities are provided to confine plotting inside or outside a given area. The package is expandable to allow new facilities to be added. The present form has been arrived at through feedback from the users over the last four years and has found a wide variety of applications in a scientific environment.
Input/output in high level programming languages
Authors: Pyle I. C.
Published: November 2006

A system's input/output is its communication with the other systems in its environment. By viewing the relationship as communication between partners, we identify the fundamental requirements in input/output programming, and discuss the responses of various programming languages to these requirements. Traditional programming languages provide either nothing or an expensive incomplete solution. The new languages Modula and Ada now offer major improvements in this area. We describe the style of their solutions, and give corresponding guidance for low‐level input/output programming.
Implementation of a special‐purpose language using Pascal implementation methodology
Authors: Machura Marek
Published: November 2006

This paper gives an account of the implementation of a problem description language for a certain program package. The implementation model used is that of the Pascal compiler. The main purpose of the paper is to convince applications programmers of the advantages of this approach and to summarize the experiences gathered during implementation.
A campus network based on ICL 2900 series protocol
Authors: Eaglestone B. M. , Partington N. J.
Published: November 2006

A campus network has been built at the University of Salford in which a number of minicomputers have been linked to a PRIME 300/400 system using the protocol adopted for ICL 2900 series communications. This protocol is known as Extended Basic Mode, or XBM. The network is integrated into a wider regional network of ICL machines through a link to the local ICL 1904S service. The protocol defines a standard terminal model which is used as a machine‐independent basis for the network construction. The benefits are described which the network brings to users both of the various minicomputers and of the PRIME system.