bluuebunny/crossref_metadata_2025 huggingface dataset:
Addressing types and objects in Ada
Authors: Van katwijk J.
Published: November 2006

In this paper a new model is presented for the run‐time description of arrays, records, and other data types in Ada*‐like programming languanges. The model has several advantages over the classical implementation model using dope vectors. It has been used for the run‐time description of data strutures in an implementation of almost the whole Ada programming languange.

First an outline of our data description model is presented, then issues in addressing components of composite objects are discussed. A practical approach to implement the model is discussed next and finally an example is given and some conclusions are drawn.
Operating‐system enhancements for a faulttolerant dual‐processor structure for the control of an industrial process
Authors: Weber Manfred
Published: November 2006

A dual processor structure and operating system enhancements are described. These permit the construction, from available minicomputers, of a fualt‐tolerant system for the control of an industrial process.
The design of a terminal independent package
Authors: Thimbleby Harold
Published: November 2006

Chareacter‐mapped display terminals very considerably. TIP is a Terminal Independent Package which conceals the details of efficiently handling terminal protocols from applications programs. There is a conflict between the ability to handle esoteric terminal features and providing a uniform programmer's interface for all terminals. This paper discusses the conflicts and the design approch which resolved them.
Making form follow function: An exercise in functional programming style
Authors: Fairbairn Jon
Published: November 2006

The combined use of user‐defined infix operators and higher order functions allows the programmer to invent new control structures tailored to a particular problem area.

This paper is to suggest that such a combination has beneficial effects on the ease of both writing and reading programs, and hence can increase programmer productivity. As an example, a parser for a simple language is presented in this style. The compactness of this parser and its notational similarity to the BNF of the language are important advantages of the approach taken.

It is hoped that the presentation will be palatable to people unfamiliar with the concepts of functional programming.
Multiple stack performance near saturation
Authors: Munakata Toshinori , Yeh D. Yun
Published: November 2006

Detailed simulation experiments have been performed to study multiple stack performance, primarily using two methods recently developed by the authors called dynamic initial allocation and local reallocation procedures. Some results are: determining first occurrences of overflows in terms of storage saturation; observing performance behaviours, particularly for near full storage saturation; and performance evaluation on the weight of two storage redistribution schemes, one being based on the most recent stack growth, the other on the current stack size. Also discussed is the issue of whether additional space should be sought when storage is near saturation, and if so, how it is to be obtained. The critical stack saturation percentage is proposed as the point where additional storage space should be sought. It is the one at which the expected total cost is the minimum.
Generalizations of the sethi‐ullman algorithm for register allocation
Authors: Appel Andrew W. , Supowit Kenneth J.
Published: November 2006

The Sethi‐Ullman algorithm for register allocation finds an optimal ordering of a computation tree. Two simple generalizations of the algorithm increase its applicability without significantly increasing its cost.
Generating reversible programs
Authors: Briggs J. S.
Published: November 2006

This paper describes the production of a system to control an electronic cricket scoreboard. The main feature of the system is the ability of the operator to ‘undo’ operations that he has performed, in order to correct errors that has has made. Undo is implemented by reversing the execution of the program. The code to perform the reversal is generated automatically and results in a minimal amount of state information being recorderded.
One‐pass compilation at its limits — A modula‐2 compiler for the xerox dragon computer
Authors: Gutknecht Juerg
Published: November 2006

We present conceptual and implementation aspects of a one‐pass Modula‐2 compiler that was developed by Xerox PARC's future Dragon workstation. Dragon features several architectural innovations. Among them are a reduced instruction set and a stack of fast registers used to store local data.

This paper emphasizes problems and solutions connected with one‐pass compilation. Although a little out of fashion at present, this simple method, if appropriately applied, turns out to be surprisingly powerful.
Flexible symbol table structures for compiling C++
Authors: Dewhurst Stephen C.
Published: November 2006

Although the C++ programming language is derived from C, it has a fundamentally different formulation of scope. This paper describes the scope structure of C++ and outlines approaches to two of C++'s special translation problems: representing scope in the symbol table and determining destructor activation sequences on scope exit. The solutions presented are based on the operational view of scope in C++ as a collection of interrelated scope objects.
The use of colour in language syntax analysis
Authors: Reynolds C. F.
Published: November 2006

The use of colour to reflect the syntax of typed‐in language statements can make a language processor much more user‐friendly. This paper shows how colour has been used in MicroCODIL and suggests ways in which the approach could be applied to other systems.
Register allocation in a pattern matching code generator
Authors: Van Biljon W. R. , Sewry D. A. , Mulders M. A.
Published: November 2006

Register allocation in a pattern‐matching code generator is discussed, and a strategy for the allocation of registers is presented. The strategy is suitable for code generators that perform no data‐flow analysis, but do perform common subexpression analysis. An implementation of the strategy has produced high quality code.
On the efficiency of categorical combinators as a rewriting system
Authors: Lins R. D.
Published: November 2006

Categorical combinators form a formal system similar to Curry's combinatory logic. The original system was developed by Curien, inspired by the equivalence of the theories of typed λ‐calculus and Cartesian closed categories, as shown by Lambek and Scott. A new system for categorical combinators was introduced by the author. This system uses a more compact notation for the code and needs a smaller set of rewriting rules.

The aim of this paper is to analyse these two different rewriting systems for categorical combinators as a basis for implementation of applicative languages, and compare them with the classical approach due to Turner, using combinatory logic.
Interactive programs in a functional language: A functional implementation of an editor
Authors: Koopman Pieter W. M.
Published: November 2006

The transition from imperative programming to functional programming for problems whose mathematical nature is not immediately obvious raises two questions. First, how can the function concept be applied to such problems, and, secondly, what language concepts are most suited in this situation. This paper shows that an existing functional programming language is very well suited for the elegant implementation of interactive programs. As an example, a text editor is described. The implementation of the editor has once more demonstrated the benefits of functional programming: fast generation of short and reliable programs. This indicates that it is worth while to investigate the application fields of functional programming languages as well as their implementation, in order to try to make them into general‐purpose programming languages that can be used in a production environment.
A debugger for a graphical workstation
Authors: Bovey J. D.
Published: November 2006

This paper describes the ups source‐level debugger. Ups, which is designed to take advantage of the graphics and mouse available on a workstation, displays the debugged program's current state in the form of a hierarchically structured document in which items of interest can be expanded to show more detail. User interaction is via a system of menus and editable subfields, the intention being to create a debugger which has a lot of functionality but is easy to learn and easy to remember. The paper describes the ups user interface itself and discusses its implementaion, which may be of interest to anyone writing a program with an interface based on menus and editable fields. There is also a discussion of some of the problems that will be encountered by anyone trying to write a new debugger to run in an existing environment.
A supercomputer program development system
Authors: Perrott R. H. , Zarea‐Aliabadi Adib
Published: November 2006

This paper describes a high‐level programming system for constructing vector and array processor based software involving the parallel language Actus. The system functions on a cross‐computer basis where a programmer develops Actus programs in a form that can be tested and transferred to the chosen supercomputer. The principles involved are, however, applicable to other similar block‐structured high‐level languages.
fsh—A functional unix command interpreter
Authors: McDonald Chris S.
Published: November 2006

Command interpreters under the UNIX operating system typically employ the syntax and semantics of imperative programming languages. Many of the advantages that functional programming languages hold over imperative languages can be incorporated in a functional command interpreter. Unfortunately, functional command interpreters to date have used the syntax of Backus's FP. The advantages of command expressiveness and composition have not been appreciated. A powerful functional command interpreter,fsh, that overcomes many of the deterrents of previous functional command interpreters is presented. Much of the unnecessary complexity of existing UNIX command interpreters is avoided by following the functional paradigm.fshhas been implemented under the UNIX 4.2BSD and System V operating systems.
A direct access technique for sequential files with variable length records
Authors: Cowie J. R.
Published: November 2006

A technique is presented, based on the method of tries, which allows direct access to variable‐length records in a sequential file. No reorganization of the original file is involved.
Remote rendezvous
Authors: Gammage N. D. , Kamel R. F. , Casey L. M.
Published: November 2006

BNR Pascal is a systems programming language intended for the implementation of the systems software of distributed computing systems. It supports the Ada Rendezvous model of tasking and communication, uniformly extended to support communications between tasks distributed over the computing nodes of a system. BNR Pascal was designed and implemented in 1980, and has since been used to implement the operating systems and real‐time applications software for Northern Telecom's Meridian family of products. In total, more than 2 million lines of BNR Pascal exist. This paper describes the BNR Pascal remote rendezvous: the extension of rendezvous to interprocessor communication. It discusses the implementation of remote rendezvous, describing the advantages and disadvantages of several options. Finally, it details BNR's experience in using remote rendezvous in building substantial, practical distributed systems used in products.
Object‐oriented data management based on abstract data types
Authors: Annevelink J. , Dewilde P.
Published: November 2006

The computer‐aided design of dedicated pipelined processors for numerical applications and signal processing requires design tools that support system refinement, partitioning strategies and the transformation of behavioural descriptions into structure. This in turn poses problems of design data management which are considered here. We show that an object‐oriented data management system is a step towards solving the problems. The method proposed here is based on a systematic specification of data structures and data access methods, using abstract data type specifications. As a result, the data management is completely transparent to the application programs. The data‐management system is written in Enhanced C (EC), a set‐orientated extension of the language C.
Synthesizing implementations of abstract data types from axiomatic specifications
Authors: Jalote Pankaj
Published: November 2006

This paper describes a system for automatically generating an implementation of an abstract data type from its axiomatic specifications. Such a system can be useful for rapid prototyping and for detecting inconsistencies in the specifications by testing the generated implementation. In the generated Implementation, an instance of the data type is represented by its state. An operation on the data type is implemented by a collection of functions — a function for each of the axioms specified for the operation, and a function for the operation that determines, depending on the state of the instance(s) on which the operation is being performed, which of the axioms of the operation is applicable. The system is developed on a Sun‐3 workstation running Unix. It is written in C and generates the implementation of the abstract data type in C.
Distributing concurrent Ada programs by source translation
Authors: Bishop Judy M. , Adams Stephen R. , Pritchard Avid J.
Published: November 2006

This paper tackles the practical aspects of obtaining a distributed version of an Ada program. It proposes the use of an adapter, which can be a methodology or an automatic translator. The adapter accepts source of a concurrent Ada program, adds communication and control tasks, and produces source for a single distributed Ada program, which can then be compiled and run on a multi‐processor computer. The original program can consist of packages and tasks, and both of these can be classed as virtual nodes. The process of adaption does not alter the contents of any package in the original program, so that the method is directly applicable to systems that make use of library and generic packages. The communication between virtual nodes, which would normally reside as one per processor, is via messages on a ring, but the protocols are kept as simple as possible, and the messages are fully checked Ada types, rather than byte strings. The method has been applied to programs of the client‐server model, and could be adapted for other rendezvous‐based languages such as occam.
Maintaining cross references in manuscripts
Authors: Aho Alfred V. , Sethi Ravi
Published: November 2006

In this note, we show how a few UNIX™ commands can be combined to create a flexible reference assembler that automatically maintains the consistency of cross references in manuscripts. The reference assembler can be used in conjunction with any text formatter.
A multicast interface for UNIX 4.3
Authors: Hughes Larry
Published: November 2006

The UNIX 4.3 operating system, like its predecessor UNIX 4.2, is designed to allow interprocess communications between pairs of processes using sockets — pairs of integers identifying specific hosts and ports — which are associated with a process. In this paper a software package which allows interprocess communications between many UNIX processes (as opposed to two) is presented.
Unscrambling non‐sequential programs
Authors: Finnie G. R.
Published: November 2006

Certain types of computer language popular in areas such as decision support systems have the property that language statements need not be written in execution sequence, as the correct evaluation order can be established by dependency analysis. The uncontrolled use of these ‘nonsequential’ languages can lead to the development of programs and systems that are difficult to comprehend and maintain. This paper describes a method of clustering such code statements into sequential (procedural) modules to clarify visual presentation. The technique is based on depth‐first search of directed graphs and will group those statements which are most strongly related to each other into a module.
Programming with generators
Authors: Berztiss Alfs
Published: November 2006

Tagging of objects produced by generators is a simple mechanism for the synchronization of generators. Such tagging is proposed as a reliable software design technique for problems based on data streams. It is used to develop programs for two‐way merge and file update.
Performance analysis of partial‐match search algorithms for BD trees
Authors: Dandamudi Sivarama P. , Sorenson Paul G.
Published: November 2006

Database systems are becoming increasingly popular for answering queries. Partial‐match search queries are an important class of queries in such a system. Several storage structures have been proposed to answer these queries efficiently. The BD tree is an example of such a storage structure. A previous study indicated that the k‐d tree performance is better than that of the BD tree for partial‐match search queries. A recent paper reported some improved algorithms. However, it is unclear whether the improved algorithms show the BD tree in a favourable light for partial‐match search queries. This paper explores the performance of these algorithms and compares their performance to that of the k‐d tree. Since the BD tree construction process uses some heuristics to make it a better balanced tree, this paper also evaluates the effect of these heuristics on the partial‐match search algorithms. The major conclusions of this study are that the BD tree performance for partial‐match search is better than that of the k‐d tree when an improved algorithm is used for partial‐match search, and only the DZ expression rearrangement heuristic has substantial effect on partial‐match search performance.
An improved protocol reachability analysis technique
Authors: Holzmann Gerard J.
Published: November 2006

An automated analysis of all reachable states in a distributed system can be used to trace obscure logical errors that would be very hard to find manually. This type of validation is traditionally performed by the symbolic execution of a finite state machine (FSM) model of the system studied.

The application of this method to systems of a practical size, though, is complicated by time and space requirements. If a system is larger, more space is needed to store the state descriptions and more time is needed to compare and analyze these states. This paper shows that if the FSM model is abandoned and replaced by a state vector model significant gains in performance are feasible, for the first time making it possible to perform effective validations of large systems.
Assert, retract and external processes in prolog
Authors: Colomb Robert M.
Published: November 2006

As Prolog becomes more widely used, it becomes important to provide clear and consistent implementations of the assert and retract primitives. This paper introduces a bit‐map indexing system with a consistent semantics. It also considers the implementation of the interface between Prolog and an external source of clauses, concentrating on the storage of clauses on secondary storage, but considering also the presentation of data to Prolog programs by non‐Prolog processes.
JDB: An adaptable interface for debugging
Authors: Winder Russel , Nicolson Joe
Published: November 2006

In the Unix environment there are a number of debugging tools. None are universally popular and many programmers choose not to use any of them at all. In this paper we present a study of existing debuggers. We highlight a number of reasons why they may not be popular and we discuss some of the features that programmers look for in a debugging aid. Finally, we report on the development of a new screen‐based interface, JDB, and some informal results of its usage.
Statistics on graph reduction of SASL programs
Authors: Hartel Pieter H. , Veen Arthur H.
Published: November 2006

The execution has been studied of four small and four medium‐sized SASL programs, when interpreted by a variant of Turner's combinator reducer. Size, structure and composition of the combinator graph have been analysed at frequent intervals during the reduction process. The most interesting results are summarized and discussed. Nodes of the graph live rather short lives and are usually not shared. Cycles are rare, and linear lists are often short. In most aspects the behaviour of the graph is quite ordinary in the sense that a simple model is sufficient to obtain a good approximation.
A practical study of semi‐automatic OSI protocol implementation
Authors: Ciminiera L. , Demartini C. , Valenzano A.
Published: November 2006

Communication protocols form a language which can be recognized by extended finite automata, and compiler generating tools can help with its implementation. This paper presents a project for implementing the ISO OSI layers which are most relevant to LANs. Taking advantage of modular and repetitive OSI architecture, a layer implementation model is proposed, introducing sharp distinctions between protocol layer‐dependent and independent modules, so that the implementation effort can be largely reduced. It is also shown that layer‐dependent modules can be generated automatically by using software tools developed for compiler construction. It is assumed that the protocols to be implemented have already been verified and validated in their abstract forms using other techniques, since these aspects are not covered by the method proposed. Measures of program sizes and execution speeds obtained following the approach proposed are reported; they show that most of the layer code can be produced by automatic tools and the overall software complexity enables the OSI architecture to be implemented for single‐board microcomputers.
A practical solution for a large sparse matrix
Authors: Hentzel I. R. , Pokrass D. J.
Published: November 2006

This paper describes a computational technique that was used for determining whether a certain matrix equation, Mx = b, had an exact solution. Here, MT was a sparse 96,208 × 40,040 integer matrix. The approach is an appropriate alternative for certain matrices when memory constraints preclude using conventional techniques. The tools used are simple and their data structures well‐suited for virtual memory computers. An important aspect of the method is to adopt different data structures to represent the matrix as the matrix changes over the course of the problem.
Converting interpreters into compilers
Authors: Pagan Frank G.
Published: November 2006

There is an effective and quite general method of manually deriving compilers from programming‐language interpreters without dealing directly with machine language. The method is an implementation of the largely theoretical and under‐appreciated concept of partial computation, but can be understood on its own terms. It involves the translation of a source program's intermediate form into the interpreter's implementation language. This paper shows how the method can be used to transform both a sample iterative interpreter and a sample recursive interpreter into compilers. The result can be a large gain in program execution speed. Other advantages of the method, including the ease and practicality of applying it, are discussed.
Problems with the language modula‐2
Authors: Cornelius B. J.
Published: November 2006

One of the first tasks of the working groups producing a Modula‐2 standard has been to identify problems with the language defined by N. Wirth. This paper reports on the major problems with the language. These occur in the areas of type coercions and casts, scope, strings, the module SYSTEM, dynamic storage management and opaque types. Some familiarity with the language Modula‐2 is assumed.
A recovery block scheme for a VAX11/750 running unix
Authors: Hobley Philip , Jesty Peter
Published: November 2006

In this paper we describe an implementation of a scheme that is widely used in software fault tolerance, the recovery block scheme. This scheme is usually implemented using special purpose hardware and software. Our implementation runs on a VAX11/750 which has not been modified in any way. This machine uses a very slightly altered version of Berkeley's 4.2 Unix

Unix is a trademark of AT&T Bell Laboratories in the USA and other countries.

.
An empirical analysis of spreadsheet calculation
Authors: Sajaniemi Jorma , Pekkanen Jari
Published: November 2006

Spreadsheet calculation is a powerful tool in simple administrative data processing. Formulae in spreadsheets have similar forms to expressions in traditional programming languages, but the implementation of control structures is totally different. This paper contains an analysis of 101 spreadsheets made and used in business and government. The analysis concerns general properties, such as cell contents and referencing, the role of input, output and computation, and the different ways iteration is implemented. Finally some effects of expertise are studied. The results show that less than half of the available functions are really used, only one cell in 25 contains computation, and iteration is implemented in at least four different ways. Formulae are found to differ in their contents from expressions of programming languages, as control structures are implemented differently in these systems. Summation with a constant skip is suggested to be included in the set of functions of spreadsheet calculation.
Modular design for simulation
Authors: Sharma Ravi , Rose Lawrence L.
Published: November 2006

This paper presents a modular design approach for the implementation of process‐oriented or event‐oriented discrete systems simulation software. Requirements for such a simulation facility are discussed, to include list processing capabilities, data structuring capabilities, dynamic allocation of data storage, statistics collection and number‐crunching capabilities, and subprograms. Specific focus is placed upon implementing the process view which requires constructs in the language for initiating, controlling and terminating a process. Resource management facilities are also considered, to include a means of defining a resource with its associated resource handler and a set of primitives for requesting, releasing and obtaining status information regarding a resource.

HPSIM, an organized collection of modules written in Modula‐2, was designed to facilitate both event‐oriented and process‐oriented discrete systems simulation, Modula‐2 was chosen for its data abstraction facilities, its software engineering capabilities, its execution efficiency, its ability for separate compilation and its implementation of co‐routines. The modeller encapsulates the conceptual model of the system into a software module which is interfaced with the HPSIM modules. The IMPORT statement in Modula‐2 allows the modeller to access any of the routines provided by HPSIM as required. An example involving a single‐server CPU system highlights the process/resource features of HPSIM.
Derivation of local software quality metrics (software quality circles)
Authors: Poore J. H.
Published: November 2006

Software is a product in serious need of quality control technology. Major effort notwithstanding, software engineering has produced few metrics for aspects of software quality that have the potential of being universally applicable. The present paper suggests that, although universal metrics are elusive, metrics that are applicable and useful in a fully defined setting are readily available. A theory is presented that a well‐defined software work group can articulate their operational concept of quality and derive useful metrics for that concept and their environment.
On a formal definition and application of dimensional design
Authors: Bertran‐Salvans Miquel
Published: November 2006

Dimensional design (DD) is a simple, practical and systematic layout technique for the display of programs, specifications, expressions, etc. for application in the general area of software. Formalizations of DD are introduced, the main one being algebraic, and the usage of DD in real software projects is outlined; one of them corresponds to a software system for the telecontrol centre of a power network.

The formal definitions of DD which are presented arise during the design of a syntax‐driven editor generator for languages whose ‘phrases’ are DDs. Grammars for the definition of such languages are introduced in the paper. The varied usage of DD within the generator design is examined: grammatical, functional and algebraic notations in particular are considered. The samples of these DD representations that are given illustrate the enhancement of readability achieved, and illustrate the suitability of DD for use in the specification area in general.
A tale of two greps
Authors: Hume Andrew
Published: November 2006

Text searching programs such as the UNIX system tools grep and egrep require more than just good algorithms; they need to make efficient use of system resources such as I/O. I describe improving the I/O management in grep and egrep by using a new fast I/O library fio to replace the normal I/O library stdio. I also describe incorporating the Boyer‐Moore algorithm into egrep; egrep is now typically 8–10 (for some common patterns 30–40) times faster than grep.
The active deallocation of objects in object‐oriented systems
Authors: Atkins Martin C. , Nackman Lee R.
Published: November 2006

In object‐oriented systems, it is oftern useful for objects to be allowed to carry out some action before they are deallocated. This can be done by defining a destroy method in the object's class, and arranging for the memory system to send a message invoking this method immediately before deallocating the object. This allows resources associated with the object to be returned to the system, limited cross‐language garbage collection, and other, more complex, behaviour. During the execution of the destroy method it is possible for new references to objects to be created. Care must be taken that the garbage collection does not erroneously free such objects. Algorithms are presented to implement destroy methods in systems using reference counting and mark‐scan garbage collection techniques. Properties that are desirable in such systems are also discussed.
K6 — a protected mode kernel for the iAPX286
Authors: le Riche P. J.
Published: November 2006

This paper presents the design of an operating system kernel offering protection, and using the object model as the design methodology. Rich communication facilities are provided between domains of protection allowing stimuli, data and objects to be passed. All object types, including protection domains, may be created and deleted dynamically, and some may be ‘sealed’ and employed as user‐defined objects by a type manager which alone can penetrate them.
Program generation for Ada — a case study
Authors: Allen Pat , Burns Alan
Published: November 2006

Program generation software is increasingly being used, not only to assist non‐computer professionals to produce their own applications, but also to provide tools for programmers and designers. As part of the toolkit for an Ada dialogue development system, a program generator has been written in Ada to generate the package which codes the dialogue manager for a specified user interface. The input specifications and the method of generation are described. The advantages and disadvantages of Ada as the implementation, target and specification language are discussed.
Elastic memory: Buddy systems interface
Authors: Challab D. J.
Published: November 2006

To implement single‐ended flexible arrays (‘elastic memory’) a class of underlying dynamic storage allocation methods called buddy systems may be used to allocate fixed blocks of memory of restricted choices of size. Arrays are implemented in one approach as contiguous blocks of memory and in another as two‐level structures. Each approach is combined with three buddy methods for allocating blocks of memory, making six methods in all. This paper illustrates the general ideas of implementing elastic memory mechanisms in terms of the buddy system interface.
Concurrent C++: Concurrent programming with class(es)
Authors: Gehani N. H. , Roome W. D.
Published: November 2006

C++ and Concurrent C are both upward‐compatible supersets of C that provide data abstraction and parallel programming facilities, respectively. Although data abstraction facilities are important for writing concurrent programs, we did not provide data abstraction facilities in Concurrent C because we did not want to duplicate the C++ research effort. Instead, we decided that we would eventually integrate C++ and Concurrent C facilities to produce a language with both data abstraction and parallel programming facilities, namely, Concurrent C++. Data abstraction and parallel programming facilities are orthogonal. Despite this, the merger of Concurrent C and C++ raised several integration issues.

In this paper, we will give introductions to C++ and Concurrent C, give two examples illustrating the advantages of using data abstraction facilities in concurrent programs, and discuss issues in integrating C++ and Concurrent C to produce Concurrent C++.
A debugger for parallel processes
Authors: Griffin James H. , Wasserman Harvey J. , McGavran Lauren P.
Published: November 2006

A system for analysing and debugging parallel Fortran codes is in use on the Sun workstation. The system is composed of a parallel processing simulatormtsim, a window‐ and mouse‐based debugging toolmtdbx, and a set of real‐time display routines. The simulatormtsim, which is called from Fortran by a set of routines having the same syntax as the CRAY X‐MP multitasking library, causes several concurrently active user tasks to be executed. The debuggermtdbxis based on the Sundbxtooldebugging facility. It has an enhanced command interface with functional control of parallel processes in multiple windows. The display routines offer two real‐time views of multitasking synchronization primitives as they are used during execution. These three components of the debugging system afford the opportunity to analyse the behaviour of parallel processes by dynamic interaction at run‐time.
An addendum to G. S. Blair, J. A. Mariani and W. D. Shepherd: ‘A practical extension to unix for interprocess communication’
Authors: Saunders D.
Published: November 2006

Long expressions derived from stochastic situations such as communication networks can usually be simplified. Although this simplification can often be done algebraically, the resulting answer sometimes points to a simpler view of the process, and thence to an easy way of simplifying the expression. This communication does this in the setting of the above‐mentioned paper.
The ECLIPSE user interface
Authors: Sommerville Ian , Welland Ray , Potter Stuart , Smart John
Published: November 2006

This paper describes the user interface facilities of the ECLIPSE integrated project support environment. This interface is based on a consistent metaphor called the ‘control panel’ metaphor and includes standard help and message‐handling systems. The paper describes these as well as some of the interface standards which have been developed. The interface has been implemented on top of the ‘applications interface’, which provides a portable, hardware‐independent interface for software tools.
Generation of file processing programs based on JSP
Authors: Engmann Rolf , Van Hoeve Frans
Published: November 2006

This paper describes the generation of file processing programmes within the TUBA environment. Program structures are derived from data structures according to the JSP method. Expressions describing output data are specified in user‐system dialogues. The program specifications are stored in the dictionary. Complete executable programs can be generated from these specifications.
A heuristic for software evaluation and selection
Authors: Anderson Evan E.
Published: November 2006

The proliferation of software packages has created a difficult, complex problem of evaluation and selection for many users. Traditional approaches to the quantification of package performance have relied on compensatory models, such as the linear weighted attribute model, which sums the weighted ratings of software attributes. These approaches define the dimensions of quality too narrowly and, therefore, omit substantial amounts of information from consideration. This paper presents an alternative methodology, previously used in capital rationing and tournament ranking, that expands the opportunity for objective insight into software quality. In particular, it considers three measures of quality, the frequency with which the attribute ratings of one package exceed those of another, the presence of outliers, where very poor performance may exist on a single attribute and be glossed over by compensatory methods, and the cumulative magnitude of attribute ratings on one package that exceed those on others. The proposed methodology is applied to the evaluation of the following software types: word processing, database management systems, spreadsheet/financial planning, integrated software, graphics, data communications and project management.
Software function allocation methodology
Authors: Ralpho'neal Michael , Lively William , Sheppard Sallie
Published: November 2006

One of the challenges of distributed computer systems is the effective allocation of software system functions among the hardware components of the distributed system. Software function allocation methodology (SFAM) provides computer software system designers with a thorough and flexible method to allocate software system functions among the hardware components of a distributed computer system. Software designers select and rank relevant design parameters, analyse how well different distributed computer system components meet the chosen parameters, and allocate the software function accordingly.

The paper defines the problem, covers necessary terminology, and discusses the current state of research. The preconditions necessary for an analysis using SFAM are covered along with the environment in which SFAM should be used. Details of SFAM components are discussed. A complete outline of the SFAM methodology is provided, along with discussion of key points and frequent examples.
Record manipulation in prolog
Authors: Vaucher Jean G.
Published: November 2006

Prolog is a relatively new programming language that has proved excellent for symbolic computation. However, Prolog was not specifically designed for industrial scale work and it lacks some standard features that are useful for reading, maintaining and debugging large programs. In particular, Prolog has no record mechanism, and programs often require major changes when data structures are modified.

The record is a standard data abstraction concept that improves the robustness of programs. The main advantage in using records is that data structures can be modified and extended with minimal repercussion to program code. Furthermore, the use of significant names to access data fields means that the intent of code is generally clearer.

We present a set of primitive operators that support a readable and robust programming style for the manipulation of record data structures in standard Prolog. The proposal covers both simple and imbricated record types and handles selective modification of records cleanly. We also treat property lists and records in a uniform way. These benefits are achieved with minimal overhead while retaining the traditional Prolog non‐deterministic style.
A measurement‐based study of hardware support for object invocation
Authors: Ramachandran Umakishore , Yousef Khalidi M. Amin
Published: November 2006

The object invocation paradigm is attractive for structuring distributed systems. Distributed object‐based operating systems view the resources of the system as a collection of objects. Object invocation is the primary mechanism in such systems, and is often used as a yardstick for measuring the system performance. However, existing systems of this flavour exhibit poor performance due to the mismatch between the requirements of the object invocation mechanism and the machine architecture. Through measurements of an existing object‐based kernel, we present a breakdown of the costs involved in implementing the object invocation mechanism. The measurements suggest architectural solutions to improve the performance of such systems. We present our preliminary studies towards providing hardware support for the object invocation mechanism.
Rapid location of mount points
Authors: Smith Jonathan M.
Published: November 2006

‘Mount points’ allow more storage to be grafted into tree‐structured hierarchical file systems. Administrative tasks use their locations, which are tabulated in a file. In our System V Unix environment, this file was occasionally removed. Getmnt was written to recover the information. Getmnt has had three significant versions. The original version (getmnt1) was a highly optimized naive tree traversal. Getmnt3 improved the real time performance by a mean factor of 7 by pruning unnecessary branches from the traversal. Getmnt3 doubled getmnt2's speed, with a change from depth‐first to breadth‐first search. On our development system, getmnt1 required 647.6 s to run, whereas getmnt3 required 42.53 s.
The oberon system
Authors: Wirth N. , Gutknecht J.
Published: November 2006

In this paper we describe an operating system for a workstation designed and implemented by the authors within two and a half years. It includes memory management and module loader, a file system, a viewer system, editors for text and graphics, a compiler, a server interface and various tools. The primary motivation was to demonstrate the feasibility of a small, yet highly flexible and powerful, system, a system that is a (decimal) order of magnitude smaller than commonly used operating systems. This is possible due to regularity of concepts and concentration on the essential. The benefits are not only fewer resources needed, but elegance and generality of concepts resulting in transparency and convenience of use and increased reliability. A corner‐stone of this approach is genuine extensibility, which is achieved by a new language, in particular by a facility called type extension. It allows for the integration of variables (objects) of a new, extended type in structures of elements of an existing base type.
Tools for implementing network protocols
Authors: Hutchinson Norman C. , Mishra Shivakant , Peterson Larry L. , Thomas Vicraj T.
Published: November 2006

This paper describes two software tools—a message manager and a map manager—used to implement network protocols. The tools are provided as part of the x‐kernel, an operating system kernel designed to support the construction and composition of protocols. For each tool, we briefly motivate the network task that needs to be done, give a high‐level specification of the tool, outline the algorithms and data structures used to implement the tool and give concrete examples of how the tool is used to implement real protocols. We also demonstrate how the tools, even though they are designed for general use, perform efficiently.
Automated software management based on structural models
Authors: Waters Richard C.
Published: November 2006

A number of software management tasks (consistent system construction, system installation, etc.) can be performed by automatic tools. Given a particular software system, such a tool requires a task model that describes how the task is to be applied to the system. For example, a system construction tool needs to know which operations (compilation, linking, etc.) must be applied to which modules.

Unfortunately, although task models are convenient for an automatic software management tool, they are inconvenient for users for two reasons. First, users have to create and maintain multiple, partially redundant models. Secondly, task models are often quite awkward to deal with‐a primary source of difficulty being the need to specify low‐level, task‐specific details.

In recognition of these problems, recent software management tools have been moving away from task models towards structural models (e.g. who calls who) as a user interface. Structural models are easy to deal with, because they contain high‐level, task‐independent relationships, rather than task‐dependent details.

A prototype tool has been implemented that makes this change complete. The tool automatically performs a variety of software management tasks using a single structural model for a system. The tasks themselves are described separately using system‐independent task descriptions.
Microcomputer vs. mainframe simulations: A case study
Authors: Bengtson Neal M.
Published: November 2006

A comparison was made between using a simulation language to run models on a mainframe computer and on a microcomputer with a hard disk. The study was performed at NASA Langley using both the SLAM II mainframe and PC versions. The procedure for executing SLAM II on a PC is given. A batch job was created to simplify this procedure and allows PCs with a hard disk to execute simulations with one command. NASA's space transportation system operations model and the examples in the SLAM II text were used as a basis for the comparison. The PC simulations completed in predictable times. These were almost always faster than the more unpredictable mainframe times.
TGMS: An object‐oriented system for programming geometry
Authors: Dietrich Walter C. , Nackman Lee R. , Sundaresan Christine J. , Gracer Franklin
Published: November 2006

TGMS (tiered geometric modelling system) is an experimental system intended to reduce the difficulty and cost of developing new solid modelling applications while preserving investment in an existing, time‐tested, solid modeller. The application developer writes programs in the TGMS language, which consists of a base language augmented by data types (classes) for geometry. The base programming language is AML/X, an object‐oriented language intended for use in design and manufacturing applications. Solid modelling is done using an interface to GDP (geometric design processor), an existing, production‐quality solid modelling system. TGMS shows how a system written in a non‐object‐oriented language can be used as a base for an object‐oriented application programming environment.

This paper presents the design of TGMS and discusses important aspects of its implementation. The TGMS language defines classes and methods that provide an interface to functions and data represented in a non‐object‐oriented language. To implement TGMS, issues related to communication, storage management and consistency were addressed. These, and other, implementation issues are discussed. The paper includes sample programs and a summary of feedback from TGMS users. It concludes that the use of object‐oriented programming for geometry has many benefits, and that an object‐oriented system can be built on top of a non‐object‐oriented system at less cost than building the equivalent object‐oriented system from scratch.
A case study comparison of four declarative programming languages
Authors: Fleck A. C.
Published: November 2006

A case study comparison is made of four declarative programming languages: Miranda,

Miranda is a trademark of Research Software Ltd.

Fp, Equations and Prolog. The case study is used as a vehicle to assess both expressiveness and performance aspects of these languages. In expressive power, Miranda is judged to be superior, Equations and Prolog are rated about even in second place, and Fp is judged least expressive. Performance was quite poor for all the available implementations. Reasons for this are explored and the implications are discussed.