bluuebunny/crossref_metadata_2025 huggingface dataset:
A multi‐user operating system for transaction processing, written in Concurrent Pascal
Authors: Kruijer H. S. M.
Published: November 2006

This paper presents a medium‐sized operating system written in Concurrent Pascal, thereby describing further experience with this language and giving further indications of its scope. The operating system was developed to support an application in the area that is usually termed ‘commercial’ or ‘administrative’. Both the functional capabilities and the structure of the operating system are described, with emphasis on its facilities for data file management, and its size and performance are given. A secondary theme of the paper is the relationship of the operating system's qualities to the properties and facilities of the programming language Concurrent Pascal used for its development.
Designing structured cobol programs
Authors: Ferstl O. K. , Sinz E. J.
Published: November 2006

COBOL is now more than 20 years old and will probably survive to become much older. Since it has some features which are out of date it is desirable to adapt at least the program style to some standards of modern programming languages. The adaption is not only a matter of style but also of costs of program production and program maintenance. This paper presents constructional rules for programming in COBOL which by‐pass some of the drawbacks and allow more readable and more maintainable program structures. Finally a postprocessor is presented, that allows verification of the chosen constructional rules and documentation of the resulting programs.
A test data synthesizer for telephone company accounting office processing of call data
Authors: Covington W. O. , Wexelblat R. L.
Published: November 2006

Testing a program designed to recognize several dozen kinds of anomalies in large volumes of input data requires test data with many combinations of the anomalies in the data stream. The large number of combinations of anomalies makes it impractical to generate test data manually. This paper describes a test data synthesizer designed to help verify the accuracy, capacity and correctness of such a program. The operation of the synthesizer is analogous to the Fourier synthesis of a periodic function. A sweep action permits test data with well known response to be combined in a methodical way to explore complicated interactions which are not well understood.
Experiences in benchmarking for the selection of an interactive system
Authors: Lang T. , Newbury J. P. , Watkins D. E. P.
Published: November 2006

The paper describes how a benchmark was constructed to assist in the selection of a general purpose interactive computing system. Because no existing user programs were available, a ‘synthetic’ program was constructed to load the different parts of the system, and the program embodied into a job script with edit, compile and run phases. The calculation of the program and job parameters were successfully derived from the operational requirements. The problems of running the benchmark and analysing the results are also described. The results of the exercise contributed significantly to obtaining a satisfactory system and show a reasonable correlation with subsequent system usage.
An adaptive system for dynamic storage allocation
Authors: Leverett Bruce W. , Hibbard Peter G.
Published: November 2006

We describe a technique (the adaptive creation of free lists) for dynamic storage allocation that is particularly suited to situations in which the distribution of sizes of blocks requested has one or more sharp peaks. We describe a particular dynamic storage allocation system and the environment in which it runs, and give the results of some experiments to determine the usefulness of the technique in this system. Our experiments also tested the efficacy of a technique suggested by Knuth for improving the performance of similar systems.
Modelling and validating the man‐machine interface
Authors: Casey Bernice E. , Dasarathy B.
Published: November 2006

This paper describes a formal model for expressing the functional requirements of the man‐machine interfaces of interactive systems. It also shows how this model can facilitate the automation of other useful activities such as checking for inconsistency, redundancy, and incompleteness in the specification, and validating the implementation of the interface against its original requirements. Finally, the paper comments on the authors' experience in developing an interactive system using this formal model.
The Cambridge ring and Unix
Authors: Collinson R. P. A.
Published: November 2006

In March 1980, a VAX 11/780

VAX is a trademark of Digital Equipment Corp.

was installed at the Computing Laboratory of the University of Kent. The VAX runs UNIX as a user service. This paper discusses what has been learnt from the integration of an existing operating system (UNIX) into a local area network based on the Cambridge ring. The approach which has been evolved attempts to make the network connections invisible to the operating system so that the utilities running on the system can access the network as if they were talking to standard peripherals. The paper gives an overview of the ring and the protocols in use at Kent; and points to alternative approaches to the implementation which could be used in a different environment.
Introduction of history to variables
Authors: Takaoka Tadao , Maclean Michael , McKenzie Bruce
Published: November 2006

The concept of history is introduced to the variables of a programming language. At each execution of assignment statement for a variable x, the current value of x is saved to x〈1〉, that of x〈1〉 to x〈2〉 and so on automatically. With the aid of this facility, a programmer will not worry about bookkeeping of saving the content of a variable and will make fewer errors in programming. A possible implementation method for the history on a conventional computer is also discussed.
The syntax of user‐defined dyadic operators
Authors: Fisher A. J.
Published: November 2006

This paper briefly reviews the syntactic means which are present in some well‐known programming languages for denoting the application of user‐defined dyadic operators, and suggests an alternative syntax for operator applications.
HADES—A command environment that supports structure
Authors: Wilkes John
Published: November 2006

HADES is a command program designed to aid programmers and authors involved in writing systems with an inherently high degree of structuring. It presents the system being developed in a hierarchical fashion, encouraging a top down approach to its design, and alleviates many of the problems experienced with traditional filing systems. Unlike other programming environment systems, the utility programs and tools do not have to be ‘integrated’ into the system, which means that new and existing tools can be quickly and easily added. This results in a rich set of operations implemented at very low cost.

The paper outlines some of the problems that arise with traditional filing systems from the point of view of software development, and then presents the approach adopted by HADES. This is followed by a discussion of the strengths and weaknesses of the result and some reflections on the lessons that have been learnt.
A dialogue generator
Authors: Kaiser Pavel , Stetina Ivan
Published: November 2006

This paper describes work done on the Dialogue Generator, DIAGEN, at the Computing Research Centre in Bratiplava. The general aim of this work was to design and implement a generalized software tool for creating an interactive interface which would permit the non‐programmer to work directly with the computer in various application areas.

The Dialogue Generator, DIAGEN, separating completely the dialogue from the application program that is to be dialogue‐driven has been implemented. A specialized DIAGEN Language is used for the dialogue description in the form of a scenario. The DIAGEN Conversational System interprets the dialogue program generated from the scenario, and controls the flow of a dialogue session.
A microprogrammed P‐CODE interpreter for the data general eclipse S/130 minicomputer
Authors: Hall J. A.
Published: November 2006

This paper describes the implementation of a P‐CODE interpreter by microprogramming. An existing system based upon the Pascal P compiler was modified by rewriting the interpreter in microcode. Consequent improvements in the system performance are illustrated by times for compiling the compiler and various small Pascal programs. The execution rate for the new system is also compared with several other languages available on the Eclipse. Problems relating to Eclipse microcode when used for tasks of this type are also discussed.
Low cost computer graphics for micro computers
Authors: Morrison Ronald
Published: November 2006

A graphical output system small enough to fit on a medium range micro computer is described. The system, called Outline, allows the user to produce line drawings in an infinite two dimensional space. It also offers a picture building facility in which the relationship between different sub‐pictures is specified by mathematical transformations. A basic set of picture manipulating facilities along with a set of physical drawing attributes for each device is defined. The system is embedded in a high level language for simplicity of use.
Computer system simulation in Pascal
Authors: Haá Anna
Published: November 2006

The programming language Pascal is considered as one of the most interesting computer system simulation tools. This paper discusses design facilities required in simulation languages, making use of a model described in Pascal. An important area is seen to be that of queues, lists or sets, and the facilities that are powerful yet simple to use are stressed. The problem of parallelism and synchronization in a simulator is solved. The structure of the simulator is considered.
How to improve computer advisory services
Authors: Dawson A. F. , Coombs M. J. , Alty J. L.
Published: November 2006

There are an increasing number of active computer users who are not computer professionals and so require continuous guidance in order to effectively employ computer facilities. In universities such guidance is provided by a formal advisory service. While advisory services play a vital role for university users, there are numerous problems which can detract from their effectiveness. This paper identifies many of these problems, and recommends ways of overcoming them. These suggestions are largely based on the results of a research project carried out for the past four years at the University of Liverpool. Topics considered are: (i) the assessment of various methods for organizing advisory services; (ii) the specific needs of inexpert users and strategies for effectively advising them; (iii) problems of the comprehension of computing information; (iv) guidelines for good advisory communication; (v) methods for improving the professional status of the advisory function.
Compilation of the Pascal case statement
Authors: Hennessy John L. , Mendelsohn Noah
Published: November 2006

Pascal case statements can be compiled using a variety of methods, including comparison trees and branch tables. The scheme discussed here combines the two techniques to allow comparison trees with entries that are branch tables. The use of a combination of the two techniques is shown to adapt well to certain instances of case statements. Extensions to the standard case statement also require such a scheme to obtain an efficient implementation.
User acceptance: Design considerations for a program generator
Authors: Mathewson S. C.
Published: November 2006

The paper discusses those features in a program generator, a simulation program preprocessor, which are significant in the context of providing an effective interface with a user of the package. Discussion identifies two different roles for a generator: (1) to teach simulation languages and (2) to assist in the construction and use of a simulation model as a problem solving tool. In the context of the first role emphasis is placed upon both input design and upon the relationship between output and published texts. In the second role, discussion centres upon the need for a careful consideration of the related teaching techniques. DRAFT/SIMSCRIPT 11.5 is used to illustrate the discussion.
A specification schema for indenting programs
Authors: Mateti Prabhaker
Published: November 2006

A two level specification of the functional behaviour of a class of indenting programs for Pascal is presented. The transformation that these programs perform on the input text is a composition of splitting input lines, altering the blank space between lexical tokens and computing the margin required in front of each of the split lines. The high level specification is given as a stylized Pascal grammar in Extended BNF. In contrast, the low level specifications, which are operationally closer to a program, and which define how syntactically invalid text is dealt with, require several mathematical functions that capture the essence of these basic transformations. The specifications of an indenting program for Pascal are then obtained as a further elaboration of these functions. Most indentation styles appearing in the literature can be specified with precision using methods developed in this paper. Our experience in this case study indicates that although specifications for real‐life programs can be given using simple mathematics, the effort required is still considerable.
Algorithms for a persistent heap
Authors: Atkinson Malcolm , Chisholm Ken , Cockshott Paul , Marshall Richard
Published: November 2006

PS‐Algol is a dialect of Algol for the programming of problems that would normally require a database management system. It supports a persistent heap, and an associative store; it has embedded within the language features to support tasks normally carried out by filing systems or database management systems.
An analysis of microcomputer implementation of pascal
Authors: Oliveira J. N. , Wilson I. R.
Published: November 2006

Various solutions to the problem of providing Pascal on low‐cost microcomputers have been proposed and implemented. The techniques used and structure of these systems are discussed. A quantitative analysis leads to suggestions of alternative solutions, which may involve significant changes in the typical compiler/interpreter architecture.
Short communication dmert crash resistant file systems
Authors: Wallace John J.
Published: November 2006

DMERT (Duplex, Multi‐Environment, Real Time) is a real‐time operating system that supports reliable telecommunications applications. Although DMERT file systems are based on UNIXTM file systems, which suffer robustness drawbacks, DMERT file systems do not suffer these drawbacks. The DMERT file manager uses synchronous writes and file system audits to manage crash resistant file systems. The performance penalty for this crash resistance is minimal. This note describes DMERT's crash resistance policy and shows how UNIX and UNIX‐like file systems can be made crash resistant without sacrificing performance.
Exception handling in C programs
Authors: Lee P. A.
Published: November 2006

This paper describes a software package which has been constructed to allow programs written in the C language to make use of exception handling facilities. The package is implemented as a set of macros and procedures and requires no modification to the C compiler or preprocessor. The operation of the package and its facilities are described, and practical experience of its use is presented. The code in the package is given in the appendix.
A system for analysing Ada programs at run‐time
Authors: Holdsworth David
Published: November 2006

This paper describes a prototype system for analysing core dump files from crashed Ada programs. In addition the general question of Ada runtime debugging is discussed. It is suggested that the Ada scope rules are not appropriate to control visibility in this situation. An alternative scheme has been implemented in the prototype. Some first impressions of live use of the Ada language are included among the conclusions.
Decision tables
Authors: Chvalovský Václav
Published: November 2006

Decision tables have been known for almost 20 years but there are still data processing shops where systems analysts and programmers have not used them at all. That is why it is felt important to re‐open their case once again and publicize experience with their use, as well as more recent developments and expected future trends. It appears, from experience gained with decision tables over the past 10 years, that they can be of great help in programming, program maintenance, as well as in design communication between analysts and programmers. To assist also in training, a brief user's guide is included in this article, which is belived to make the first attempts to easier design of a decision table. Finally, the procedure adopted to implement a machine independent (portable) decision‐table preprocessor for COBOL is outlined. In as much as the availability of such a preprocessor appears essential for the degree of use of decision tables, this single fact may well become a milestone in the overall popularity of decision tables world‐wide.
Global variables versus local variables
Authors: Fisher D. L.
Published: November 2006

Much modern programming theory places emphasis on the localization of the use of program variables and only occasionally justifies the use of global variables. This paper does not support that point of view. In fact it advocates exactly the reverse.
A program structuring preprocessor for a macro assembly language
Authors: Hayashi Tsunetoshi
Published: November 2006

This paper deals with design considerations and implementation of a program structuring preprocessor for a macro assembly language. The macro assembly language is used for writing the code generation pass of a compiler. Macro instructions become lengthy, tedious and cumbersome when they incorporate some mild code improvement. This is chiefly because the macro assembly language lacks an adequate program structuring facility. Program structuring is a great help in improving ease of programming and the under‐standability of the expansion control statements of a macro instruction in such a kind of programming. Considerations on the design of the source language and the outline of implementation are described. The design objective is ease of implementation and ease of use, and is fairly well satisfied by the language.
Distributed processing in a small office
Authors: Barton D.
Published: November 2006

The paper describes a small update and enquiry system developed on a PDP11/34 computer and the steps that are required to upgrade this system to a distributed configuration based on microcomputers. The advantages of the distributed approach are discussed and found to be dominant.
Short communication. Improving overlay handlers
Authors: Hansche Brian
Published: November 2006

Code overlay segments are commonly used to implement large program modules on machines with limited address space. Unfortunately, these systems usually impose some limitations on the permissible sequence of subroutine invocations. This paper discusses the reasons for these limitations and introduces a simple change that allows more general invocation sequences to be used.
Introduction to enhanced C (EC)
Authors: Katzenelson Jacob
Published: November 2006

The main goals of EC are to design a set‐oriented, extensible, C‐like language and to build a translator for this language that produces efficient run‐time code.

A set‐oriented language supports higher level data aggregates and operations. In EC these are sets, sequences, tuples, oneofs, and the corresponding operations. Extensibility in EC involves the use of data abstractions to define new types. EC's data abstractions, called clusters, are macro‐like devices that perform substitution on the typed syntax tree. They handle names in a way that prevents name conflicts at substitution time. They also have some novel error reporting properties. Run‐time efficient code is understood as code of the quality expected from a programmer using C.

This paper describes the EC language and, in particular, the data abstractions. The description is by examples and assumes familiarity with C. Conclusions and the experience gained in applying EC are summarized in the last section.
Access path query language for relational database systems
Authors: Patnaik L. M. , Shailendra Phule , Rao K. Venkateswara
Published: November 2006

Database management systems offer a very reliable and attractive data organization for fast and economical information storage and processing for diverse applications. It is much more important that the information should be easily accessible to users with varied backgrounds, professional as well as casual, through a suitable data sublanguage. The language adopted here (APPLE) is one such language for relational database systems and is completely nonprocedural and well suited to users with minimum or no programming background. This is supported by an access path model which permits the user to formulate completely nonprocedural queries expressed solely in terms of attribute names. The data description language (DDL) and data manipulation language (DML) features of APPLE are also discussed. The underlying relational database has been implemented with the help of the DATATRIEVE‐11 utility for record and domain definition which is available on the PDP‐11/35. The package is coded in Pascal and MACRO‐11. Further, most of the limitations of the DATATRIEVE‐11 utility have been eliminated in the interface package.
A software tool for top‐down programming
Authors: Ince Darrel C.
Published: November 2006

Top‐down design and programming methods have become well established in both commercial and academic environments. However, a programmer using such methods faces a number of organizational difficulties. This paper describes a software tool, written in Pascal, which eliminates these difficulties. It allows a programmer to interactively develop programs in a top‐down fashion.
The real‐time debugging monitor for the bell system 1A processor
Authors: Witschorik C. A.
Published: November 2006

Real‐time computer systems can be difficult to test when their timing characteristics influence the occurrence of problems. Because of this, tools for debugging real‐time systems must account for the interference that they produce in the system they are monitoring. The debugging monitor for the Bell System 1A processor is an example of just such a tool. This paper examines the 1A processor debugging monitor, focusing on the division of the monitor into three separate devices: a hardware monitor that allows autonomous debugging; a resident monitoring program that allows debugging with a minimal interference to normal timing; and a separate mini‐computer monitor that offers extended capability at the expense of unrestricted interference.
Implementation of a retrospective tracing facility
Authors: Malone J. R.
Published: November 2006

The implementation of a retrospective trace facility, which produces diagnostics in terms of the original source code language, is described. In its simplest form the mechanism is straightforward to implement, requiring perhaps one man‐month of effort. As the generated object code is bulkier measurements of the expected size increase. Suggestions to reduce code volume have been outlined.
Implementing a simulation tool in a high‐level language with no multitasking facilities
Authors: Cavouras John C.
Published: November 2006

Ways to implement coroutines in a block‐structured language with no multitasking facilities are presented. Coroutines are implemented as procedures. The reactivation points are kept in global variables, one variable for each procedure. Local variables whose values are required on re‐entry are stored as STATIC objects. The variables or data of re‐entrant coroutines are stored in an event list associated with each such coroutine. A procedure with several entries is a convenient mechanism to trap the primitive calls issued by the coroutines. This procedure returns to the master program by using a non‐local GOTO. The implementation of the above in PL/I and C is described and a comparison is made with sequential Pascal. Ada includes constructs which satisfy most requirements.
The effect of scope delimiters on program comprehension
Authors: Sykes Floyd , Tillman Raymond T. , Shneiderman Ben
Published: November 2006

Scope delimiters, such as BEGIN‐END or DO‐END, are used in many programming languages, but they can lengthen and clutter a program listing. This paper provides experimental evidence that ENDIF or ENDWHILE statement terminators make for easier to comprehend programs than BEGIN‐END pairs surrounding compound statements.
Tools: An environment for time‐shared computing and programming
Authors: Ellis John R. , Mishkin Nathaniel , van Leunen Mary‐Claire , Wood Steven R.
Published: November 2006

The Yale Tools environment provides integrated modern computing facilities to a mixed group of programmers and users on time‐shared machines. Hundreds of people use the environment every day for systems and applications programming, word‐processing and university business. The success of the environment is in its integration and engineering detail. Building such a system without a high‐level language and a run‐time library would have been impossible.
On the design of a special‐purpose scientific programming language
Authors: Knight John C. , Dunlop Douglas D.
Published: November 2006

Observations on the design of the special‐purpose scientific programming language SL/1 are presented. SL/1 is intended for applications programming of the Control Data Corporation Cyber 203, a very high‐performance vector processor, which is mainly used for scientific computation. The language design has been heavily influenced by the hardware characteristics of this machine and the needs of the Cyber 203 user community. Various aspects of the design of SL/1 are discussed and measurements of their use are presented. In addition, unexpected similarities between the resulting design of SL/1 and the design of FORTRAN are examined and several reasons for the continued widespread use of FORTRAN are suggested.
The little META translator writing system
Authors: Marti Jed
Published: November 2006

The Little META Translator Writing System is a tool for implementing experimental compilers, interpreters, preprocessors and higher level translator writing systems on a microprocessor. This paper presents the salient features of the system through the implementation of three translators. Some knowledge of LISP is assumed.
A distributed programming assistant
Authors: Ramsay Allan
Published: November 2006

This paper describes an interactive programming environment within which proposed changes to a program are monitored to ensure that they do not introduce various common types of logical inconsistency. The environment, which is provided by a network of concurrent ‘experts’ dealing with various aspects of the program being developed, is designed to be convenient to work in and to impose few constraints on the programmer.
An optimizer for a relational database command language
Authors: West Vincent
Published: November 2006

This paper describes the optimizer included in the ICL personal data system (PDS), an interactive relational database system designed for users with little or no computer experience. The optimizer transforms the selection criteria in a command into an equivalent form which can be used to obey the command more quickly. The optimization method and the factorization procedure it uses are described in detail.
Software tools for first‐order logic
Authors: Cunningham R. James , Zappacosta‐Amboldi Silvana
Published: November 2006

A suite of software tools for the manipulation and validation of first‐order logic expressions is presented. The suite ponsists of a collection of modules, each performing a precise and well‐defined task. More sophisticated tasks such as theorem proving can be achieved by concatenating modules and interacting at suitable stages.
Incremental back‐up procedures
Authors: Williamson J. H.
Published: November 2006

Back‐up and archival storage is safer and quicker if knowledge of the absent files is retained and exploited. The method has been applied to the reconciliation of two active discs, as well as the security back‐up of and retrieval of files from a single disc.
Real‐time BASIC
Authors: Bull Gordon , Lewis Alan
Published: November 2006

A standard for BASIC is nearing completion. An integral part of that standard is a module of the language addressing the needs of real‐time applications. This paper describes the features of real‐time BASIC, highlighting the concurrency aspects, the mechanisms provided for inter‐process communication and synchronization, and for communication with the hardware system. An example showing how the language may be used to control the environment and pump water from a mine shaft is included. The use of the language with a distributed control system is also discussed.
Syntax driven COBOL compilers—an assessment
Authors: Layzell P. J. , Triance J. M.
Published: November 2006

Most syntax analysis phases of COBOL compilers are written as sequences of procedural code instructions each of which validates a particular part of the syntax of a COBOL program. This paper examines the structure of a syntax driven COBOL compiler and a practical implementation is described. The problems encountered with this type of compiler construction are explained, and its advantages are examined. Finally, some other potential applications of syntax driven technology are suggested.
The new mexico state university ring‐star system: A distributed unix environment
Authors: Karshmer Arthur I. , Depree Dirk J. , Phelan James
Published: November 2006

A distributed version of the UNIX operations system is currently under development through a joint effort of New Mexico State University and the Hebrew University of Jerusalem. A microprocessor version of the UNIX kernel has been developed which will run on any PDP‐11 or LSI‐11 based processing element and allows processes to run in a UNIX ‘look‐alike’ environment. Each process is fully transportable among all processors in the system. Although the preliminary version of the system was built in a star configuration, the system is currently being upgraded by the addition of a communication ring with 8‐bit microprocessors as ring interface units. The current paper describes the software structure, the hardware structure and the communication protocol of the system.
A note on space filling curves
Authors: Cole A. J.
Published: November 2006

Recursive procedures for drawing Peano, Hilbert and Sierpinski polygons are discussed. In each case the starting figure is a single point and the procedures clearly reflect the underlying geometry of the construction of the polygons. No assignment is required in any of the procedures.
Perseus: Retrospective on a portable operating system
Authors: Zwaenepoel Willy , Lantz Keith A.
Published: November 2006

We describe the operating system Perseus, developed as part of a study into the issues of computer communications and their impact on operating system and programming language design. Perseus was designed to be portable by virtue of its kernel‐based structure and its implementation in Pascal. In particular, machine‐dependent code is limited to the kernel and most operating systems functions are provided by server processes, running in user mode. Perseus was designed to evolve into a distributed operating system by virtue of its interprocess communication facilities, based on message‐passing. This paper presents an overview of the system and gives an assessment of how far it satisfied its original goals. Specifically, we evaluate its interprocess communication facilities and kernel‐based structure, and discuss its portability. We close with a brief history of the project, pointing out major milestones and stumbling blocks.
Andra: The document preparation system of the personal workstation Lilith
Authors: Gutknecht Jürg , Winiger Werner
Published: November 2006

Andra is a modern text editor and formatter designed for the personal computer Lilith. Lilith was developed at the ETH by Prof. N. Wirth. The interactive part of Andra makes extensive use of Lilith's characteristic features, namely its high‐resolution raster scan display and the mouse. The printer component of Andra allows the creation of high‐quality hardcopies on a laser printer. The Andra program is written in the language Modula‐2.
The design of an interactive program development system for Pascal
Authors: Nordström Bengt , Wikström Åke
Published: November 2006

A program language can be defined as the language in which computer programs are written, and a programming language as the language used by the programmer to create programs. This paper presents the design of an interactive program development system which uses Pascal as both program and programming language. Principal properties of the system are a complete immediate syntax check, a program‐structure oriented editor, incremental compiling techniques, and interactive interpretation and debugging of programs. The syntax check is split into three phases, and the user can change the degree of check wanted. After a change of the program only part of it is recompiled, and only necessary phases of the compiling process are performed.
A semantically‐based formatting discipline for Pascal
Authors: Bailes Paul A. , Salvadori Antonio
Published: November 2006

The abstract (or semantic) syntax of the Pascal language is identified, and a linear representation for the trees so formed within the framework of the concrete syntax for that language is imposed. The indentation scheme so formed, augmented with a small number of pragmatic considerations, is compared with several previously proposed formatting schemes for Pascal and an example of the use of this new method is given.
An interactive data visualization system
Authors: Thalmann Daniel
Published: November 2006

GRAFANA is an interactive program, which allows the user to produce drawings based on data stored on a disk file. The major advantage and originality of the system is that the user can interactively determine the visual effect of a drawing and immediately see it on the screen. Moreover, any drawing produced by GRAFANA can still be edited by a generalpurpose graphics editor. This system allows the user to obtain precisely the right drawing for any book, paper or report.

GRAFANA has been implemented in MIRA‐2D, a graphical Pascal extension. It is available for different machines and kinds of graphical devices.
Preprocessing embedded actions
Authors: Sethi Ravi
Published: November 2006

Some parser generators allow the user to attach actions, consisting of executable code, to syntax rules. Actions are usually in the local programming language, so they are simply copied into the generated parser. However, we show two situations in which it is convenient to allow actions to be in a different notation. A preprocessor is used to translate such notations into the local programming language. A preprocessor must know where to find actions and how to translate them. We show how these two activities can be programmed separately. Often, the user only has to worry about the second part: once the parser generator is known, the placement of the actions is known as well, so routines for finding actions can be separately compiled and linked in. Examples in the paper are based on the parser generator Yacc, but the approach is not limited to Yacc, or even to parser generators. Certain compositions of syntax‐directed translations can be implemented by preprocessing actions.
Allocating computer resources to satisfy user and management demands
Authors: Posch R. , Raring G.
Published: November 2006

The paper deals with strategies to implement comfort classes and with fixed optimization criteria.
A methodology and notation for compiler front end design
Authors: Brown Cynthia A. , Purdom Paul W.
Published: November 2006

A methodology and associated notation for designing compiler front ends, and in particular the interface between the parser and the semantic routines, is described. The methodology leads to a clean, easy to understand, documentable design. The notation is similar to an attribute grammar, but its purpose is to document the first pass of a specific compiler, rather than to describe the semantics of a language. It is designed to be accessible to non‐specialists, easy to learn, and natural. It can be used with or without software support. The notation was used during the development of a large compiler, and to assist in the transfer of the compiler to the group that will maintain it. Experience with the notation indicates that it meets its goals.
Processing variable‐length abbreviations
Authors: Mincy Jeffrey W. , Tharp Alan L.
Published: November 2006

This paper describes a simple technique for processing variable length abbreviations of keywords.
Exception handling—A static approach
Authors: Knudsen Jørgen Lindskov
Published: November 2006

This paper presents a static approach to exception handling. The static approach is proposed as a consequence of an examination of existing language constructs for exception handling in which several trouble spots have been revealed. The static approach consists basically of one concept, namely the sequel concept. Although the sequel concept is sufficient to specify exception handling within a program, one additional concept is introduced, namely the derived definition concept that is introduced as a generalization of the derived type and generic concepts from Ada.

The main advantages of the static approach are first that it is truly static as opposed to the existing language constructs in which dynamic association is used in some way or another; and, secondly, the language constructs for exception handling are simple, easy to implement and based on familiar concepts.
Reference count garbage collection
Authors: Christopher Thomas W.
Published: November 2006

A garbage collection algorithm that permits a reference count storage reclamation scheme to collect circularly linked inaccessible structures is presented. The algorithm requires no additional information beyond that required by a reference count scheme. In particular, it does not require the garbage collector to be able to find pointers outside the heap. The algorithm is most useful for augmenting reference count storage reclamation systems and for implementing storage management systems on top of languages that do not provide their own. It is, however, considerably less efficient in space and time than conventional garbage collection systems.
Exploiting partial order with Quicksort
Authors: Dromey R. Geoff
Published: November 2006

The widely known Quicksort algorithm does not attempt to actively take advantage of partial order in sorting data. A simple change can be made to the Quicksort strategy to give a bestcase performance of n, for ordered data, with a smooth transition to O(n log n) for random data. This algorithm (Transort) matches the performance of Sedgewick's claimed best implementation of Quicksort for random data.
A software development system based on a macroprocessor
Authors: Barcucci Elena , Pelacani Gianluca
Published: November 2006

In this paper a system for software development is described. This system consists of a general‐purpose macroprocessor and a set of service programs. The macroprocessor has been planned to work in a conversational environment and to this purpose a set of utilities has been inserted to aid the editing and the debugging of the macrodefinitions. Indeed the system allows the user to select, by means of commands, the flow of the operations to be executed and to choose when and how any program has to be expanded. The macroprocessor is easy to use and it is suitable to generate codes for both high‐level languages and assembler languages.
Adam: An Ada‐based language for multiprocessing
Authors: Luckham D. C. , Von Henke F. W. , Larsen H. J. , Stevenson D. R.
Published: November 2006

Adam is a high‐level language for parallel processing. It is intended for programming resource scheduling applications, in particular supervisory packages for run‐time scheduling of multiprocessing systems. An important design goal was to provide support for implementation of Ada and its run‐time environment. Adam has been used to implement Ada task supervision and also as a high‐level target language for compilation of Ada tasking.

Adam provides facilities corresponding to the Ada sequential constructs (including subprograms, packages, exceptions, generics). In addition, it provides specialized module constructs for implementation of packages that may be shared between parallel processes, and new predefined types for scheduling. The parallel processing constructs of Adam are more primitive than Ada tasking. Strong restrictions are enforced on the ways in which parallel processes can interact.

A compiler for Adam has been implemented in MacLisp on DEC PDP‐10 computers. Runtime support packages in Adam for scheduling (on a single CPU) and I/O are also provided. The compiler contains a library manipulation facility for separate compilation.

The Adam compiler has been used to build an Ada compiler for most of the July 1980 Ada, including task types and rendezvous constructs. This was achieved by implementing the translation of Ada tasking into Adam parallel processing as a preprocessor to the Adam compiler. This present Ada compiler, which has been operational since December 1980, uses a procedure call implementation of tasking. It can be easily modified to other implementations. Compilation of Ada tasking into a high‐level target language such as Adam facilitates studying questions of correctness and efficiency of various compilation algorithms, and code optimizations specific to tasking, e.g. elimination of unnecessary threads of control.

This paper gives an overview of Adam and examples of its use. Emphasis is placed on the differences from Ada. Experience using Adam to build the experimental Ada system is evaluated. Design of a run‐time supervisor in Adam is discussed in detail.
A standard Pascal event simulation package
Authors: Marsden B. W.
Published: November 2006

A package implemented using standard Pascal is described. It provides the user with basic tools for discrete event‐orientated simulation, and includes facilities for scheduling and causing pending events, handling of LIFO and FIFO queues, control of periodical dumping of statistics and comprehensive initialization and error routines.

Two versions of the package have been implemented, using tree and linked list structures for scheduled events. Their relative performances are compared. The tree structure proves to be more efficient except in the minority of cases where the set of scheduled events has to be searched frequently; it also provides a much more efficient scheduling algorithm than does a linked list structure.

This package is primarily intended as a communication network design tool, and a simple example of this type of usage is included. It could also be used in undergraduate teaching. Coding examples are given for the main procedures, in the two implementations.
PL/I as a discrete event simulation tool
Authors: Hać Anna
Published: November 2006

The programming language PL/I is considered as a most useful and portable discrete event simulation tool. This paper discusses design facilities required in simulation languages, making use of a model described in PL/I. The problem of queues, parallelism and synchronization in a simulator is solved. The structure of the simulator is considered.
Compile—time detection of aliasing in euclid programs
Authors: Cordy James R.
Published: November 2006

Aliasing of variables occurs when two or more identifiers accessible in the same scope refer to the same storage location. When aliasing is present, the meaning of assignments becomes obscure because assignment to one variable identifier may change the value of others. Some of the more obscure kinds of variable aliasing can be the cause of particularly insidious bugs in computer programs. Axiomatic proof systems, such as that used for the Euclid language, assume that no aliasing is present so that the meaning of assignment is clear. For this reason, Euclid requires that no aliasing be present in Euclid programs and requires the compiler to implement checks to ensure this. This paper discusses the features of Euclid that aid in the detection of aliasing. It enumerates the kinds of aliasing that can be present in Euclid programs and gives efficient one‐pass algorithms for compile‐time detection of potential aliases. Aliasing is related to interference between concurrent processes, and a similar algorithm for detection of inter‐process interference in Concurrent Euclid programs is presented.
A general approach to queuing in C.S.P
Authors: Hull M. Elizabeth C. , McKeag R. M.
Published: November 2006

It has been our experience that, when writing software for operating systems, the synchronization techniques available in Communicating Sequential Processes are inconveniently primitive. In this paper we investigate how different types of queue can be represented in C.S.P., and we show how this approach can be developed into a general queuing mechanism.
Taming the PL/I syntax
Authors: Marks B. L.
Published: November 2006

Ideally the syntactic part of a PL/I compiler would be generated directly from the semi‐formal definition of ANSI Standard PL/I. A practical approach to this is described, using finite state machines and an LALR parser generator.

The parser uses a method due to Aoe which avoids list searching. Adapted for this method the PL/I grammar has 841 states. The parse table generator exploits the freedom to renumber states in a way that improves on previous algorithms for compacting the tables. The parser tables occupy less than 4K bytes.
Programs to process trees, representing program structures and data structures
Authors: Wilson Anne D.
Published: November 2006

Utility programs discussed in this paper were initially developed to automate the ‘drawing’ of the non‐binary trees which occur when using a Jackson type methodology for program design; these trees represent either data structures or program structures, showing the selective, sequential and iterative relationships between nodes

First a language was developed to allow information about tree structures to be input to the programs. Techniques and algorithms are described which enabled utility programs to be coded to process this data; transforming it into printable diagrammatic representation of trees; pseudo‐code representation of program trees; and PL/I or Cobol programs

Secondly a merge operation for trees had to be defined, reflecting the step in Warmer's and Jackson's methodologies of combining data tree structures together to provide a program structure. Further algorithms are described which enable this step to be performed automatically, they include checks that each particular merge can be performed

Because the aims and concepts have been fluid some of the ideas have been discarded, and programs have been rewritten. Valuable insights were gained from persuing both the rejected and the acceptable ideas, these are described in this paper.
An Electronic Secretary
Authors: Sommerville I. , Smith D. J.
Published: November 2006

This paper describes an electronic mail system which has been implemented to provide facilities for the receiver as well as the sender of electronic mail. As well as the usual mail creation, transmission and filing operations, the system allows the receiver to specify automatic redirection of mail, and provides classification facilities so that the order of mail presentation is under the receiver's control. The system also includes an automatic mechanism for acknowledging mail and for cancelling mail which is either out‐of‐date or which was sent in error. The model on which the system is based is a non‐automated office, so analogues of waste paper baskets, etc. are provided.