bluuebunny/crossref_metadata_2025_split huggingface dataset:
DEMOS/MP: The development of a distributed operating system
Authors: Miller Barton P. , Powell Michael L. , Presotto David L. 
Published: November 2006

AbstractThe DEMOS/MP operating system has moved from a supercomputer with a simple addressing structure to a network of microcomputers. This transformation was done without significant changes to the semantics of the original DEMOS, i.e. existing DEMOS programs should run on DEMOS/MP. The changes to DEMOS were simplified by the structure of its primitive objects and the functions over those objects. The structure of DEMOS links and processes were the major contributors to the simplicity. The changes made to produce DEMOS/MP involved the internal structure of link, modification to parts of the kernel, and limited changes to the various system processes.
Addressing types and objects in Ada
Authors: Van katwijk J. 
Published: November 2006

AbstractIn 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.
Making form follow function: An exercise in functional programming style
Authors: Fairbairn Jon 
Published: November 2006

AbstractThe 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

AbstractDetailed 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.
Generating reversible programs
Authors: Briggs J. S. 
Published: November 2006

AbstractThis 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

AbstractWe 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

AbstractAlthough 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.
Register allocation in a pattern matching code generator
Authors: Van Biljon W. R. , Sewry D. A. , Mulders M. A. 
Published: November 2006

AbstractRegister 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

AbstractCategorical 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

AbstractThe 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

AbstractThis 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

AbstractThis 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

AbstractCommand 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.
Remote rendezvous
Authors: Gammage N. D. , Kamel R. F. , Casey L. M. 
Published: November 2006

AbstractBNR 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

AbstractThe 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

AbstractThis 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

AbstractThis 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.
A multicast interface for UNIX 4.3
Authors: Hughes Larry 
Published: November 2006

AbstractThe 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

AbstractCertain 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.
Performance analysis of partial‐match search algorithms for BD trees
Authors: Dandamudi Sivarama P. , Sorenson Paul G. 
Published: November 2006

AbstractDatabase 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

AbstractAn 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

AbstractAs 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

AbstractIn 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

AbstractThe 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

AbstractCommunication 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

AbstractThis 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

AbstractThere 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

AbstractOne 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

AbstractIn 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 UnixUnix 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

AbstractSpreadsheet 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.