bluuebunny/crossref_metadata_2025_split huggingface dataset:
A programmer‐friendly LL(1) parser generator
Authors: Grune Dick , Jacobs Ceriel J. H. 
Published: November 2006

AbstractLL(1) grammars have the conceptual and practical advantage that they allow the compiler writer to view the grammar as a program; this allows a more natural positioning of semantic actions and a simple attribute mechanism. Resulting parsers can be constructed that achieve fully automatic error‐recovery, which allows the compiler writer to ignore totally the issue of syntax errors. Measurement shows that such parsers can be reasonably efficient.
A microprogrammed occam interpreter for the HLH orion
Authors: Cooper R. E. M. , Jones G. 
Published: November 2006

AbstractA micro‐coded interpreter has been written for the occam programming language that runs on the fully microprogrammable HLH Orion mini‐computers. The resulting software gives performance which is comparable with native‐code operation on similar hardware, and is able to be extended easily to support new instructions as the language is developed further.
The design of a language processor generator
Authors: Koskimies Kai , Nurmi Otto , Paakki Jukka , Sippu Seppo 
Published: November 2006

AbstractLanguage processor generators are systems that produce various language processors (including compilers) on the basis of a high‐level specification. The design of language processor generators is discussed on the basis of experiments with a traditional compiler writing system (HLP78) employing pore LALR parsing and general attribute grammars. It is argued that these methods are too primitive from the practical point of view. The design of a new language processor generator, HLP84, is based on this view. This system is an attempt to provide high‐level tools for a restricted class of applications (one‐pass analysis). The syntactic facilities include regular expressions on the right‐hand sides of productions, a disambiguating mechanism that is integrated with regular expressions, and a mechanism for using semantic information to aid parsing. The semantic facilities include automatic support for semantic error handling and for symbol tables. Early experiences with the new system show that in spite of the general overhead caused by the higher automation level, the system allows the generation of reasonably efficient processors.
PICASSO: A graphical query language
Authors: Kim Hyoung‐Joo , Korth Henry F. , Silberschatz Avi 
Published: November 2006

AbstractPICASSO (PICture Aided Sophisticated Sketch Of database queries) is a graphics‐based database query language designed for use with a universal relation database system. The primary objective of PICASSO is ease of use. Graphics are used to provide a simple method of expressing queries and to provide visual feedback to the user about the system's interpretation of the query. Inexperienced users can use the graphical feedback to aid them in formulating queries whereas experienced users can ignore the feedback. Inexperienced users can pose queries without knowing the details of underlying database schema and without learning the formal syntax of SQL‐like query language. This paper presents the syntax of PICASSO queries and compares PICASSO queries with similar queries in standard relational query languages. Comparisons are also made with System/U, a non‐graphical universal relation system on which PICASSO is based. The hypergraph semantics of the universal relation are used as the foundation for PICASSO and their integration with a graphical workstation enhances the usability of database systems.
Low‐level programming in modula‐2: An experience with local area network access
Authors: Tagg A. G. 
Published: November 2006

AbstractAccess to a computer network, which is currently a topic of some importance to the high‐level language programmer, can be provided in a number of ways. This paper describes one such example, where users of the language Modula‐2 were given access to a local area network. The author discusses the type of problem that needs to be overcome, when a language such as Modula‐2, which was designed as part of an integrated systems architecture, is used for low‐level programming in a different architectural environment.
CSP‐i: An implementation of communicating sequential processes
Authors: Wrench K. L. 
Published: November 2006

AbstractHoare's proposal for a notation for communicating sequential processes has led to the development of a number of concurrent languages based on the concept of message passing. CSP‐i is a new language which reflects the design objectives of the original CSP notation more faithfully than most of these other languages. This paper describes the development of the language, as well as an implementation for a single processor, with simulated time‐slicing providing pseudo‐concurrency.
A LISP implementation of the model for ‘communicating sequential processes’
Authors: Fidge C. J. 
Published: November 2006

AbstractTo explain his abstract model of Communicating Sequential Processes, Hoare includes an implementation of the concepts being expounded as a set of LISP functions. However, the final sections are only described sketchily. This paper completes the missing details, and briefly discusses experience with the system. The usefulness of the implementation is enhanced by the addition of features to ensure that incomplete program fragments can be executed, and that no restrictions are placed on the way operators may be combined.
RTS: A system to simulate the real time cost behaviour of parallel computations
Authors: Qin Bin , Sholl Howard A. , Ammar Reda A. 
Published: November 2006

AbstractIn this paper, we present a software tool, RTS (real time simulator), that analyses the time cost behaviour of parallel computations through simulation. It is assumed in RTS that the computer system which supports the executions of parallel computations has a limited number of processors all processors have the same speed and they communicate with each other through a shared memory. In RTS, the time cost of a parallel computation is defined as a function of the input, the algorithm, the data structure, the processor speed, the number of processors, the processor power allocation, the communication and the execution environment. How RTS models the time cost is first discussed in the paper. In the model, a locking technique is used to manipulate the access to the shared memory, processing power is equally allocated among all the operations that are currently being performed in parallel in the computer system, and the number of operations in the execution environment of a parallel computation changes from time to time. How RTS works and how the simulation is used to do time cost analysis are also discussed.
NSEDIT: A syntax‐directed editor and testing tool based on Nassi—Shneiderman charts
Authors: Halewood K. , Woodward M. R. 
Published: November 2006

AbstractThis paper describes a programming environment for Pascal, called NSEDIT, which runs under VAX/VMSVAX/VMS is a trademark of the Digital Equipment Corporation.
. NSEDIT is based upon the notion of Nassi‐Shneiderman charts (abbreviated to N‐S charts in this paper) and is designed for ease of use by novice programmers in a teaching situation. A key component of the system is the editor, which enables structural features of Pascal to be manipulated in terms of their N‐S chart box representations. Simultaneous editing of more than one program or module is permitted. Another key feature of the system is a semiautomatic interface to the VAX/VMS Pascal compiler, with subsequent display of execution counts as part of the N‐S charts. In this way users can obtain immediate feedback on the coverage of program elements by test runs, while still inside an editing session.
GNU Emacs as a dynamically extensible programming environment
Authors: Halme Heikki , Heinänen Juha 
Published: November 2006

AbstractGNU Emacs is usually used only as an extensible editor. However, the ability to integrate inferior processes into GNU Emacs makes it an attractive programming environment. Like Interlisp and Smalltalk‐80, GNU Emacs can be extended dynamically by its user. Unlike these programming environments, it can be used easily as a programming environment for an arbitrary programming language, and not just for its extension language. This paper discusses the methods of extending GNU Emacs and how we have applied them in creating a programming environment for a high‐level specification language called AGENT.
Support for graphs of processes in a command interpreter
Authors: McDonald Chris , Dix Trevor I. 
Published: November 2006

AbstractSince the inception of pipes in the UNIX operating system, the standard UNIX command interpreters, or shells, have supported processes connected only in linear arrangements. This paper explains why linear pipe structures are too restrictive and how the standard UNIX shells have dictated the interface strategy of new commands. A new command interpreter is presented that supports general directed process graphs. Processes and files are considered simply as nodes and pipes as arcs in a process graph.
DAG—a program that draws directed graphs
Authors: Gansner E. R. , North S. C. , Vo K. P. 
Published: November 2006

AbstractDAG is a program that draws directed graphs by reading a list of noeds and edges, computing a layout and then writing a PIC or PostScript description of a picture. Optional drawing instructions specify the way nodes are drawn, attach labels and control spacing. DAG works best on directed acyclic graphs, which are often used to represent hierarchical relationships. For example, here is a drawing of a graph from J. W. Forrester's book, World Dynamics (Wright‐Allen, Cambridge, MA, 1971), which took 1.63 CPU seconds to draw using a VAX‐8650.
Load balancing in a session‐based distributed file‐store architecture
Authors: Santana M. J. , Zaluska E. J. 
Published: November 2006

AbstractThis paper discusses novel dynamic‐load‐balancing and user‐allocation mechanisms for an advanced session‐based file‐store architecture to improve overall system performance. Such an architecture comprises several LAN‐based file servers working together, implementing a global and distributed file‐store for a loosely coupled distributed computing system. The load‐balancing and user‐allocation algorithms are responsibilities of a high‐level co‐ordinator server, which may be either centralized or distributed. The mechanism discussed considers three basic parameters in order to optimize the global performance: the individual file‐server performance, the cost of connection between user workstations and file servers and the cost of accessing different file servers. The paper presents the algorithms developed, together with a brief description of the file‐store architecture and associated environment. Results obtained from a simulation study and practical aspects are also presented and discussed.
Attribute grammars in constraint‐based graphics systems
Authors: Barford Lee Alton , Vander Zanden Bradley T. 
Published: November 2006

AbstractA constraint‐based graphics system provides a flexible, intuitive framework for describing relationships among graphical objects in applications such as document preparation, fount design and solid modelling. This paper describes two constraint‐based graphics systems, micro‐COSM and the IDEAL Synthesizer, and their implementation in terms of attribute grammars. Our experiences with attribute grammars suggest that they provide a powerful framework for representing constraints and extracting important semantic information such as the equations to be solved by the constraint solver. We discuss the advantages of using attribute grammars in constraint‐based graphics and from our experiences make several observations about the way attribute grammars should be used.
A session editor with incremental execution functions
Authors: Holsti Niklas 
Published: November 2006

AbstractEditing the script of an interactive session on‐line can replace or enhance common interaction techniques and help to separate the user interface from the computation. We describe a text editor that executes scripts incrementally, co‐operating with application programs to undo and redo script parts. The user edits the input part of a transcript, and the editor updates the output part. The transcript becomes a clear and reusable document. The applications choose the backtracking steps, and can thus evolve gradually. Extensions to non‐linear dialogues are in progress.
Implementation of a declarative state‐transition system
Authors: Foster Ian 
Published: November 2006

AbstractA declarative programming style is claimed to have significant advantages from a software engineering point of view. However, these benefits cannot generally be realized when writing programs that are concerned with changing state, such as environments and programming tools. Declarative state‐transition (DST) systems have been proposed as a solution to this problem. In DST systems, computation and update are separated. Programs are interpreted as defining functions or relations over states, and update follows successful computation of new states. Support for persistent state and atomic, serializable transactions facilitates the implementation of programming environments and tools. This paper describes an implementation scheme for DST systems. The scheme is illustrated by a presentation of the implementation of PPS, a DST system for parallel logic programming.
Object management in a persistent smalltalk system
Authors: Straw Andrew , Mellender Fred , Riegel Steve 
Published: November 2006

AbstractThe main goal of the Alltalk project is to provide transparent database support to the Smalltalk programmer. As a first step towards this goal, the current version of Alltalk extends Smalltalk‐80 by providing persistence to Smalltalk objects without adding a database sublanguage, new language syntax, classes or methods. This paper describes the implementation of object management in Alltalk, including database layout, database access methods, in‐memory object management and high‐level interface from the interpreter. It also discusses how the object manager is integrated in a unique way with the operations of the Alltalk garbage collector and interpreter.
Mapping massive SIMD parallelism onto vector architectures for simulation
Authors: Rosenberg Jonathan B. , Becker Jonathan D. 
Published: November 2006

AbstractA software behavioural simulator for a new massively parallel single‐instruction/multiple data (SIMD) architecture has been developed that can accurately simulate the entire 16, 384 bit‐serial processor array. The key to this high performance modelling is the exploitation of an inherent mapping that exists between massively parallel SIMD architectures and the vector architectures used in many high performance scientific super‐computers. The new SIMD architecture, called BLITZEN, is based on the Massively Parallel Processor (MPP) built for NASA by Goodyear in the late 1970s. By simulating the full‐scale machine with very high performance, the simulator allows development of algorithms and high‐level software to proceed before realization of the hardware. This paper describes the SIMD ‐ vector architecture mapping, the highly vectorized simulator in which it is used, and how the result was a simulator that achieved a level of performance three orders of magnitude faster than the conventional uniprocessor approach.
A simple technique for automatic recompilation in modular programming languages
Authors: Olsson Ronald A. , Whitehead Gregory R. 
Published: November 2006

AbstractThis paper presents simple techniques that can be used to automate recompilation and avoid unnecessary recompilation in modular programming languages. The basic technique generates a Makefile that reflects the dependencies among modules. This technique is demonstrated for programs written in SR, although it can easily be adapted to other modular languages. The recompilation problem for SR programs is complicated by the flexible way components can be placed in source files and by how an SR module's specification and implementation can be combined. A small modification to the basic technique reduces the amount of unnecessary compilation. This ‘semi‐smart’ approach is worth the small extra effort. The techniques described in this paper should be considered as an inexpensive, yet reasonably effective, alternative to smart recompilation. These techniques are especially applicable when the language's compiler cannot easily be modified.
A parallel Ada system on an experimental multiprocessor
Authors: Lundberg Lars 
Published: November 2006

AbstractThis paper describes the development of a parallel Ada system on an experimental MIMD multiprocessor. The system enables a single unmodified Ada program, with a number of tasks, to execute in parallel on different processors. Allocation and migration strategies are controlled by mechanisms in the run‐time system, and are thus transparent to the Ada programmer. The parallel Ada system is based on a validated portable front‐end compiler. Implementation issues related to the multiprocessor environment are pointed out, and solutions to these issues are suggested. The experimental multiprocessor environment, consisting of both hardware and software, is described. Applicable resource allocation strategies in, and feasible experiments with, the Ada system are discussed. The complete experimental system provides unique possibilities to experiment with, and monitor the effects of, design decisions at different levels in a multiprocessor environment.
A language‐independent prettyprinter
Authors: Jokinen Matti O. 
Published: November 2006

AbstractA general‐purpose prettyprinting program is presented. The input to the prettyprinter is a linear stream composed of visible symbols and elementary formatting instructions. The user can specify a set of alternative formats and the precedence of the alternatives. The prettyprinter attempts to select automatically the ‘best’ layout that fits on the bounded horizontal space available on the output medium. The prettyprinter is implemented as a library module, which makes it more flexible than many traditional prettyprinters that are written as main programs. For instance, formatted expressions can be mixed with plain text or displayed interactively on the user's terminal, and the application program can use several prettyprinters simultaneously.
A parallel version of cook and Kim's algorithm for presorted lists
Authors: McGlinn Robert J. 
Published: November 2006

AbstractThe Cook and Kim algorithm is a well known method for sorting presorted lists. This paper presents observations based on an implementation of the algorithm on a single processor. An extension of the algorithm to a tightly coupled multiprocessor will also be presented. The performance of the parallel version of the algorithm on presorted lists will be compared to that of a heavily used parallel sort algorithm for tightly coupled multiprocessors, Parallel Quicksort.
Near‐perfect hashing of large word sets
Authors: Brain Marshall D. , Tharp Alan L. 
Published: November 2006

AbstractThis article presents a procedure for constructing a near‐perfect hashing function. The procedure, which is a modification of Cichelli's algorithm, builds the near‐perfect hashing function sufficiently fast to allow larger word sets to be used than were previously possible. The improved procedure is the result of examining the original algorithm for the causes of its sluggish performance and then modifying them. In doing so an attempt was made to preserve the basic simplicity of th original algorithm. The improved performance comes at the expense of more storage. The six modifications used to improve performance are explained in detail and experimental results are given for word sets of varying sizes.
Fast allocation and deallocation of memory based on object lifetimes
Authors: Hanson David R. 
Published: November 2006

AbstractDynamic storage‐management algorithms are based either on object sizes or object lifetimes. Stack allocation, which is based on object lifetimes, is the most efficient algorithm, but severely restricts object lifetimes and creation times. Other algorithms based on object sizes, such as first fit and related algorithms, permit arbitrary lifetimes but cost more. More efficient variations capitalize on application‐specific characteristics. Quick fit, for example, is more efficient when there are only a few object sizes. This paper describes a simple algorithm that is very efficient when there are few object lifetimes. In terms of instructions executed per byte allocated, the algorithm is almost half the cost of quick fit and less than twice the cost of stack allocation. Space for all objects with the same lifetime is allocated from a list of large arenas, and the entire list is deallocated at once. An implementation in ANSI C is included.
Ceres‐net: A low‐cost computer network
Authors: Wirth N. 
Published: November 2006

AbstractThis paper describes a local‐area network, its hardware and software structure, and its protocol. The principal objective was to minimize the complexity of hardware and software, yet to offer an adequate functionality and performance for a system of up to 30 workstations with local file stores. The primary benefit of the achieved simple structure and low‐overhead protocol is the system's reliability.
Tools to aid in discovering parallelism and localizing arithmetic in Fortran programs
Authors: Cowell Wayne R. , Thompson Christopher P. 
Published: November 2006

AbstractWe describe a collection of software tools that analyse and transform Fortran programs. The analysis tools detect parallelism in blocks of code and are primarily intended to aid in adapting existing programs to execute on multiprocessors. The transformation tools are aimed at eliminating data dependencies, thereby introducing parallelism, and at localizing arithmetic in registers, of primary interest in adapting programs to execute on machines that can be memory bound (common for machines with vector architecture). The tools are unified conceptually by their use of a set of conditions for data independence; these conditions have been implemented so as to combine tool analysis with user/tool interaction. We include timing results from applying the tools to programs intended for execution on two machines with different architectures — a Sequent Balance and a CRAY‐2. The tools are written in Fortran in the tool‐writing environment provided by Toolpack and are easily incorporated into a Toolpack installation.
Code generation using an orthogonal model
Authors: Cordy James R. , Holt Richard C. 
Published: November 2006

AbstractThis paper describes a new systematic approach to code generation. The approach is based on an orthogonal model, in which implementation of language‐level operators (‘operators’) and addressing operators (‘operands’) is achieved by two independent subtasks. Each of these phases is specified using a set of decision trees that encode the set of possible implementation templates for each language feature and the set of constraints under which each can be applied. Code selection in each phase is achieved by interpreting these trees using a single comprehensive selection algorithm.The method easily extends to machine independence across a large class of target computers by abstracting the implementation templates into machine‐independent implementation strategies. The selection algorithm is then modified to select between implementation strategies based on a machine capability ‘menu’ that describes each target machine in terms of the subset of implementation strategies for which it has corresponding instruction sequences.The method has been used to implement a prototype machine‐independent code generator for the Concurrent Euclid programming language whose generated code density is consistently within four per cent of production machine‐dependent code generators across its entire target class of five modern computers.