ppxscal/embedding_network huggingface dataset:
An object-oriented approach to multimedia databases
Authors: Darrell Woelk, Won Kim, Willis Luther
Venue: ACM SIGMOD Record (1986)

This paper identifies data modelling and data access and sharing requirements which multimedia applications impose on a database system. It shows the capabilities of an object-based data model and indicates extensions which are needed to meet the data modelling aspects of these requirements. A logical implementation of the operations on the model is described. The model generalizes the notions of instantiation and generalization in the standard object-oriented paradigm, and augments it with the notions of aggregation and relationships which are specialized for a multimedia application environment. Objects may exist in aggregation hierarchies which provide the capability to integrate diverse types of multimedia information such as text, sound, bit-mapped images, and complex graphics drawings. Objects may also be linked through other user-defined relationships to capture such application functions as voice annotation and referencing of one document by another. Using this model, the semantics of aggregation and relationships in a multimedia application environment can be understood and efficiently supported by a database system.
Deferred data structuring: Query-driven preprocessing for geometric search problems
Authors: R Motwani, P Raghavan
Venue: Proceedings of the second annual symposium on Computational geometry (1986)

We consider the problem of answering a series of on-line queries on a static database. The conventional approach to such problems involves a preprocessing phase which constructs a data structure with good search behavior. The data structure is then used to process a series of queries without any further reordering. Our approach involves dynamic or query-driven structuring of the database, i.e. we process the database only when it is required for answering a query. We present optimal algorithms for the following problems in the plane: testing convex hull membership, half-plane intersection queries and fixed-constraint multi-objective linear programming. This technique is also applied to multidimensional dominance query problems.
Pictorial representations of abstract concepts relating to human-computer interaction
Authors: Yvonne Rogers
Venue: ACM SIGCHI Bulletin (1986)

Recently, there has been a growing trend to develop interfaces which incorporate icons and various other visual symbols to represent system information. The idea behind this trend is that visual symbols can help reduce the complexity of the system and make it easier to understand and use. A problem with substituting this form of graphic interfacing for existing verbal command languages, however, is the extent to which abstract concepts, which underlie the operation of most systems, can be effectively represented in a graphic form that is both meaningful and discriminable.
Addressable WSI: a non-redundant approach
Authors: Gilman Chesley
Venue: ACM SIGARCH Computer Architecture News (1987)

A taxonomy of configuration techniques for WSI is discussed and a metric for WSI efficiency is derived. A technique called addressable WSI is described which uses addresses to reference only good modules. By not addressing bad modules, fault-tolerance is achieved without redundancy in the conventional sense. It is argued that memory WSI avoids most of the problems of WSI construction and use.
GALILEO: a strongly-typed, interactive conceptual language
Authors: Antonio Albano, Luca Cardelli, Renzo Orsini
Venue: ACM Transactions on Database Systems (TODS) (1985)

Galileo, a programming language for database applications, is presented. Galileo is a strongly-typed, interactive programming language designed specifically to support semantic data model features (classification, aggregation, and specialization), as well as the abstraction mechanisms of modern programming languages (types, abstract types, and modularization). The main contributions of Galileo are (a) a flexible type system to model database structure and semantic integrity constraints; (b) the inclusion of type hierarchies to support the specialization abstraction mechanisms of semantic data models; (c) a modularization mechanism to structure data and operations into interrelated units (d) the integration of abstraction mechanisms into an expression-based language that allows interactive use of the database without resorting to a new stand-alone query language. Galileo will be used in the immediate future as a tool for database design and, in the long term, as a high-level interface for DBMSs.
APL function definition notation
Authors: John Bunda
Venue: Proceedings of the international conference on APL: APL in transition (1987)

A pure functional notation for defining APL objects is described, and constructed with previous work in this area. The notation is extended to address both theoretical and pragmatic programming considerations. The notation is compatible with existing implementations, and is shown to straightforwardly incorporate popular extensions to the language.
Address resolution for an intelligent filtering bridge running on a subnetted ethernet system
Authors: G. Parr
Venue: ACM SIGCOMM Computer Communication Review (1987)

When a generic host goes down or moves on a subnetted configuration on Ethernets running, for example TCP/IP, and comes back up again, with either a completely new network interface, or a newly assinged protocol address, this information is not currenlty available to remote hosts/devices on the system. What I propose here is a facility whereby all connected systems can be informed of this "REBOOT" situation as soon as it is detected by its neighbouring Bridge. This way, subsequent redundant, and wasteful transmissions can be prevented taking place from remote sources to 'unobtainable' hosts. A broadcast medium such as Ethernet is assumed.
A :20piano movers' '
Authors: J H Davenport
Venue: ACM SIGSAM Bulletin (1986)

As has been pointed out [Schwartz amp; Sharir, 1983b], various problems of motion planning can be expressed as cylindrical algebraic decompositions [Collins, 1975; Arnon et al., 1984]. The purpose of this note is to discuss a particularly simple such problem, and show what actually happens during the decomposition (as far as we could take it). There is no pretence at originality, except perhaps in the conclusions.
Limitations of concurrency in transaction processing
Authors: Peter Franaszek, John T. Robinson
Venue: ACM Transactions on Database Systems (TODS) (1985)

Given the pairwise probability of conflict p among transactions in a transaction processing system, together with the total number of concurrent transactions n, the effective level of concurrency E(n,p) is defined as the expected number of the n transactions that can run concurrently and actually do useful work. Using a random graph model of concurrency, we show for three general classes of concurrency control methods, examples of which are (1) standard locking, (2) strict priority scheduling, and (3) optimistic methods, that (1) E(n, p) &les; n(1 - p/2)n-1, (2) E(n, p) &les; (1 - (1 - p)n)/p, and (3) 1 + ((1 - p)/p)ln(p(n - 1) + 1) &les; E(n, p) &les; 1 + (1/p)ln(p(n - 1) + 1). Thus, for fixed p, as n &rarrtl; &infin;), (1) E &rarrtl; 0 for standard locking methods, (2) E &les; 1/p for strict priority scheduling methods, and (3) E &rarrtl; &infin; for optimistic methods. Also found are bounds on E in the case where conflicts are analyzed so as to maximize E. The predictions of the random graph model are confirmed by simulations of an abstract transaction processing system. In practice, though, there is a price to pay for the increased effective level of concurrency of methods (2) and (3): using these methods there is more wasted work (i.e., more steps executed by transactions that are later aborted). In response to this problem, three new concurrency control methods suggested by the random graph model analysis are developed. Two of these, called (a) running priority and (b) older or running priority, are shown by the simulation results to perform better than the previously known methods (l)-(3) for relatively large n or large p, in terms of achieving a high effective level of concurrency at a comparatively small cost in wasted work.
A simple on-line bin-packing algorithm
Authors: C. C. Lee, D. T. Lee
Venue: Journal of the ACM (JACM) (1985)

The one-dimensional on-line bin-packing problem is considered, A simple O(1)-space and O(n)-time algorithm, called HARMONICM, is presented. It is shown that this algorithm can achieve a worst-case performance ratio of less than 1.692, which is better than that of the O(n)-space and O(n log n)-time algorithm FIRST FIT. Also shown is that 1.691 &hellip; is a lower bound for all 0(1)-space on-line bin-packing algorithms. Finally a revised version of HARMONICM , an O(n)-space and O(n)- time algorithm, is presented and is shown to have a worst-case performance ratio of less than 1.636.d
Implementation of logical query languages for databases
Authors: Jeffrey D. Ullman
Venue: ACM Transactions on Database Systems (TODS) (1985)

We examine methods of implementing queries about relational databases in the case where these queries are expressed in first-order logic as a collection of Horn clauses. Because queries may be defined recursively, straightforward methods of query evaluation do not always work, and a variety of strategies have been proposed to handle subsets of recursive queries. We express such query evaluation techniques as &ldquo;capture rules&rdquo; on a graph representing clauses and predicates. One essential property of capture rules is that they can be applied independently, thus providing a clean interface for query-evaluation systems that use several different strategies in different situations. Another is that there be an efficient test for the applicability of a given rule. We define basic capture rules corresponding to application of operators from relational algebra, a top-down capture rule corresponding to &ldquo;backward chaining,&rdquo; that is, repeated resolution of goals, a bottom-up rule, corresponding to &ldquo;forward chaining,&rdquo; where we attempt to deduce all true facts in a given class, and a &ldquo;sideways&rdquo; rule that allows us to pass results from one goal to another.
Missing information (applicable and inapplicable) in relational databases
Authors: E. F. Codd
Venue: ACM SIGMOD Record (1986)

There has been some technical and justified criticism of the treatment of missing information in the data sublanguage SQL and in IBM's Database 2 system (a relational database management system). Some of this criticism has been directed (by mistake) at the relational model. The purpose of this paper is to clarify and extend the treatment of missing information by the relational model. The clarification places heavy emphasis on the semantic aspects of missing information. The extension, which is relatively minor, provides a systematic approach (independent of data type) to dealing with the inapplicability of certain properties to some objects. This extension does not invalidate any part of the present version of the relational model.
MMAIM: a software development method for Ada
Authors: J. Carter
Venue: ACM SIGAda Ada Letters (1988)

Traditional methods for software development fail to make use of Ada's unique features to support software engineering principles. Several methods have been proposed to overcome this problem, but shortcomings have been identified with all of them. A method for Ada software development is presented which avoids the shortcomings of existing methods. Further work required on the method is also discussed.
Enriched knowledge representation for information retrieval
Authors: F. N. Teskey
Venue: Proceedings of the 10th annual international ACM SIGIR conference on Research and development in information retrieval (1987)

In this paper we identify the need for a new theory of information. An information model is developed which distinguishes between data, as directly observable facts, information, as structured collections of data, and knowledge as methods of using information. The model is intended to support a wide range of information systems. In the paper we develop the use of the model for a semantic information retrieval system using the concept of semantic categories. The likely benefits of this area discussed, though as yet no detailed evaluation has been conducted.
The roles of a SQA person
Authors: F. J. Buckley
Venue: ACM SIGSOFT Software Engineering Notes (1987)

This paper identifies the three major roles of an SQA (Software Quality Assurance) professional, discusses the major obstacles encountered in performing each role, and provides recommendations to alleviate the associated difficulties.
Parallel free-text search on the connection machine system
Authors: Craig Stanfill, Brewster Kahle
Venue: Communications of the ACM (1986)

A new implementation of free-text search using a new parallel computer&mdash;the Connection Machine&reg;&mdash;makes possible the application of exhaustive methods not previously feasible for large databases.
Infinite loops and how to create them
Authors: John R. Searle
Venue: ACM SIGAPL APL Quote Quad (1987)

Infinite loops are the worst enemy of any programmer in any language. They waste potentially huge amounts of time, system resources and/or money, and can destroy the credibility of the programmer amongst colleagues or customers. In APL, infinite loops can potentially occur wherever a loop is present. However, they can also occur wherever any branching statement is used, and can even occur where no branching instructions have been used. In order to avoid infinite loops, the programmer is best equipped if he/she is aware of all of the possible ways in which they may be created. An APL function is also presented which will give programmers new to the language a means whereby most infinite loops can be avoided in their training phase.
Design and implementation in object-oriented simulation
Authors: Jean Bezivin
Venue: ACM SIGSIM Simulation Digest (1988)

This document intends to emphasize some important issues about the required qualities of simulation software. It will be argued firstly that the need for readability is much more important for simulation programs than for general software and secondly that the need for high efficiency is rapidly increasing. We shall then discuss how the object-oriented paradigm may help to meet these mutually dependent requirements in various ways.
An expert system for screening employee pension plans for the Internal Revenue Service
Authors: G. Grdy, R. S. Patil
Venue: Proceedings of the 1st international conference on Artificial intelligence and law (1987)

This paper describes the development of an expert system demonstration prototype for identifying legal issues within the domain of employee pension plans. Pension plans are submitted by employers to the Internal Revenue Service for approval as to content, and obtain subsequent tax advantages. The prototype is able to identify and analyze legal issues, reach conclusions about a plan's conformity with the issues identified, and provide an explanation of the conclusions reached by the system. Success in the program's ability to identify and explain legal issues was determined by comparing the system's conclusions with those of an expert in the field.
A reliable datagram protocol on local area networks
Authors: D Lee, K Chon, C Chung
Venue: Proceedings of the ACM SIGCOMM conference on Communications architectures protocols (1986)

Most of interprocess communications in transaction oriented distributed systems are based on client-server model, in which one process communicates with several processes simultaneously. Datagram service fits this type of communication rather than virtual circuit service. Transaction oriented distributed systems sometimes need to move large data such as a file or a part of database from a machine to other. The reliable delivery is fairly important since an error might cause retransmission of a whole data. In this paper, we propose the efficient mechanism for reliable datagram service, i) the concept of semi-virtual circuit and ii) the simple error detection and recovery algorithm based on our existing transport protocol, UDSTP. We describe implementation details supporting those facilities and performance results.
A simple divide-and-conquer algorithm for computing Delaunay triangulations in O(n log log n) expected time
Authors: R A Dwyer
Venue: Proceedings of the second annual symposium on Computational geometry (1986)

We present a modification to the divide-and-conquer algorithm of Guibas Stolfi [GS] for computing the Delaunay triangulation of n sites in the plane. The change reduces its &THgr;(n log n) expected running time to &Ogr;(n log n) for a large class of distributions which includes the uniform distribution in the unit square. The modified algorithm is significantly easier to implement than the optimal linear-expected-time algorithm of Bentley, Weide Yao [BWY]. Unlike the incremental methods of Ohya, Iri Murota [OIM] and Maus [M] it has optimal &Ogr;(n log log n) worst-case performance. The improvement extends to the composition of the Delaunay triangulation in the Lp metric for 1 < p &le; &infin;. Experimental evidence presented demonstrates that in the Euclidean case the modified algorithm performs very well for n &le; 216, the range of the experiments. We conjecture that its average running time is no more than twice optimal for n less than seven trillion.
CCAL: an interpreted language for experimentation in concurrent control
Authors: P. Kearns, M. Freeman
Venue: Papers of the Symposium on Interpreters and interpretive techniques (1987)

Concurrent Control Abstraction Language, CCAL, is an interpreted language which provides no particular control regime to the user. CCAL instead supports five primitive operations which manipulate an abstract model of inter-procedural control. This model is intrinsically concurrent, and the user is allowed to construct high-level concurrent control operations from the primitives (hence, control abstraction). The primary use of CCAL is as a vehicle by which rapid prototyping of application specific control forms may be done and as a tool for the construction and evaluation of novel control forms, especially control forms for highly concurrent and distributed systems. The CCAL interpreter is implemented as a distributed program on a network of Vaxen and Sun-3 workstations under 4.2bsd and 4.3bsd Unix1. CCAL programs appear as multi-process programs in a shared memory system. Both true and apparent concurrency are possible. This paper describes the control abstraction facilities offered by the CCAL interpreter, its use, and implementation strategies in the distributed environment.
TEXT: Publication-quality characters come to APL graphics
Authors: Ian Feldberg
Venue: ACM SIGAPL APL Quote Quad (1986)

An APL workspace named TEXT has been developed to generate publication-quality characters for use with several APL plotting packages, both on the mainframe and on the PC. TEXT is written in APL and is very simple to use. The fonts supplied are based on the Hershey fonts - a well known public-domain digitization of over 20 character fonts. The user is provided with several functions that construct the vectors for plotting a character string (vectors signifying move and draw locations) &mdash; including lower-level functions that are more flexible for certain applications. Some of these functions are: rotating, scaling, justifying, underlining and changing style of text strings. Greek, Italic, Russian, Gothic, Math, Weather, and Music symbols are just a few of the character sets available. A modified version is described for APL21, which uses mixed arrays as input.
Editing by example
Authors: Robert P. Nix
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1985)

An editing by example system is an automatic program synthesis facility embedded in a text editor that can be used to solve repetitive text editing problems. The user provides the editor with a few examples of a text transformation. The system analyzes the examples and generalizes them into a program that can perform the transformation to the rest of the user's text. This paper presents an overview of the design, analysis, and implementation of a practical editing by example system. It studies the problem of synthesizing a text processing program that generalizes the transformation implicitly described by a small number of input/output examples. A class of text processing programs called gap programs is defined and the problems associated with synthesizing them from examples are examined, leading to an efficient heuristic that provably synthesizes a gap program from examples of its input/output behavior. The editing by example system derived from this analysis has been embedded in a production text editor. By developing an editing by example system that solves a useful class of text processing problems, this work demonstrates that program synthesis is feasible in the domain of text editing.
The Ubik configurator
Authors: Peter de Jong
Venue: Proceedings of the ACM SIGOIS and IEEECS TC-OA 1988 conference on Office information systems (1988)

Ubik is a system within which organizational structure, concepts, and actions are described and organizational applications are executed. Ubik represents an organization not with one global model, but with multiple overlapping models which can be physically distributed within multiple knowledge bases. There is a basic computational object in Ubik called the Ubik Configurator. The Configurator is used to specify organizational concepts, handlers, goals, and constraints. Configurators are linked together in lattices within a model. There are different types of models built using the configurator. Ubik models support the communication between distributed applications and the control of the parallel execution of applications. Development models support the continual evolution necessary in a large organization to cope with the changing external environment. Due process models support the resolving of conflicts between conflicting models. Organizational models describe the end-users organization and applications.
Virtual copies: at the boundary between classes and instances
Authors: Sanja Mittal, Daniel G. Bobrow, Kenneth M. Kahn
Venue: ACM SIGPLAN Notices (1986)

Knowledge bases built in object-oriented systems use networks of interconnected objects in their representations. The mechanism described here provides a way to use such a network as a prototype by making virtual copies of it. The virtual copy is created incrementally. Values of instance variables in the virtual copy are inherited from the prototype until locally overridden in the copy, similar to inheritance of defaults between instances and classes in Loops. A virtual copy preserves the topology of the original network. Virtual copies can be made from virtual copies. Alternative implementations of virtual copies allow different tradeoffs in space and lookup time. Virtual copies can be used for building knowledge bases for design, for representing contexts in a problem solving system, and have other uses in ordinary programming.
Group Properties of Cellular Automata and VLSI Applications
Authors: W Pries, A Thanailakis, C Card
Venue: IEEE Transactions on Computers (1986)

The study of one-dimensional cellular automata exhibiting group properties is presented. The results show that only a certain class of cellular automata rules exhibit group characteristics based on rule multiplication. However, many other of these automata reveal groups based on permutations of their global states. It is further shown how these groups may be utilized in the design of modulo arithmetic units. The communication properties of cellular automata are observed to map favorably to optimal communication graphs for VLSI layouts. They exploit the implementation medium and properly address the physical limits on computational structures. Comparisons of cellular automata-based modulo arithmetic units with other VLSI algorithms are presented using area-time complexity measures.