bluuebunny/crossref_metadata_2025_split huggingface dataset:
A communication system supporting large datagrams on a local area network
Authors: Linton A. , Panzieri F. 
Published: November 2006

AbstractThis paper describes an implementation of a software interface designed for use from within UNIXUNIX is a trademark of A T & T Bell Laboratories.
application programs for network communications. This interface provides the abstraction of possibly very large datagrams, supports ‘scatter‐gather’ facilities, and maintains standard network addresses consisting of (host number; port number) pairs. This interface has been provided on different data communication facilities, allowing uniform program access to those facilities. The particular implementation developed for a local area network is described, and performance results obtained are examined and compared with those obtained from a conventional datagram interface to that network. The results obtained confirm that the abstraction of very large datagrams enables the construction of an efficient mechanism for process‐to‐process communications over the network that is not only more convenient, but also has significant performance advantages over the use of conventional (small) datagrams.
Process administration in a high level language
Authors: Pedersen T. 
Published: November 2006

AbstractThe traditional approach to the implementation of process administration in multiprogrammed systems is to make it part of the run‐time system or ‘kernel’. This implies first, that the implementation is written in assembler language, and secondly that the process administration will be very inflexible. This article outlines a high level language PoMP, a Pascal extension. Following the trend set by Concurrent Pascal and Modula towards integrating ever increasing parts of the ‘kernel’ in the individual application program, PoMP provides language constructs for implementing process administration. It is shown that the multiprogramming language constructs of a number of languages may be ‘imitated’ in PoMP.
The construction of information management system prototypes in Ada
Authors: Burns A. , Kirkham J. A. 
Published: November 2006

AbstractThe use of a data‐flow diagram and data dictionary for the requirements specification of an information management system is described together with the benefits to be gained from using prototypes. Construction of such prototypes in Ada is discussed in detail with a simple example being given. The use of a flexible user interface, generic data‐flows, exception handlers for error conditions and a top‐down design method that makes use of separate compilation indicates that Ada is an appropriate language for the development of such systems. Consideration is also given to the use of Ada in the construction of actual as well as prototype information systems.
A persistent graphics facility for the ICL PERQ
Authors: Morrison R. , Brown A. L. , Bailey P. J. , Davie A. J. T. , Dearle A. 
Published: November 2006

AbstractThe facilities of the PS‐algol programming language are described in this paper to show how they may be used to provide an integrated programming support environment. The persistent store mechanism and the secure transaction facilities provide the basic environment in which an integrated system may be implemented. In particular the paper makes use of the data type picture of PS‐algol to show how such an environment may be built for a graphics system ideal for use with a medium range computer workstation. An implementation of a picture editor on the ICL PERQ workstation is described to show the utility of the system.
AWK as glue for programs
Authors: Van Wyk Christopher J. 
Published: November 2006

AbstractAlthough AWK is usually presented as a language for simple data retrieval and formatting, it is also well suited to writing program generators. This use gives AWK much more power as a means of communicating among programs than its usual role as reformatter suggests. This paper discusses features of AWK that are especially useful for program generation. As an extended example, it presents a complete AWK program for typesetting charts in TROFF documents.
Yet another storage technique for lr parsing tables
Authors: Al‐Hussaini A. M. M. , Stone R. G. 
Published: November 2006

AbstractA submatrix storage scheme for sparse matrices is presented which has been found useful for storing LR parsing tables. It is not the most compact representation but it is easy to use and of order (1) in speed of access. The method is compared with the two most popular methods of storing LR parsing tables which use ‘linear lists’ and ‘row displacement’. Results of using the submatrix method to store the parsing tables for the Pascal language are included.
A Distributed Real‐Time Operating System
Authors: Tuÿnman F. , Hertzberger L. O. 
Published: November 2006

AbstractA distributed real‐time operating system, Fados, has been developed for an embedded multiprocessor system. The operating system is based on a host‐target approach and provides for communication between arbitrary processes on host and target machines. The facilities offered are, apart from process communication, access to the file system on the host by programs on the target machine and monitoring and debugging of programs on the target machine from the host. The process communication has been designed in such a way that the possibilities are the same as those offered by the Ada programming language. The operating system is implemented on an MC 68000 based multiprocessor system in combination with a UnixUnix is a trademark of A. T. & T. Bell laboratories.
host.
Experimenting with data structures
Authors: Taylor David J. , Black James P. 
Published: November 2006

AbstractResearch in robust data structures can be done both by theoretical analysis of properties of abstract implementations and by empirical study of real implementations. Empirical study requires a support environment for the actual implementation. In particular, if the response of the implementation to errors is being studied, a mechanism must exist for artificially injecting appropriate kinds of errors. This paper discusses techniques used in empirical investigations of data structure robustness, with particular reference to tools developed for this purpose at the University of Waterloo.
A modula‐2 kernel for supporting monitors
Authors: Terry P. D. 
Published: November 2006

AbstractThe concept of the monitor as a device for handling the problems of mutual exclusion and synchronization in a set of concurrent processes is now well understood. In addition to being of considerable theoretical interest, the monitor concept has been found suitable for the design of several practical operating systems. This paper discusses an implementation of monitors using a kernel written in Modula‐2.
The cost of lexical analysis
Authors: Waite W. M. 
Published: November 2006

AbstractThis paper examines a common design for a lexical analyser and its supporting modules. An implementation of the design was tuned to produce the best possible performance. In effect, many of the optimizations that one would expect of a production‐quality compiler were carried out by hand. After measuring the cost of tokenizing two large programs with this version, the code was ‘detuned’ to remove specific optimizations and the measurements were repeated. In all cases, the basic algorithm was unchanged, so that the difference in cost is an indication of the effectiveness of the optimization. Comparisons were also made with a tool‐generated lexical analyser for the same task. On the basis of the measurements, several specific design and optimization strategies are recommended. These recommendations are also valid for software other than lexical analysers.
A string pattern matching extension to pascal and some comparisons with snobol4
Authors: Liu Ken‐Chih 
Published: November 2006

AbstractThis paper presents an extension of Pascal with string pattern matching. Pattern definitions are built using six basic operations: alternation, concatenation, immediate value assignment, intersection, difference and complement. The last three have not been previously implemented and they increase the expressive power beyond context‐free languages. The pattern matching actions are augmented with three options: trace, prefix and suffix. Comparisons with a SNOBOL4 implementation are also presented. This experiment demonstrates that Pascal with pattern matching is a useful tool for string processing applications.
A management system for dirty data
Authors: Coombs R. F. 
Published: November 2006

AbstractA computer system for managing error prone and complex time‐series data is described. The system processes statistics on the catches and fishing operations of fishermen operating in New Zealand waters. These statistics are used primarily for fisheries management and, for this purpose, many years of data may be required. Errors in the data can seriously compromise management and must be weeded out as far as possible.The system is organized around four groups of files: an input file in which data are held temporarily for error checking and correction; a master file which provides medium‐term storage for the basic data; derived from this, several summary files tailored to the needs of different user groups; and, lastly, archival files in which the basic data are stored in the long term.The most significant feature of the system is providing effective and comprehensive error detection and correction, and in this is has proved most successful.
Automatic generation of useful syntax error messages
Authors: Kantorowitz E. , Laor H. 
Published: November 2006

AbstractMany current compilers produce in some situations wrong error messages that mislead the user and harm his confidence in the system. It is demonstrated that a reliable and efficient syntax error handling system may be produced automatically by a compiler generator from the BNF specification of the language, and without any effort by the language implementor. This result is achieved in three ways:

Some errors may not be diagnosed without knowledge of the intentions of the programmer. Some compilers employ a sophisticated analysis that attempts to capture these intentions, but which is not always successful. Such an elaborate analysis is not employed here, and instead a list of all the legal corrections is displayed, so that the programmer may readily select the right one.
The recovery symbols are selected by a ‘careful’ algorithm resulting in a high probability for correct error recovery.
The ‘honest’ error messages show also the parts of the code which could not be analysed correctly because of errors, and where more errors may exist.
Efficiency is achieved by computing the recovery sets once and for all at compiler generation time, so that a fast error recovery at program compilation time is achieved. Experiments with erroneous programs suggest that the method compares well with the best compilers that we have seen, and is specially good at the avoidance of wrong error messages.
Multiplication by integer constants
Authors: Bernstein Robert 
Published: November 2006

AbstractMethods are given for finding a sequence of ‘add’, ‘subtract’ and ‘shift’ instructions to multiply the contents of a register by an integer constant. Each method generalizes the previous one and requires only a few intermediate or scratch registers. A variation of the last method is used in the PL.8 compiler and uses an unnoticeable amount of the overall compile time. Some statistics roughly indicating the effectiveness of the methods are presented.
A practical approach to data modelling in spatial applications
Authors: Norris‐Sherborn A. , Milne W. J. 
Published: November 2006

AbstractThe storage and manipulation of spatial data requires a different style of support from that normally found in commercial database systems. This paper explores the use of the functional data model and the high level language Daplex to provide an integrated tool for the conceptual modelling of spatial data and the manipulation of data values. Importance is attached to allowing dynamic schema definition and to the provision of abstract data types to support spatial objects. The implementation comprises three separate modules and uses an underlying relational DBMS to store all metadata and data values. This modular design has enabled the user interface, Daplex language and storage aspects of the software to be developed independently, creating a system which has already proved to be easily portable. Consideration has also been given to ways of improving system performance.
Foreet: A tool for design and documentation of fortran programs
Authors: Ben‐Ari Mordechai 
Published: November 2006

AbstractForeet is a software tool for the design and documentation of Fortran programs. It is based on the premise that documents accompanying a program should be computerized and integrated: computerized–to ensure fast, easy and inexpensive updating; integrated–to ensure that the documents reflect what is actually contained in the program and not some idealized notion. Foreet takes a syntactically correct Fortran program (or skeleton of a program) and comments in a specified format and writes a report. It can be used to document existing programs, though the best results will be obtained if the documentation is developed concurrently with the program. Foreet is concerned with data description and subprogram interfaces. By encouraging precise specification of these critical facets of a program, Foreet can improve the quality of programs.
Logicon: An integration of prolog into icon
Authors: Lapalme Guy , Chapleau Suzanne 
Published: November 2006

AbstractThis paper describes the coupling of logic programming with Icon, which is a programming language aimed at string processing. Icon and Prolog have many similarities and their integration is feasible and desirable because the weaknesses of one can be compensated for by the strengths of the other. In our case, a Prolog interpreter was written as an Icon procedure that can be linked and called by an Icon program. This interpreter deals with all Icon data types and can be called in the context of the goal‐directed evaluation of Icon. We give an example showing the power of this symbiosis between these two languages where a Prolog call in Icon is a generator and an Icon call in a Prolog clause is a built‐in predicate.
A functional processor for the relational algebra on a microcomputer
Authors: Merrett T. H. , Van Rossum Ted 
Published: November 2006

AbstractWe have built on the U.C.S.D. P‐system (running on an IBM Personal Computer) a relational algebra processor, MRDS/FS, which is extremely powerful and which supports a functional syntax for the programmer‐user. The relational algebra is provided in the extended operators μ‐join, σ‐join, project and select. The domain algebra is fully implemented for the first time, giving operations on attributes: arithmetic, logic, comparison and four different categories of aggregation of these. A strictly functional syntax is provided, permitting user‐defined functions using the relational and domain algebras as primitive operations. An interactive editor permits the creation, copying and changing of both relations and user‐defined functions.
Algorithms for BD trees
Authors: Dandamudi Sivarama P. , Sorenson Paul G. 
Published: November 2006

AbstractDatabase applications often require a sophisticated class of storage structures in order to answer different types of queries efficiently. This often dictates that the file should be organized on multiple keys. Several storage structures have been proposed to satisfy these needs. Most are generalizations of the storage structures used for managing one‐dimensional data. Recently, a new storage structure, called the BD tree, was proposed to manage multidimensional data. This structure has good dynamic characteristics. This paper presents algorithms for the BD tree to perform insertion, deletion, and to answer exact match, partial match and range queries. In addition, some experimental evidence is presented that suggests that BD trees have good dynamic characteristics.
Writing concurrent assemblers–a case study in path pascal
Authors: Dowsing R. D. , Sanderson M. T. 
Published: November 2006

AbstractThis paper describes an investigation into the use of Path Pascal for implementing a number of different concurrent algorithms for an assembler for a subset of the PAL‐11A assembly language for the PDP‐11 range of computers. The various programs which resulted were run using simulated concurrency under the VMS operating system on a VAX 11‐780 computer, and measurements were obtained relating to the performances of the programs on different architectures. The suitability of path expressions for specifying object concurrency in such problems is discussed.
Lazy garbage collection
Authors: Glaser H. W. , Thompson P. 
Published: November 2006

AbstractThis paper describes a variation on the reference count method of garbage collection which can be particularly effective for the implemention of modern, truly functional languages. This method gives a high degree of control over the collection process and an increase in efficiency for many systems, particularly those with small, fast memories local to the central processor, such as a stack or an addressable cache.
Formatting texts accessed randomly
Authors: Smith John B. , Weiss Stephen F. 
Published: November 2006

AbstractFull‐text systems that access text randomly cannot normally determine the format operations in effect for a given target location. The problem can be solved by viewing the format marks as the non‐terminals in a format grammar. A formatted text can then be parsed using the grammar to build a data structure that serves both as a parse tree and as a search tree. While processing a retrieved segment, a full‐text system can follow the search tree from root to leaf, collecting the format marks encountered at each node to derive the sequence of commands active for that segment. The approach also supports the notion of a ‘well formatted’ document and provides a means for verifying the well‐formedness of a given text. To illustrate the approach, a sample set of format marks and a sample grammar are given suitable for formatting and parsing the article as a sample text.
Transporting TEX into the HITAC VOS3 environment
Authors: Hayashi Tsunetoshi 
Published: November 2006

AbstractAn attempt to transport TEX82 and to implement a typesetting program which realizes the output of the former at Hokkaido University Computing Center is described. The target operating environment and the environment required for running the TEX82 program are compared. The transporting procedure and the requirements for compiling and running the TEX82 program are described, along with the problems that they caused. The measures taken to adapt TEX82 to the target operating environment are explained, where considerations of how the system‐dependent parts are designed in accordance with the conventions of the target environment are illustrated in detail.The working principles and some implementation details of the output typesetting program are described, where rather esoteric techniques are employed. Finally, some measurements of performance are given.
A browser for directed graphs
Authors: Rowe Lawrence A. , Davis Michael , Messinger Eli , Meyer Carl , Spirakis Charles , Tuan Allen 
Published: November 2006

AbstractA general‐purpose browser for directed graphs is described. The browser provides operations to examine and edit graphs and to generate a layout for a graph automatically that minimizes edge crossings. Two layout algorithms were implemented. A hierarchical graph layout algorithm was found to be best for directed graphs. The graph browser also has facilities that allow it to be integrated with other applications (e.g. a program browser). These facilities and our experiences building a program call‐graph browser are described.
Debugging programs that use macro‐oriented data abstractions
Authors: Katzenelson Jacob , Strominger Avy 
Published: November 2006

AbstractEnhanced C (EC) is a set‐oriented, extensible, C‐like language. EC uses data abstractions to define new types. These data abstractions, called clusters, are macro‐like devices that perform substitution on the typed syntax tree. Debugging programs that use clusters raise problems that are not encountered in ordinary programming languages. At compile time there is a need to determine and report whether the macro expansion will result in a legal program before this expansion actually takes place. At run‐time the problems are how to account for replaced statements and how to handle variables whose types have been established by the clusters, variables that disappear, or variables whose names have been changed.This article presents these problems and their solutions as implemented by the EC compiler and the EC symbolic debugger.Similar debugging problems appear in other languages: The need to handle variables at run time is common to all languages that support data abstraction even if the abstractions are procedure oriented; also, a mild form of the problem of the replaced statement appears in inline procedure substitution of Ada. The solutions developed for the EC debugger apply to these cases as well.
The suitability for master/slave concurrency of concurrent euclid, ada and modula
Authors: Butler Gregory , Kendall Mathhew J. 
Published: November 2006

AbstractThe suitability of Concurrent Euclid, Ada and Modula for a special form of asynchronous concurrency, called master/slave concurrency, is investigated. No language is ideal, with Concurrent Euclid and Modula having major drawbacks. The conclusion lists the features desirable in a language for master/slave concurrency.
A structural testing method for JSP designed programs
Authors: Roper M. , Smith P. 
Published: November 2006

AbstractA new structural testing method (STM) is presented for use with JSP (Jackson structured programming) designed programs. The method involves the creation of a path expression from the program structure and subsequent expansion of the expression into a set of paths using an algebra described in the paper. The treatment of each JSP construct is dealt with in detail. A worked example demonstrates the use of the method to generate test cases. The method is compared in terms of coverage to other well‐known structural testing methods. The advantages and disadvantages of the method are discussed and further work currently being undertaken by the authors is outlined.
A depth‐first and tool‐supportable programming strategy
Authors: Huang J. C. 
Published: November 2006

AbstractThis paper describes a software im plementation strategy that allows the programmer to construct a running version of a program early in its development. In general, the first version of the program only works for a subset of the intended input domain. The subset is defined by a number of constraints placed on the program by the programmer. The program can be completed by removing the constraints one at a time. In the process, each new part added to the program can be validated independently. Software tools can be built to facilitate the validation process.
Implementing an extended functional data model using PS‐algol
Authors: Kulkarni K. G. , Atkinson M. P. 
Published: November 2006

AbstractA number of data models have been proposed in the literature to improve the usability of database systems. Most of these proposals have not been implemented. It is felt that a working implementation is a necessary prerequisite for a serious study of these proposals. So far, implementing data models has been a daunting task, requiring a large team. We report here on a simple implementation technique using the persistent algorithmic language. PS‐algol, which promises to make the task of implementing data models a manageable one. The feasibility of the approach is demonstrated by implementing an entity‐based functional data model (extended function data model) using PS‐algol.