ppxscal/embedding_network huggingface dataset:
Specification and implementation of programs for updating incomplete information databases
Authors: S. Hegner
Venue: Proceedings of the sixth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1987)

The problem of updating incomplete information databases is examined as a programming problem. From this point of view formal denotational semantics are developed for two applicative programming languages, BLU and HLU. BLU is a very simple language with only five primitives, and is designed primarily as a tool for the implementation of higher level languages. The semantics of BLU are formally developed at two levels possible worlds and clausal and the latter is shown to be a correct implementation of the former. HLU is a user level update language. It is defined entirely in terms of BLU, and so immediately inherits its semantic definition from that language. This demonstrates a level of completeness for BLU as a level of primitives for update language implementation. The necessity of a particular BLU primitive, masking, suggests that there is a high degree of inherent complexity in updating logical databases.
A class of compatible cache consistency protocols and their support by the IEEE futurebus
Authors: P. Sweazey, A. J. Smith
Venue: Proceedings of the 13th annual international symposium on Computer architecture (1986)

Standardization of a high performance blackplane bus, so that it can accommodate boards developed by different vendors, implies the need for a standardized cache consistency protocol. In this paper we define a class of compatible consistency protocols supported by the current IEEE Futurebus design. We refer to this class as the MOESI class of protocols; the term &ldquo;MOESI&rdquo; is derived from the names of the states. This class of protocols has the property that any system component can select (dynamically) any action permitted by any protocol in the class, and be assured that consistency is maintained throughout the system. Included in this class are actions suitable for copyback caches, write through caches and non-caching processors. We show that the Berkeley protocol and the Dragon protocol fall within this class, and can be extended to be compatible with other members of the class. The Illinois, Firefly and Write-Once protocols can be adapted to be compatible with this class; the facilities of he Futurebus currently do not support those protocols without adaptation. We discuss very briefly performance choices among protocols, and also other issues relating to a standard bus consistency protocol.
Rectangular convolution for fast filtering of characters
Authors: Avi Naiman, Alain Fournier
Venue: Proceedings of the 14th annual conference on Computer graphics and interactive techniques (1987)

While the race towards higher-resolution bitmap displays is still on, many grayscale displays have appeared on the scene. To fully utilize their capabilities, grayscale fonts are needed, and these can be produced by filtering bi-level masters. Most of the efficient filtering techniques cannot directly be applied. For example, prefiltering is impractical, due to the number of character masters and the requirement of sub-pixel positioning. Furthermore, we would like to impose as few restrictions as possible on the characteristics of the filter, in order to facilitate exploration into the quality of various filters.We describe a fast filtering technique especially adapted to this task. The characters are decomposed into rectangles, and a summed-area representation of the filter is efficiently convolved with each individual rectangle to construct the grayscale character. For a given filter, the number of operations is O (linear size of the grayscale character), which is optimal.We give an analysis of the efficiency of this technique, and examples of its implementation applied to various families of fonts and point sizes. The performance of the implementation is such that filtering characters for grayscale displays is feasible in realtime on personal workstations.
A linear algorithm for finding dominators in flow graphs and related problems
Authors: D Harel
Venue: Proceedings of the seventeenth annual ACM symposium on Theory of computing (1985)

In the first part of the paper we show how to extend recent methods for solving a special case of the union-find problem in linear time, to a special case of the eval-link-update problem for computing the minimum function defined on paths of trees. In the cases where our approach is applicable, we give a way to perform m eval, link, and update operations on n elements in O(m + n) time and O(n) space, improved from O(m &agr;(m + n, n) + n) time and O(n) space in the more general case, where &agr; is a functional inverse of Ackermans function. The technique gives similar improvements in the efficiency of algorithms for solving several network optimization problems in the case where all the keys involved are integers in some suitable range. In the second part of the paper we show how to use the new technique for speeding up the fastest known algorithm for finding dominators in flow graphs so that it runs in linear time. We introduce the notions of pseudo and external dominators which are both computable in linear time and make the technique introduced in the first part applicable for finding immediate dominators. We first give an algorithm for a limited class of graphs which include cycle free graphs, and thus can be used to find dominators in reducible flow graphs. We then show how to extend our technique for computing dominators on any flow graph. All the algorithms we describe run on a Random Access Machine.
An information system based on distributed objects
Authors: Michael Caplinger
Venue: ACM SIGPLAN Notices (1987)

The Telesophy system is intended to provide transparent access to all of a community's online information. The scale of the system requires that it be distributed across many machines via a network; the multiple types and formats of the information require that it be a multimedia system. We describe a prototype that uses objects to represent, query, display, and edit information. A two-level storage system is used to store the objects on multiple servers; queries are processed by indexing servers layered on top of the storage system. New media types and new indexing schemes can be added simply by defining new classes within the existing framework.
Impact of the technological environment on programmer/analyst job outcomes
Authors: Jack J. Baroudi, Michael J. Ginzberg
Venue: Communications of the ACM (1986)

Recent research has shown that key DP/IS personnel job outcomes (e.g., turnover, organizational commitment, job satisfaction) are affected by job design, leadership characteristics, and role variables. This study investigates another class of variables, the technological environment faced by DP/IS personnel, that might impact these job outcomes. The technological environment includes (1) development methodologies employed, (2) project teams and reporting relationships, and (3) work characteristics. Variables from all classes were found to impact DP/IS job outcomes. Over 11 percent of the variance in DP/IS job satisfaction is explained by these variables.
Evolution of program documentation through a long-term project
Authors: Peter E Schilling, John T Wizzard
Venue: Proceedings of the 4th annual international conference on Systems documentation (1986)

This paper is a case study with some recommendations. Over the course of a four-year (twenty person-year) project, the method of documenting programs changed from using separate files containing input data for a documentation lister, to placing all of the program documentation in the source code and using an extraction program when separate documentation was needed. The history and reasons for this evolution are described. The project revealed the usefulness of documentation tools including program templates, a good cross-reference lister, in-line documentation, and the extraction program.
A project for operating systems simulation
Authors: William A. Shay
Venue: Proceedings of the seventeenth SIGCSE technical symposium on Computer science education (1986)

The purpose of this paper is to describe a project in a course on Operating Systems. The project is designed to reinforce the concepts of memory management, process management and processor management that are discussed in most Operating Systems texts. Each student is to design and write a program that will simulate these major components of an operating system. This project is presented to the student in 3 phases and is written in Pascal although it can be adapted to other languages. The first phase requires the design of memory management routines for an operating system which schedules jobs through the use of a combined round robin/FIFO philosophy. The major concerns are the allocation and deallocation of memory pages as programs are submitted to the system and are removed from the system as they finish. The second phase takes into account various scheduling techniques, I/O requests, and swapping. Having already worked out the bugs in the memory management routines, the student now must be concerned with the management of the jobs that pass through the system. The third and last phase is the implementation of job synchronization. Several events are described, any of which may be the object of a WAIT or SIGNAL directive issued by an executing program. The project must synchronize jobs that issue a WAIT and SIGNAL directive on the same event. The project is part of a 3 credit course in Operating Systems taught to Juniors and Seniors. Successful completion of the project includes not only the correct implementation of a well documented and logically designed operating system, but also a comparative study, within each phase, of the efficiency and effectiveness of the operating system as a variety of parameters, which describe the environment, are changed. Observations are submitted in a report that is required with each phase.
An algorithm for concurrency control and recovery in replicated distributed databases
Authors: Philip A. Bernstein, Nathan Goodman
Venue: ACM Transactions on Database Systems (TODS) (1984)

In a one-copy distributed database, each data item is stored at exactly one site. In a replicated database, some data items may be stored at multiple sites. The main motivation is improved reliability: by storing important data at multiple sites, the DBS can operate even though some sites have failed. This paper describes an algorithm for handling replicated data, which allows users to operate on data so long as one copy is &ldquo;available.&rdquo; A copy is &ldquo;available&rdquo; when (i) its site is up, and (ii) the copy is not out-of-date because of an earlier crash. The algorithm handles clean, detectable site failures, but not Byzantine failures or network partitions.
Demand driven simulation: BACKSIM
Authors: S. P. Smith, M. R. Mercer, B. Brodk
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

A new digital simulation algorithm is presented based on the concept of demand driven simulation. Where traditional event driven simulation propagates signal values forward through a circuit in response to input pin events, demand driven simulation propagates requests for simulation values backwards both through the circuit and through time. In this manner, only those evaluations required to obtain &ldquo;watched&rdquo; signal values are performed. BACKSIM, the simulator based on this algorithm, has proven to be faster and more efficient than event driven simulation for every test case tried to date.
An Efficient Memory System for Image Processing
Authors: Jong Won Park
Venue: IEEE Transactions on Computers (1986)

Image processing operations require that an image or partial image be stored in a memory system that permits access to p × q, 1 × pq, and/or pq × 1 subarrays of an image array where p and q are design parameters.
A high performance routing engine
Authors: T. D. Spiers, D. A. Edwards
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

A hardware architecture for implementing Lee based routing algorithms is described. The design features hardware implementations of the main data structures and parallelism among a number of specialised processing elements. An engine based on this architecture has been constructed which executes a sophisticated cost-based algorithm 40 times faster than a VAX 11/780.
Query optimization by simulated annealing
Authors: Yannis E. Ioannidis, Eugene Wong
Venue: ACM SIGMOD Record (1987)

Query optimizers of future database management systems are likely to face large access plan spaces in their task. Exhaustively searching such access plan spaces is unacceptable. We propose a query optimization algorithm based on simulated annealing, which is a probabilistic hill climbing algorithm. We show the specific formulation of the algorithm for the case of optimizing complex non-recursive queries that arise in the study of linear recursion. The query answer is explicitly represented and manipulated within the closed semiring of linear relational operators. The optimization algorithm is applied to a state space that is constructed from the equivalent algebraic forms of the query answer. A prototype of the simulated annealing algorithm has been built and few experiments have been performed for a limited class of relational operators. Our initial experience is that, in general, the algorithm converges to processing strategies that are very close to the optimal. Moreover, the traditional processing strategies (e.g., the semi-naive evaluation) have been found to be, in general, suboptimal.
An approach for assessing software prototypes
Authors: VE Church, D N Card, W W Agresti, Q L Jordan
Venue: ACM SIGSOFT Software Engineering Notes (1986)

A procedure for evaluating a software prototype is presented. The need to assess the prototype itself arises from the use of prototyping to demonstrate the feasibility of a design or development strategy. The assessment procedure can also be of use in deciding whether to evolve a prototype into a complete system. The procedure consists of identifying evaluation criteria, defining alternative design approaches, and ranking the alternatives according to the criteria.
An object-oriented user interface management system
Authors: John L. Sibert, William D. Hurley, Teresa W. Bleser
Venue: Proceedings of the 13th annual conference on Computer graphics and interactive techniques (1986)

The George Washington User Interface Management System (GWUIMS) has been designed as a test bed for comparing user interface models, as a tool for rapidly prototyping highly interactive graphic user interfaces, and as a vehicle for investigating the applicability of knowledge-based technology to user interface design. The GWUIMS was designed and implemented using the object-oriented programming paradigm and consists of a variety of object classes representing different levels of abstraction, Responsibility for lexical, syntactic, and semantic levels of both input parsing and feedback are distributed throughout these classes. We include a description of the GWUIMS and a brief scenario to demonstrate its capabilities. A description of the implementation is followed by a discussion of the future application of knowledge representation techniques and the evolution towards an intelligent assistant for the user interface designer.
Modern introductory computer science
Authors: Peter Henderson
Venue: Proceedings of the eighteenth SIGCSE technical symposium on Computer science education (1987)

There have been numerous testimonies to the inadequacies of our educational system [83]. For undergraduate computer science educators, major concerns regarding student preparation include poor problem solving and critical thinking skills, weak mathematics background, an inability to convey thoughts and concepts, and a lack of motivation. These problems can be addressed in the introductory computer science course by developing an integrated approach to effectively teaching discrete mathematical foundations, fundamental computer science concepts, and problem-solving skills. This paper is conceptual in nature and introduces some specific examples of possible approaches to overcoming these deficiencies and problems.
Automated Protocol Validation in Argos: Assertion Proving and Scatter Searching
Authors: Gerard J. Holzmann
Venue: IEEE Transactions on Software Engineering (1987)

Argos is a validation language for data communication protocols. To validate a protocol, a model in Argos is constructed consisting of a control flow specification and a formal description of the correctness requirements. This model can be compiled into a minimized lower level description that is based on a formal model of communicating finite state machines. An automated protocol validator trace uses these minimized descriptions to perform a partial symbolic execution of the protocol to establish its correctness for the given requirements.
A LOTOS Specification of the PROWAY Highway Service
Authors: V Carchiolo, A Faro, O Mirabella, G Pappalardo, G Scollo
Venue: IEEE Transactions on Computers (1986)

The Language for temporal ordering specification (LOTOS) is a formal description technique whose development is under way within ISO, the International Organization for standardization, mainly for application to open systems interconnection (OSI) standards. The paper presents a LOTOS specification of the PROWAY interface for process control applicatioins, defined by IEC, the International Electrotechnical Commision. LOTOS is shown to be tailored for the specification of asynchronous systems. In particular, it proves suitable for the specification both of the services which define an interface and of the protocols which implement it. The paper shows how LOTOS supports formal reasoning aimed at establishing consistency between service and protocol specifications. Two examples of such a verification are developed that are related to the PROWAY interface. Finally, advantages and limitations of this approach are outlined.
Yes, software reliability can be measured and predicted
Authors: M. L. Shooman
Venue: Proceedings of the 1987 Fall Joint Computer Conference on Exploring technology: today and tomorrow (1987)

This paper complements the others presented in this session. It provides additional examples of the success of software reliability modeling culled from the literature. In addition it discusses the practical and theoretical steps which must be pursued to advance software reliability modeling. The main conclusion is that existing software reliability models are adequate for prediction and should now be more widely used.
Using the re-export paradigm to build composable Ada software components
Authors: Bryce M. Bardin, Christopher J. Thompson
Venue: ACM SIGAda Ada Letters (1988)

In the construction of reusable software components, transitive composability of parameterized abstractions is important for achieving the functionality desired. We have argued in a previous paper ("Composable Ada Software Components and the Re-Export Paradigm", which was published in a preceding issue of Ada Letters) that the paradigm we call "re-export" is the best technique for building robust, composable components in Ada which come close to meeting our standards for software quality. That paper discusses in detail the techniques which Ada provides that are appropriate for composing abstractions using re-export and the difficulties which are encountered in their construction. Because we do not have the space to recapitulate here, our previous paper must be read to provide the necessary context for understanding this one.A concrete example of re-export is presented here in which we attempt to design an abstraction using composable components. After analyzing the successes and shortcomings of this example, we conclude by presenting our view of the current realities of composition in Ada and outlining the general requirements for effective composition of software in Ada.
Efficient recompilation of module interfaces in a software development environment
Authors: Hausi A Muller, Robert Hood, Ken Kennedy
Venue: Proceedings of the second ACM SIGSOFT/SIGPLAN software engineering symposium on Practical software development environments (1987)

This paper presents global interface analysis algorithms that analyze and limit the effects of an editing change to a basic interface of a software system. The algorithms improve on the deficiencies of the traditional compilation rule found in strongly-typed, separately-compiled programming languages, which often forces the recompilation of modules that are not at all affected by a change to a basic interface. The algorithms assume a software development environment that provides efficient access to the compilation dependencies and the module interfaces of the components being implemented. The algorithms are designed to operate on recursive compilation dependencies since separate compilation of recursive inter-module dependencies can easily be implemented in such an environment.
An inference model for inheritance hierarchies with exceptions
Authors: K Whitebread
Venue: Proceedings of the ACM SIGART international symposium on Methodologies for intelligent systems (1986)

We present a definition of property inheritance with exceptions in terms of a formal model of default reasoning called nonconclusive reasoning. Our model resolves both types of ambiguity encountered in inheritance with exceptions and avoids the need for explicit exceptions without resorting to extralogical mechanisms to derive them.
A modular verifiable exception handling mechanism
Authors: Shaula Yemini, Daniel M. Berry
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1985)

This paper presents a new model for exception handling, called the replacement model. The replacement model, in contrast to other exception-handling proposals, supports all the handler responses of resumption, termination, retry, and exception propagation, within both statements and expressions, in a modular, simple, and uniform fashion. The model can be embedded in any expression-oriented language and can also be adapted to languages which are not expression oriented with almost all the above advantages. This paper presents the syntactic extensions for embedding the replacement model into Algol 68 and its operational semantics. An axiomatic semantic definition for the model can be found in [27].
A new efficient motion-planning algorithm for a rod in polygonal space
Authors: S Sifrony, M Sharir
Venue: Proceedings of the second annual symposium on Computational geometry (1986)

We present here a new and efficient algorithm for planning collision-free motion of a rod in the plane amidst polygonal obstacles. The algorithm calculates the boundary of the space of free positions of the rod, and then uses this boundary for determining the existence of required motions. The algorithm runs in time &Ogr;(K log n) where n is the number of obstacle corners and where K is the total number of pairs of obstacle walls or corners lying from one another at distance less than or equal to the length of the rod. Since K = &Ogr;(n2), the algorithm has the same worst-case complexity as the best previously developed algorithm of Leven and Sharir [LS1], but if the obstacles are not too cluttered together it will run much more efficiently.