bluuebunny/crossref_metadata_2025 huggingface dataset:
Anatomy of an educational network database system
Authors: Johnson James L.
Published: November 2006

The construction of the systems software necessary to support arbitrary network databases is described. The software consists of two packages. First, there is a data description language compiler, which accepts a conceptual description of an arbitrary network and reduces it to a set of specialized data structures. The second component is a set of data manipulation language access routines, which are callable from an application program to store and retrieve data from the structures. The software is essentially an implementation of the CODASYL proposal, although the treatment of sets has been simplified. The main thrust of the discussion is the representation of nodes and sets of an arbitrary network by certain data structures. The software was written to provide a system on which students could practice database design problems and to illustrate systems programming techniques common in database software.
Resource monitors: A design methodology for operating systems
Authors: Pashtan Ariel , Unger Elizabeth A.
Published: November 2006

Resource manager objects are the operating system entities that manage computer system resources. In this paper we extend Hoare's and Brinch Hansen's monitor concept, and introduce a resource monitor language construct that represents a resource manager object. Resource monitors provide requesting processes with implicit synchronization, and do not require separate processes to perform the resource access operations. The resource monitor construct is compared to current language constructs used to structure operating system software. For this purpose we use an evaluation methodology that combines software complexity measurements with program performance measurements. The evaluation itself is carried out in a Concurrent Pascal‐like programming environment. The current language constructs have a software complexity that is larger by 37 to 219 per cent over the resource monitor's complexity. The run‐time synchronization overhead of programs that use current language constructs is 1.43 to 2.75 times higher than the overhead of programs that use a resource monitor.
A simulator for real‐time software debugging and testing
Authors: Huang J. C. , Ho Melody , Law Ted
Published: November 2006

A software simulator can be built to facilitate debugging and testing of real‐time programs. This paper describes a simulator designed to operate in three modes: simulation, debugging and process monitoring. In the simulation mode, it simulates a Z80‐based microcomputer and can be used to execute programs written in the Z80‐assembler language. In the debugging mode, it provides facilities for interactive debugging on the instruction level. The simulator's unique feature is the process monitoring mode. It displays the activities among processes being executed concurrently under the control of a real‐time executive and thus allowing direct observation of dynamic program behaviour at the process level.
Register allocation and exhaustive peephole optimization
Authors: Davidson Jack W. , Fraser Christopher W.
Published: November 2006

Emerging peephole optimizers can relieve code generators of much case analysis, but delaying code generation decisions requires register allocation algorithms that accept object code instead of the more usual intermediate code. This paper describes two programs that implement such algorithms for a retargetable optimizing compiler. In a machine‐independent fashion, they allocate and assign registers, eliminate common subexpressions (including often‐missed machine‐specific ones), identify dead variables, and define windows for the companion peephole optimizer. Their techniques for handling machine‐specific data should generalize to other optimizations as well.
Experience with remote procedure calls in a real‐time control system
Authors: Carpenter B. E. , Cailliau R.
Published: November 2006

This paper describes several years' practical experience with remote procedure calls as a primary tool for application software in a large and complex distributed real‐time process control system. We motivate the use of remote procedure calls as an effective technique for the use of local area networks, describe our implementation and discuss its advantages and disadvantages.
Compact coding of syntax tables
Authors: Contla Jose Felipe
Published: November 2006

A method for constructing compact syntax tables in three steps is presented. First, the rules of a grammar are mapped into a syntax graph, from which five syntactic forms are defined. Secondly, the grammar expressed in these syntactic forms is mapped into data structures. Finally, from the data structures, the compact syntax table of the grammar is constructed.
Top‐down design within a functional environment
Authors: Leith Philip
Published: November 2006

This paper describes a design tool for use within the INTERLISP1 environment. The design tool, DT, is based upon the design methodology described by the general term, top‐down design and is novel in that it attempts to apply this design method to a functional programming environment. Also novel is the method whereby the generation of the design can occur in parallel with the implementation of the design. This allows a design process more in accord with the needs of functional programmers.
An experiment in language design for distributed systems
Authors: Crookes D. , Elder J. W. G.
Published: November 2006

This paper describes a recent experiment in the design, implementation and application of a programming language designed specifically for distributed systems. The fundamental nature of such systems is used in the derivation of an experimental language, which is described and illustrated. Having outlined an implementation, the project is evaluated and some of the more significant findings are reported. In particular, the paper discusses (and argues for) an explicit language facility for expressing the distribution of a program over an actual system.
Polymorphic programming I. Another language designed on semantic principles
Authors: Harland David M. , Gunn Hamish I. E.
Published: November 2006

We wish to illustrate the potential of a thus far little explored avenue of programming language design–‐namely the employment of types and routines as values in their own right within the framework of an Algol. In this first paper we pay particular attention to the development of highly orthogonal self‐initializing data structures, and to the advantageous expressive power of polymorphism when combined with routine values so as to provide abstract data structures. The emphasis is on the design phase, rather than on the implementation details or precise syntactic structure of the envisaged language. A second, companion paper† discusses the design of a high‐level orthogonal abstract architecture intended to support polymorphic languages in which routines are ‘first class’ values. The relationship of the abstract machine architecture to the programming language vis‐a‐vis the ‘semantic gap’ is then discussed from the viewpoint of compiling programs which are strongly typed while exploiting polymorphism. We feel that polymorphism is essential if truly general purpose programs, software tools, are to be written easily. The research reported herein is an effort towards realizing this goal.
A hierarchical exception handler binding mechanism
Authors: Nackman Lee R. , Taylor Russell H.
Published: November 2006

A mechanism is proposed for binding exception handlers to exceptions. Hierarchical exception classes can be defined and changed during program execution. In addition, the action taken when an exception of a particular class is raised depends upon the type of the current exception handler for that class. The mechanism can be implemented in programming languages that allow runtime determination of an identifier's binding; most dynamically scoped programming languages meet this criterion.
Polymorphic programming II. An orthogonal tagged high level architecture abstract machine
Authors: Gunn Hamish I. E. , Harlan David M.
Published: November 2006

This paper describes the implementation of a very powerful high level language from the standpoint of those features rarely found in other languages. These are constancy, polymorphism, user‐defined types, orthogonal data structures, and field selectors and routines as assignable values. It examines the characteristics of these features in order to show how they are implemented. They greatly influence the architecture of the underlying abstract machine which is described. Finally the paper highlights several important instructions such as those for routine calling and data structure management. It also shows how the list as a data type in a language can be exploited in the implementation of assignment and parameter passing.
Concurrent C: A programming language for distributed multiprocessor systems
Authors: Tsujino Y. , Ando M. , Araki T. , Tokura N.
Published: November 2006

Recent advances in hardware technology have made the construction of multiprocessor systems economically feasible. This paper describes a new programming language (Concurrent C) suitable for distributed systems which are networks of loosely connected processors, each with its own local storage. Concurrent C is the extended version of the programming language C, incorporating features for parallel processing and interprocess communications.
Dedicated, distributed and portable operating systems: A structuring concept
Authors: Valdorf G.
Published: November 2006

Primarily economic reasons have created a growing need for the development of operating systems providing support for existing and newly developed structurally different hardware systems–‐operating systems which

(a) implement functionally different problem‐oriented solutions without imposing the need of developing problem‐invariant functions repeatedly (‘operating system family’)

(b) work not only in a local environment, but also co‐operate with one another in an interconnected hardware system, thus appearing to the user as only one big operating system

(c) are portable among structurally different hardware systems independent of one another (‘autonomous systems’), as well as among structurally different interconnected hardware systems (‘networks’)

We present some principles of a structuring concept which seems to be a suitable means of developing operating systems with the specified characteristics in an economic and controlled manner.
A language independent error recovery method for LL(1) parsers
Authors: Spenke Michael , Muhlenbein Heinz , Mevenkamp Monika , Mattern Friedemann , Beilken Christian
Published: November 2006

An efficient and systematic LL(1) error recovery method is presented that has been implemented for an LL(1) parser generator. Error messages which provide good diagnostic information are generated automatically. Error correction is done by discarding some input symbols and popping up some symbols from the parsing‐stack in order to restore the parser to a valid configuration. Thus, symbol deletions and insertions are simulated. The choice between different possible corrections is made by comparing the cost of the inserted (popped) symbols with the reliability value of the recovery symbol (the first input symbol that is not discarded). Our concept of reliability is based on the observation that input symbols differ from each other in their ability to serve as recovery points. A high reliability value of a symbol asserts that it was probably not placed in the input by accident. So it is reasonable not to discard that symbol but to resume parsing. This is done even if a string with high insert‐cost has to be inserted before that symbol in order to fit it to the part of the program that has already been analysed. The error recovery routine is invoked only when an error is detected. Thus, there is no additional time required for parsing correct programs. Error‐correcting parsers for different languages, including Pascal, have been generated. Some experimental results are summarized.
QS: A tool for general data input
Authors: Dewey M. E.
Published: November 2006

This paper describes QS, a program which inputs data in a very general format. QS interprets a script, which contains text to be used to prompt the user, and commands which collect the data from the user. This apparently simple description hides an idea of great power, and in this paper examples are provided of the use of the program in three areas. (1) A system for producing questionnaires and psychiatric interview schedules relies on the program to provide a data validation system which is automatically updated to keep pace with changes to the schedules. (2) The program provides a general purpose patient interviewing package. Most current systems are specific to a particular interview, but new interviews can be administered by QS simply by changing the script, which is much simpler than writing a new program. (3) The program also provides a means of presenting multiple choice self assessment examinations, or programmed instruction to students. Again any set of questions can be set, just by writing a new script

The design of the program is discussed with reference to the criteria of simplicity, ease of writing and maximum recycling of existing software. The advantages of the tools approach to software design are stressed.
The starmod distributed programming kernel
Authors: Leblanc Thomas J. , Gerber Robert H. , Cook Robert P.
Published: November 2006

This paper describes the design and implementation of a kernel for the distributed programming language StarMod. The distributed programming kernel was written in a subset of StarMod supported by a concurrent programming kernel. Kernel issues addressed include process representation, I/O device management, signal semantics, system utilities, network communication and the implementation of high‐level language communication primitives. We conclude with a summary of our experiences in the development of a ‘bare machine’ kernel for a network of microprocessors.
P/CL: A flexible input processor
Authors: Arciszewski H. F. R. , Van Gasteren E. M.
Published: November 2006

An interactive program inevitably has a need for a user interface which exceeds the simple combination of a write and a read statement. This is necessary to prevent a program abort due to an input error from the side of the user. Also it is desirable to allow for more advanced types of input than single characters or numbers. For these reasons a general‐purpose input package has been developed which allows for sophisticated command‐driven programs while offering the programmer as well as the user an easy‐to‐use interface. The structure of the package is described and examples of its use are given.
Avoiding trickle‐down recompilation in the Mary2 implementation
Authors: Rain Mark
Published: November 2006

Programming languages which support separate but not independent compilation are prone to a problem called trickle‐down recompilation. These languages, which include Ada, Modula and others as well as Mary2,1 permit a compilation unit to refer at compile time to objects declared in another, imported, compilation unit. When the exporting compilation unit is recompiled for any reason, its exported interface may change, and so the importing compilation units which are the clients of that interface must be recompiled. These recompilations in turn force others, and so on

Many recompilations are in fact innocuous, in that they may change the run‐time behaviour of the recompiled unit but do not alter the exported interface. This paper describes the implementation of that portion of the Mary2 language system which performs just those recompilations actually necessary and avoids redundant recompilations. The methods described are applicable to the implementation of any other language which enforces version control across compilations.
A source code control system based on semantic nets
Authors: Ince D. C.
Published: November 2006

A major problem facing the developers of large pieces of software is source code version control. This paper describes how semantic nets can model this process and how a semantic net processor can be used to construct a flexible and portable source code control system.
Operating system support for sharing writable control store
Authors: Winner R. I. , Reed L. B.
Published: November 2006

The design of a portable, production‐quality dynamic microprogramming system is given. The system is an extension to UNIX; it allows multiple users easily to time‐share the writable control store on a Perkin‐Elmer 3220. Each process may have its own microcode support, known as a microimage; processes may share microimages. Microimages are managed either in an optional software cache in kernel memory or in user memory where they are subject to secondary memory swapping. The physical loading of the WCS is accomplished in on‐demand fashion in the sense that only the first attempt to enter control store during a given scheduling quantum can cause a WCS fault. Users are prevented from erroneously entering control store by separate management of the control store entry points. The paper provides sufficient detail to allow other UNIX and similar systems to adopt this approach. Performance effects of WCS contention add from about 0.5 to 1 per cent overhead to the jobs, and the use of vertical migration has improved job run times up to 50 percent. This system has been in use for over a year and provides the main support for ongoing research into vertical migration.
Forced termination of loops
Authors: Dromey R. Geoff
Published: November 2006

Loops must often be forced to terminate early. Solutions to such problems are usually either language‐dependent or rather clumsy. A practical alternative is presented. The accompanying methodology clarifies the role of the finalization mechanism in loop construction. It also leads to the idea of control‐structure independence in the context of data representation and forced termination.
On implicit data structures for priority queues
Authors: Perko A.
Published: November 2006

Certain implicit data structures for priority queues are implemented and compared with a simple linked structure. Timing experiments show that implicit structures are rather slow.
An interactive assembly level debugging system
Authors: Panchapakesan S. , Subramanian S. , Venkateswaran H.
Published: November 2006

An interactive assembly level debugging system has been developed to facilitate program development on an INTEL 8080A/8085 based microcomputer. It has features such as decoding machine level instructions into the assembly language, relocating programs in memory, changing instructions interactively at assembly level etc. This paper deals with the design of the assembly level debugging system and the various facilities and features it provides. The debugging system requires only 4.5K bytes of RAM besides the memory requirements of the application program that has to be debugged.
The NMFECC cray time‐sharing system
Authors: Fong Kirby W.
Published: November 2006

The National Magnetic Fusion Energy Computer Center (NMFECC) at the Lawrence Livermore National Laboratory (LLNL) has implemented a simple, yet powerful interactive operating system, the Cray Time‐Sharing System (CTSS), on a Cray‐1 supercomputer. CTSS augments the multi‐programming batch facilities normally found in supercomputer systems with many of the interactive services typical of interactive minicomputer systems. This paper gives some of the historical background leading to CTSS and gives an overview of the system that emphasizes the strong points or unusual features such as multiple channels, decentralized control of resources, priorities and program scheduling, system recovery, and on‐line documentation.
A survey of systems programming languages: Concepts and facilities
Authors: Appelbe William F. , Hansen Klaus
Published: November 2006

In recent years, high‐level programming languages have evolved specifically for systems programming. In this paper, systems programming languages are surveyed to find common characteristics and individual differences and limitations of a number of current languages, including Ada, Concurrent Pascal, CLU, Pascal‐Plus, Modula‐2, Mesa, Edison, PLZ/SYS and C. The survey is based on the following classification of systems programming concepts and facilities: types, sequential control, concurrency, encapsulation, environment specifications and programming support environments.
A flexible software character generator
Authors: Gujar Uday G. , So Frank W. L.
Published: November 2006

This paper describes a general and flexible character generator which is capable of producing virtually an unlimited number of character founts. To demonstrate this flexibility, eight different founts, ranging from Roman letters and symbols, double line letters, APL characters etc. to a Devanagari script have been generated. These founts have been chosen to see how characters with wide ranging requirements can be generated.

Each of the founts can be manipulated in a variety of different ways. The user can display a desired character string, with specified height and width, anywhere on the display device with any inclination, each character in the string having a desired orientation. Moreover, various other transformations, such as stretch, fall and skew, can be applied to the string. Mathematical formulae for all the transformations are included. The system is described both from the user's as well as system programmer's point of view.

Several examples illustrating the ease of use and the flexibility of the system are given.
Optimization of expression syntax: An experimental approach
Authors: Bertsch E.
Published: November 2006

Several alternative ways of defining the syntax of expressions in Pascal are compared. Based on experimental observations, measures of syntactic efficiency are calculated for each variant of the syntax. An optimal variant is determined for each such measure.
Portable real‐time software for 8‐bit microprocessors
Authors: Saxena S. , Field J. A.
Published: November 2006

This paper discusses a method for developing efficient and portable software for 8‐bit microprocessors used in real‐time applications. The technique used is to design an ‘intermediate level language’ (ILL) which defines low‐level primitives to support the real‐time application programming and the constructs of high level languages. Thus, the high level language (HLL) program goes through two stages of translation; first to the ILL code and then to the machine code of a microprocessor. The ILL instruction set developed bridges the gap between high level languages and the poor instruction set of microprocessors. This allows the development of optimized and portable code for the microprocessors. The ILL operations, data types, data organization, control structures, synchronization, communication and multi‐tasking facilities are described. The effectiveness of this technique is shown by comparing the code generated by the ILL approach with the code available for a sample real‐time application written directly in assembly level language.
Developing ada programs using the vienna development method (VDM)
Authors: Jackson M. I.
Published: November 2006

A method is presented for the systematic development of sequential Ada programs using the Vienna Development Method (VDM). The approach is based upon using the facilities of Ada for supporting parameterized abstract data types to implement the primitives of the VDM specification language. More experimental work is required to assess the utility of the method, but a systematic approach is promised for using features of Ada unfamiliar to most programmers (e.g. packages, generics and exceptions).

Familiarity with Ada is assumed. An overview of VDM is presented so that unfamiliar readers can understand the example given in the paper.
Writing portable fortran programs for microcomputers
Authors: Onibere E. A.
Published: November 2006

This paper is concerned with choosing a subset of FORTRAN which will make it possible to write portable programs on medium‐sized microcomputers.

To achieve this, some restrictions are placed on ANSI 1966 Standard FORTRAN after studying and analysing a collection of FORTRAN manuals for medium‐sized microcomputers. Some assumptions are made concerning machine dependent constants after a careful observation. By combining these restrictions with those made in compatible Fortran1 and making use of the assumptions, portable programs can be written.
Foam: A two‐level approach to text formatting on a microcomputer system
Authors: Ganzinger Harald , Willmertinger Walter
Published: November 2006

This paper describes the design and implementation of the FOAM text formatting system. FOAM runs on an 8085 microprocessor system under CP/M and produces output on Diablo printers. The main feature of the system is that it supports two levels of formatting. On a meta level, the system accepts descriptions of text and document classes together with formatting styles for text components. From the description, a specific instance of a formatter is generated. This formatter, then, on the text level accepts the input of a text of the described class and produces a formatted document as specified by the formatting styles.
Network management in a local computer network
Authors: Nakamura Tomoo , Ikeda Katsuo , Ebihara Yoshihiko , Nishikawa Masafumi
Published: November 2006

The functions and structure of the network management subsystem of the GAMMA‐NET, a local computer network at the University of Tsukuba, are presented. The network management subsystem is an integrated subsystem that offers a convenient man‐machine interface for the network users during the execution of required jobs, and levels the workload throughout the system, as well as managing the network operations.
Run‐time diagnostics in pascal
Authors: White N. H. , Bennett K. H.
Published: November 2006

A compiler maps abstract data and control structures into equivalent representations at the order code level of a computer. When a program written in a high level language fails, there is presented the problem of interpreting the state of the abstract (high level) machine in terms of the state of the physical machine which is all that is available. This interpretation is undertaken by a program usually known as a run‐time diagnostics package. In this paper a novel package is described which provides diagnostics for dynamically created data structures in addition to the usual facilities. It has been implemented for the language Pascal and has been used successfully for 18 months.
Newlong: A program for manipulation of data on populations of individuals subject to change
Authors: Carter B. S.
Published: November 2006

In longitudinal studies subjects are measured from time to time at examinations. The subjects have some data, such as birth date, which do not change between the examination occasions. The bulk of the data are values, of variables such as height, which are taken at the examinations. The essence of these longitudinal studies is found in the change from one exam to the next. A program is described which will derive values from this type of data structure and produce summary statistics. Values can be sent to BCD files for printing or further analysis.
A low‐cost implementation of coroutines for C
Authors: Bailes Paul A.
Published: November 2006

We identify a set of primitive operations supporting coroutines, and demonstrate their usefulness. We then address their implementation in C according to a set of criteria aimed at maintaining simplicity, and achieve a satisfactory compromise between it and effectiveness. Our package for the PDP‐11 under UNIX† allows users of coroutines in C programs to gain access to the primitives via an included definitions file and an object library; no penalty is imposed upon non‐coroutine users.
Topic libraries for mathematical computation
Authors: Cox M. G.
Published: November 2006

This paper describes software engineering aspects and the scope of three subroutine libraries developed at the U.K. National Physical Laboratory (NPL). The libraries are concerned with three important fields of mathematical computation: data approximation, linear algebra and optimization. A portable subset of Fortran was used in the construction of these libraries, which have a highly modular structure and are supported by full user documentation.

Reference is made to Microtext, an NPL software product for displaying structured information. Its value in respect of the subroutine libraries lies in its ability to assist the user in selecting appropriate subroutines for the solution of his problem.
Software for an air pollution measuring system: An application of modula
Authors: Dubery J. M. , Pinches A. J.
Published: November 2006

The program for a small embedded computer system has been implemented in Modula. The execution speed of this program was particularly important and the speed achieved was adequate. Some parts of this program are described using a notation derived from the Mascot approach. The use of the Mascot notation with a module‐structured language is discussed and some suggestions for an appropriate style are made. Some simple optimizations of the program were made in order to achieve increased execution speed and it was observed that the final program ran at about twenty times the rate of an equivalent Fortran program. Some points on the suitability of Modula are briefly discussed and, in a similar way to previous authors, it is concluded that Modula is suitable for applications of this type.
Analysis and design for a standard transport protocol
Authors: Garratt P. W. , Michaelson G. G.
Published: November 2006

In the development of computer networks, the trend towards open systems interconnection is creating the need for standard protocols. The transport level protocols published by ECMA and ISO are supported by the Department of Industry as ‘intercept’ standards to be adopted by the computing community as a whole. This paper presents the published standards interpreted as a set of state transition diagrams. This reinterpretation is a necessary prerequisite to the method of implementation which is based on a finite state automaton. We summarize the advantages of a software ‘funnel machine’ to effect the state transitions during the execution of the transport protocol server. The same analysis and design technique has been used successfully to implement network and link protocol handlers. We recommend its adoption on a variety of machines in any programming language to ensure a relatively short development period and to achieve compatability among the different classes: 0, 1, 2, 3 and 4, of the transport protocol.
Unisex: A unix‐based symbolic executor for pascal
Authors: Kemmerer Richard A. , Eckmann Steven T.
Published: November 2006

UNISEX is a UNIX‐based symbolic executor for Pascal. The UNISEX system provides an environment for both testing and formally verifying Pascal programs. The system supports a large subset of Pascal, runs on UNIX and provides the user with a variety of debugging features to help in the difficult task of program validation. This paper contains a brief introduction to symbolic execution, followed by an overview of the features of UNISEX, a discussion of the UNISEX Pascal language, and some of the implementation details for the UNISEX system. Finally, some of the problems encountered when designing and implementing the system are discussed as well as future directions.
ISDMS—a scientific data management system
Authors: Bruestle H. R. , Snider D. M. , Russell K. D. , Stewart H. D.
Published: November 2006

This paper describes the design and development of the Idaho National Engineering Laboratory Scientific Data Mangement System (ISDMS). The ISDMS is an integrated system providing organization, processing, control and retrieval of scientific time series data in a large laboratory environment using Control Data Corporation (CDC) computers. Data reformatting, graphics, data manipulation, data management, engineering analysis and general utility functions are offered to engineers, scientists, and other end users. The ISDMS usage has grown steadily since its first release into production status in early 1979. The current configuration is well received by the user community and meets most requirements for studying and analysing data in a scientific environment.
Sre—a syntax recognizing editor
Authors: Budinsky Frank J. , Holt Richard C. , Zaky Safwat G.
Published: November 2006

This paper presents a syntax‐directed editor dubbed SRE, for syntax recognizing editor. Unlike other syntax‐directed editors, SRE enables the user to edit programs with nearly the same natural and unrestrictive ease as a conventional text editor. In addition, it helps identify syntax errors and many typing errors before leaving the editor and attempting to compile a program. Programs are also formatted during entry, thereby providing immediate visual feedback of the recognized structure. The editor replaces the scanner/parser pass of a conventional compiler and thus reduces compilation time substantially.
Automating the selection of code templates
Authors: Horspool R. Nigel , Scheunemann André
Published: November 2006

A new methodology for code generation in compilers is advanced. The underlying principle is a simple one—that machine memory resources must be matched to intermediate code values. It is possible to view the methodology as a generalization of the Graham‐Glanville approach, but where there is a wider‐ranging search for the best code sequences. This new approach has been implemented for the IBM/370, the VAX‐11 and the Intel 8086 instruction sets.
A debugger for concurrent programs
Authors: Gait Jason
Published: November 2006

This paper reports on an experimental debugger for concurrent programs. Design objectives include a showing of greatest usefulness when dealing with multiprocess interactions, creation of a simplified more approachable interface for programmers, allowance for the systematic organization (and limitation) of debugging information by programmers, reflection of a natural view of concurrency, and portability. The design responds to a perceived need for debugging techniques applicable in systems of concurrent, communicating, asynchronous processes. During debugging sessions, a user is able to dynamically explore interprocess synchronization points, parallel actions and deadlock situations. The programmer interface is based on a transparent window multiplexer providing a set of windows for each concurrent process. The window manager interactively maps interesting windows to programmer‐specified viewscreen locations, while relegating temporarily uninteresting windows to the background. In implementing a debugger for concurrent programs, a principal concern is the probe effect, or the possibility that the debugger itself masks synchronization errors in the program being debugged. For the examples explored, the probe effect was not observed to limit the localization of implanted synchronization errors.
Ada's derived types and units of measure
Authors: Gehani N. H.
Published: November 2006

Types in programming languages cannot model many properties of real world objects and quantities. Consequently, many errors resulting from the inconsistent usage of program objects representing real world objects and quantities cannot be detected automatically. For example, the real variables PRICE and WEIGHT, representing the price of diesel fuel and the weight of a person, may be inadvertently added, giving a non‐sensical value; such an error cannot be detected by a compiler. The programming language Ada introduces the concept ofderivedtypes to tackle this problem. An alternative solution to this problem is the incorporation ofunits of measureas a new data attribute. Derived types only partially solve the problem of detecting the inconsistent usage of objects; some valid usages of objects are also not allowed. Moreover, the solution is inelegant and inconvenient to use. On the other hand, specification of units of measure solves the problem elegantly and conveniently. The two solutions are compared and analysed. Several ways to implement units of measure in Ada are examined.
On squeezing the unix quart into a data general eclipse pint pot
Authors: Cooper R. E. M.
Published: November 2006

UNIX has become widely accepted as an efficient, highly flexible operating system for a wide range of computers. It is viewed as being portable because much of it is written in a high‐level language, but transporting it to machines other than its original host is not a trivial procedure. This paper describes the design decisions necessary in moving UNIX to the Data General Eclipse range of minicomputers, and some of the difficulties that arose because of the limited address space on these processors.
A program design language based software maintenance tool
Authors: Ince D. C.
Published: November 2006

Program design languages are an increasingly important method of expressing the detailed design of a software system. Such languages can be modelled using a data structure known as a semantic net. This paper describes a maintenance tool for program design languages based on such a data structure. The tool allows the user to interrogate a semantic net using an interactive procedural language in order to derive information necessary for software maintenance. The technique upon which this tool is based is applicable to the maintenance of activities throughout the software lifecycle.
The university of salford lisp/prolog system
Authors: Bailey D.
Published: November 2006

This paper describes a joint implementation of the LISP and PROLOG languages (with the emphasis in this paper on the latter) for the PRIME range of mini‐computers. Both languages may be compiled or interpreted as required. Several novel techniques for PROLOG compilation are discussed.
Handin — a system for helping with the teaching of programming
Authors: Cowling A. J. , McGregor J. J.
Published: November 2006

A system has been implemented that enables students on a programming course to hand in programs for assessment without the need for printed listings to be generated. The system test runs all submitted programs using standard sets of data, and then facilitates the marking of these programs by the staff teaching the course. The implementation of this system is described, and the experience gained from using it is discussed.
Rcs — a system for version control
Authors: Tichy Walter F.
Published: November 2006

An important problem in program development and maintenance is version control, i.e. the task of keeping a software system consisting of many versions and configurations well organized. The Revision Control System (RCS) is a software tool that assists with that task. RCS manages revisions of text documents, in particular source programs, documentation, and test data. It automates the storing, retrieval, logging and identification of revisions, and it provides selection mechanisms for composing configurations. This paper introduces basic version control concepts and discusses the practice of version control using RCS. For conserving space, RCS stores deltas, i.e. differences between successive revisions. Several delta storage methods are discussed. Usage statistics show that RCS's delta method is space and time efficient. The paper concludes with a detailed survey of version control tools.
Implementation techniques for prolog databases
Authors: Clocksin W. F.
Published: November 2006

All clauses comprising a Prolog program are stored in a database from which they can be removed later. Other long‐term data structures are represented as clauses and are also stored and removed from the same database. Implementation techniques for the manipulation of clauses are not well known, and a lack of information has led to incorrect and incomplete implementations. Further previously unresolved issues are apparent when considering the storage of compiled clauses. We describe the way database manipulations are performed in Prolog‐X, a new compiler‐based Prolog system. We also introduce a new technique for storing the source form of compiled clauses.
Dynamic storage allocation: Experiments using the c language
Authors: Gai Silvano , Mezzalama Marco
Published: November 2006

The paper discusses the problem of dynamic storage allocation (DSA) using C in a VMS environment. The problem is studied in a specific context, i.e. fault simulation of logic circuits. However, owing to its intrinsic generality, the adopted solution can be effectively applied to a large number of similar situations. It is shown how the use of standard C‐functions for dynamic memory allocation result unacceptable for efficiency reasons and different implementation strategies to solve the problem are presented.
Experiences with writing library software for an attached processor
Authors: Pryce J. D.
Published: November 2006

The Floating Point Systems AP120B attached processor (AP) offers a Fortran system which is aimed at making the machine an easy‐to‐use, low‐cost ‘number cruncher’. We report on experience of writing library mathematical software for a PRIME system with an AP120B. An ordinary differential equation code was chosen because it exemplifies a common requirement: the user supplies a subroutine that, on an AP system, forms part of the code executing on the AP. This turned out to be hard to organize conveniently on this system. We discuss the program design, and the deficiencies of the AP120B system that make it less promising than it appears for general scientific computation, and make suggestions concerning the design and implementation of the support software for attached processors.
Management of block‐structured programs
Authors: Marsland T. A.
Published: November 2006

Experience with a technique for compiling subsets of the procedural elements of AlgolW programs is described. The method does not require modifications to the compiler, but does presume the existence of a random access file system. Complete management of the user's source and object files is provided by supplementary directory and environment files. Because of its nature, the basic method should be equally applicable to other block‐structured languages, such as Pascal, which also require recompilation of the whole program whenever a small change is made.
Mos: A multicomputer distributed operating system
Authors: Barak Amnon , Litman Ami
Published: November 2006

This paper describes the goals and the internal structure of MOS, a Multicomputer distributed Operating System. MOS is a general‐purpose time‐sharing operating system which makes a cluster of loosely connected independent homogeneous computers behave as a single‐machine UNIX system. The main goals of the system include network transparency, decentralized control, site autonomy and dynamic process migration. The main objective in the design of the system was to reduce the complexity of the system, while maintaining good performance. The internal structure of the system can be characterized by modularity, a high degree of information hiding, hierarchical organization and remote procedure calls.
Software concurrency in real time control systems: A software nucleus
Authors: Sears Ken H. , Middleditch Alan E.
Published: November 2006

This paper gives the rationale for the design of a nucleus to support real time control applications. In particular, mechanisms for communication between concurrent tasks are reviewed and analysed in the context of this application area. Finally, although no implementation is discussed in detail, techniques which have proved useful in implementing this nucleus on three different machines are described.
A general character to integer conversion method
Authors: Parker J. R.
Published: November 2006

Most programs which involve character to integer conversion fail to detect integer overflow correctly. This paper describes some of the pitfalls of not recognizing overflow, and presents a correct method for doing so in an arbitrary base for any precision.
A VLSI interactive layout editor (VILE)
Authors: Allen G. H. , Perry S.
Published: November 2006

A description of an interactive geometric editor for the layout of very large scale NMOS integrated circuits is presented. The implementation of the VLSI Interactive Layout Editor (VILE) using an HP2648A Graphics Terminal connected to a mainframe computer is described. The command language for the user‐computer interface is described, and to demonstrate the use of the editor an example of an integrated circuit layout is documented.
Yacc in sasl — an exercise in functional programming
Authors: Jones Simon L. Peyton
Published: November 2006

Among the advantages claimed for a purely functional programming style is ease of designing and implementing large programs. However, little experience of actually doing so has been gained so far. The experience of writing a particular medium sized program in a functional language is described here, with particular emphasis on the differences in programming style that were appropriate. This is compared with the experience of writing a very similar program in an imperative language. The main conclusions appear to be that the functional version was significantly easier to write, and was considerably smaller, though not by as large a factor as is sometimes claimed; that strong typing is, if anything, more desirable than in imperative systems; and that the question of debugging functional programs needs further research attention.
A comparison of the ANSI and ISO Pascal Standards
Authors: Tennent R. D.
Published: November 2006

We compare the American and international standards for Pascal and make suggestions to help implementors and programmers achieve the greatest possible compatibility with both standards.
Towards a language for concurrent processes
Authors: Harland David M.
Published: November 2006

In this paper we shall discuss concurrency in programming languages, with a view towards designing a process‐oriented language which, by its inherent parallelism, is well suited to exploit the forthcoming generation of distributed processor networks.

We shall start by discussing the traditional approach towards managing concurrency, with ‘monitors’ co‐ordinating the interactions of ‘processes’, and shall demonstrate that this approach actually degrades concurrency by imposing sequentiality during interactions because it is based on the premise of co‐ordinating secure access to shared resources. As a tool for interprocess communication it is felt that the ‘monitor’ is too far removed from the abstract nature of the problem, and so, as a purely engineering solution, it imposes too broad and too prolonged an exclusion to be acceptable in general.

Instead we turn to a simpler, and ultimately more powerful notion of ‘message passing’ between parallel processes. We shall show how, if the message system is polymorphic, any data value, however large it is, can pass freely between any pair of processes. By making the processes themselves values in the language we shall discover that message networks can come into being dynamically, and tailor themselves to their applications as and when necessary by ‘short‐circuiting’ extensive communications paths. We shall also see how, if the message system is inherently asynchronous, the degree of the parallelism in a system can be enhanced, not degraded, as more and elaborate communications paths develop, the only sequentiality in the system as a whole being imposed by synchronizing processes, not the message passing system itself.

After discussing the various built‐in system facilities that permit processes to dynamically find out about and study one another, thus permitting processes to set up and thereafter supervise whole subsystems, we shall round off by discussing the advantages of introducing the machines themselves into the language, making it possible for processes to become aware of, and then ‘migrate’ within, the topological structure of a multi‐processor distributed network, moving closer to their application, or just to a less‐loaded processor, as the need arises.

To conclude we shall contrast this new‐style process‐oriented language with various existing programming languages which have experimented with concurrency, either implicitly or explicitly, in order to see if, and if so how, this new style is any simpler and more powerful than its precursors.