ppxscal/embedding_network huggingface dataset:
Query processing techniques in the summary-table-by-example database query language
Authors: Gultekin Özsoyoğlu, Victor Matos, Meral Özsoyoğlu
Venue: ACM Transactions on Database Systems (TODS) (1989)

Summary-Table-by-Example (STBE) is a graphical language suitable for statistical database applications. STBE queries have a hierarchical subquery structure and manipulate summary tables and relations with set-valued attributes. The hierarchical arrangement of STBE queries naturally implies a tuple-by-tuple subquery evaluation strategy (similar to the nested loops join implementation technique) which may not be the best query processing strategy. In this paper we discuss the query processing techniques used in STBE. We first convert an STBE query into an &ldquo;extended&rdquo; relational algebra (ERA) expression. Two transformations are introduced to remove the hierarchical arrangement of subqueries so that query optimization is possible. To solve the &ldquo;empty partition&rdquo; problem of aggregate function evaluation, directional join (one-sided outer-join) is utilized. We give the algebraic properties of the ERA operators to obtain an &ldquo;improved&rdquo; ERA expression. Finally we briefly discuss the generation of alternative implementations of a given ERA expression. STBE is implemented in a prototype statistical database management system. We discuss the STBE-related features of the implemented system.
Address space virtualization in reconfigurable computers
Authors: D. A. Cañas
Venue: Proceedings of the 17th conference on ACM Annual Computer Science Conference (1989)

Operating Systems virtualize the execution environment of a task by managing the available resources of the system. On traditional architectures a task executes on a static environment, i.e. every instant of a task will be carried upon a fixed set of physical resources. In reconfigurable computers the availability of resources and thus the physical environment upon which a task executes may vary for different executions of a task as well as during the execution of the task. The execution of a task must be independent of configuration. This paper discusses the virtualization of the address space of a task executing in a reconfigurable environment.
A unified approach for multilevel database security based on inference engines
Authors: Linda M. Null, Johnny Wong
Venue: ACM SIGCSE Bulletin (1989)

A multilevel relational database system handles data at different security classifications and provides access to users with different security clearances. Many methods for enforcing security in this environment have been investigated. This paper presents a unified approach to multilevel database security based on two ideas: a trusted filter and an inference engine. These two approaches are introduced separately and then the motivation for the unified system and the system model itself are presented.
An outline of a general model for information retrieval systems
Authors: J. Nie
Venue: Proceedings of the 11th annual international ACM SIGIR conference on Research and development in information retrieval (1988)

This paper is a contribution to the construction of a general model for information retrieval. As in the paper of Van Rijsbergen ([RIJ86]), the implicit base in all information retrieval systems is considered as a logical implication. The measure of correspondence between a document and a query is transformed into the estimation of the strength (or certainty) of logical implication. The modal logics will show its suitability for representing the behavior of information retrieval systems. In existing Information Retrieval models, several aspects are often mixed. A part of this paper is contributed to separate these aspects to give a clearer view of information retrieval systems. This general model is also compared with some existing models to show its generality.
Evaluating Software Design Processes by Analyzing Change Data Over Time
Authors: L. J. Chmura, T. J. Wicinski, A. F. Norcio
Venue: IEEE Transactions on Software Engineering (1990)

An analysis is presented of early design and code change data from the software cost reduction (SCR) project, a well-reported effort conducted at the US Naval Research Laboratory from 1978 to 1988. The analyses are mostly time-based studies of the change data and relationships between the data and SCR personnel activity data. Some analyses of the change data show patterns consistent with a major goal of the SCR project: the design and development of easy-to-change software. Specifically, most changes took a day or less to uncover and resolve; the majority of changes updated at most one module. Moreover, these percentages remained fairly stable. No positive relationship appeared between error-correction effort and the number of days that an error remained in the SCR design documentation. Other analyses suggest that consistency may have been temporary. For example, the analyses suggest a stepwise growth in average change effort, and an increasing percentage of changes resulted in module interface updates. Certain specific ratios between SCR change data and personnel activity data may be possible indicators of design incompleteness.
Control and coordination policies for systems with buffers
Authors: D. Mitra, I. Mitrani
Venue: Proceedings of the 1989 ACM SIGMETRICS international conference on Measurement and modeling of computer systems (1989)

We study systems consisting of a number of service cells in tandem, each containing a finite buffer. Several policies governing the operation of such systems are described and compared. These include traditional and novel blocking schemes, with applications to computer communications and production lines. In particular, it is shown that kanban, a novel discipline for coordinating cells in a manufacturing context, is obtained by combining two, more basic, concepts: a blocking policy introduced here as minimal blocking, and shared buffers. The Kanban discipline is superior in terms of throughput to the ordinary transfer blocking policy. A method for analyzing approximately the performance of the Kanban system is also presented. This is based on examining first a single cell in isolation and then combining the isolated cells through fixed-point equations. Some numerical results and comparisons with simulations are included.
What best predicts computer proficiency?
Authors: Gerald E. Evans, Mark G. Simkin
Venue: Communications of the ACM (1989)

Identifying variables that predict computer aptitude can help educators and employers target potential students and employees. The authors examine a number of possible explanatory variables including demographic profiles, high school achievements, prior computer training and experience, cognitive styles, and problem-solving abilities.
Algorithms for the reduction of timed finite state graphs
Authors: G. H. Masapati, G. M. White
Venue: Proceedings of the ACM workshop on Frontiers in computer communications technology (1987)

A set of algorithms to reduce the size of timed finite state graphs are presented. In particular, we develop a more general algorithm for vertex folding than those presently existing. It is based on the law of conservation of transition time. We demonstrate the application of these reduction algorithms to a version of the stop-and-wait protocol. We have also developed a graph reduction software package incorporating all these algorithms which can be used in automated performance prediction. Graph reduction software tools such as these are important and form an integral part of automated protocol performance prediction tools[RUD 83].
Dependence of multi-dimensional array references
Authors: D. R. Wallace
Venue: Proceedings of the 2nd international conference on Supercomputing (1988)

Accurate data dependence analysis is the key function in vectorizing-restructuring compilers for supercomputers. However, the data dependence analysis algorithms currently available have limitations. Those that execute quickly, such as the Banerjee Test [3], [4], [21] are very limited in generality. Those that are general are too slow. 1 Compiler designers have been keenly aware of the need for an algorithm that is both general and fast. The algorithm that follows fills this need simply and uniformly. Aside from fast execution, this algorithm has three main features: It can deal with arbitrary linear constraints whose variables are not limited to loop-control variables It can deal with any number of these linear constraints simultaneously. It only looks at integer solutions. The algorithm organizes the multiple constraints into a constraint matrix and uses a method derived from linear programming techniques. We refer to this as the Constraint-Matrix algorithm. Burke and Cytron [6] have discussed linearization to deal with arrays of greater than one dimension. This approach was also referred to by Towle [18]. Linearization is limited unless additional constraints are added; it cannot deal with arbitrary additional constraints and it does not restrict its solutions to integers. The Constraint-Matrix algorithm is organized specifically for a goal that is different from the standard linear programming problem. This goal is to prove the lack of a solution [i.e. the lack of a dependence) rather than minimize an &ldquo;objective function.&rdquo; further, this algorithm is designed to &ldquo;short-circuit&rdquo; when its goal is reached, in a way that a standard linear programming algorithm cannot. In order to simplify the exposition, we begin with a precise definition of dependence. To provide some motivation for the later algorithm and to show the advantages of the matrix format, we then present two special case methods (Solvable-Matrix and Matrix-GCD). Finally we present the Constraint-Matrix algorithm.
A Specification and Verification Method for Preventing Denial of Service
Authors: Che-Fn Yu, V. D. Gligor
Venue: IEEE Transactions on Software Engineering (1990)

A specification and verification method is presented for preventing denial of service in absence of failures and of integrity violations. The notion of user agreements is introduced, and it is argued that lack of specifications for these agreements and for simultaneity conditions makes it impossible to demonstrate denial-of-service prevention, in spite of demonstrably fair service access. The use of this method is illustrated with an example and it is explained why current methods for specification and verification of safety and liveness properties of concurrent programs do not handle this problem. The proposed specification and verification method is meant to augment current methods for secure system design.
Development of the domain name system
Authors: P. Mockapetris, K. J. Dunlap
Venue: ACM SIGCOMM Computer Communication Review (1988)

The Domain Name System (DNS) provides name service for the DARPA Internet. It is one of the largest name services in operation today, serves a highly diverse community of hosts, users, and networks, and uses a unique combination of hierarchies, caching, and datagram access. This paper examines the ideas behind the initial design of the DNS in 1983, discusses the evolution of these ideas into the current implementations and usages, notes conspicuous surprises, successes and shortcomings, and attempts to predict its future evolution.
Near real-time shadow generation using BSP trees
Authors: Norman Chin, Steven Feiner
Venue: Proceedings of the 16th annual conference on Computer graphics and interactive techniques (1989)

This paper describes an object-space shadow generation algorithm for static polygonal environments illuminated by movable point light sources. The algorithm can be easily implemented on any graphics system that provides fast polygon scan-conversion and achieves near real-time performance for environments of modest size. It combines elements of two kinds of current shadow generation algorithms: two-pass object-space approaches and shadow volume approaches. For each light source a Binary Space Partitioning (BSP) tree is constructed that represents the shadow volume of the polygons facing it. As each polygon's contribution to a light source's shadow volume is determined, the polygon's shadowed and lit fragments are computed by filtering it down the shadow volume BSP tree. The polygonal scene with its computed shadows can be rendered with any polygon-based visible-surface algorithm. Since the shadow volumes and shadows are computed in object space, they can be used for further analysis of the scene. Pseudocode is provided, along with pictures and timings from an interactive implementation.
Routing and broadcasting in faulty hypercube computers
Authors: T. C. Lee, J. P. Hayes
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

This paper examines routing and broadcasting algorithms for hypercube computers subject to node failures. First some simple message-passing algorithms are described which perform well with certain fault patterns, but poorly with others. The concept of an unsafe node is introduced to identify fault-free nodes that may cause communication difficulties in faulty hypercubes. It is then shown that by only using &ldquo;feasible&rdquo; paths that try to avoid unsafe nodes, routing and broadcasting can be substantially simplified. It is assumed that each active node is supplied with the fault status of all neighboring nodes within a specified radius k. A computationally efficient routing algorithm is presented which can route a message via a path of length no greater than p+2, where p is the minimum feasible distance from the source to the destination, provided that not all non-faulty nodes in the hypercube are unsafe, and k = 1. We further show that broadcasting can be achieved under the same fault conditions with only one more time unit than the fault-free case.
Contextual design: an emergent view of system design
Authors: Dennis Wixon, Karen Holtzblatt, Stephen Knox
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Empowering people (1990)

We offer an introduction to contextual design as an emergent method for building effective systems. Contextual design addresses a number of the inadequacies in previous methods by emphasizing: interview methods conducted in the context of the user's work, codesigning with the user, building an understanding of work in context, and summarizing conclusions through out the research. We contrast this design method to usability engineering and artifact examination.
A Nonparametric Method for Fitting a Straight Line to a Noisy Image
Authors: B. Kamgar-Parsi, N. S. Netanyahu
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

In fitting a straight line to a noisy image, the least-squares method becomes highly unreliable either when the noise distribution is nonnormal or when it is contaminated by outliers. The authors propose a nonparametric method, the median of the intercepts, to overcome these difficulties. This method is free of assumptions about the noise distribution and insensitive to outliers, and it does not require quantization of the parameter space. Thus, unlike the Hough transform, its outcome does not depend on the bin size. The method is efficient and its implementation does not involve practical difficulties such as local minima or poor convergence of iterative procedures.
Kink-free deformations of polygons
Authors: G. Vegter
Venue: Proceedings of the fifth annual symposium on Computational geometry (1989)

We consider a discrete version of the Whitney-Graustein theorem concerning regular equivalence of closed curves. Two regular polygons P and P', i.e. polygons without overlapping adjacent edges, are called regularly equivalent if there is a continuous one-parameter family Ps, O &ge; s &le; 1 of regular polygons with Po = P and P1 = P'. Geometrically the one-parameter family is a kink-free deformation transforming P into P'. The winding number of a polygon is a complete invariant of its regular equivalence class. We develop a linear algorithm that determines a linear number of elementary steps to deform a regular polygon into any other regular polygon with the same winding number.
The conjecture of Fliess on commutative context-free languages
Authors: Juha Kortelainen
Venue: Journal of the ACM (JACM) (1989)

The conjecture of Fliess concerning commutative context-free languages is disproved using a counterexample.
Operations and Implementation of Complex Objects
Authors: Won Kim, Hong-Tia Chou, Jay Banerjee
Venue: IEEE Transactions on Software Engineering (1988)

A model of a complex object is presented and a set of meaningful operations, both basic and advanced, on a single complex object and on a configuration of complex objects is defined. A set of requirements is presented for storage subsystems that support complex objects. Implementation of complex objects and operations on a single complex object are described, and a detailed performance analysis is provided which establishes the merit of complex objects. Finally, storage techniques are proposed for supporting advanced operations on a configuration of complex objects.
&ldquo;Boyd V. Deaver - Litigation Strategies&rdquo; videodisc: an opportunity to improve curriculum and prototype expert systems
Authors: D. Burnstein
Venue: Proceedings of the 2nd international conference on Artificial intelligence and law (1989)

Once in a rare while we come across an environment that can illuminate several areas of inquiry. BOYD V. DEAVER: LITIGATION STRATEGIES is such a tool. The major original thesis of the paper is that using AI tools to gather the &ldquo;audit trails&rdquo; of case development strategies of experienced attorneys, and bringing them to the attention of law school professors would assist in curriculum assessment and development. The second aspect of the paper is a brief proposal to develop three expert systems and compare them.
Partitioning Techniques for Large-Grained Parallelism
Authors: R. Agrawal, H. V. Jagadish
Venue: IEEE Transactions on Computers (1988)

A model is presented for parallel processing in loosely coupled multiprocessing environments, such as networks of computer workstations, that are amenable to large-grained parallelism. The model takes into account the overhead involved in data communication to and from a remote processor and can be used to partition a large class of computations optimally, consisting of computations that can be organized as a one-level tree and are homogeneous and separable. The optimal partition can be determined for a given number processors, and, if required, the optimal number of processors to use can also be derived. Experimental results validate the model and demonstrate its effectiveness.
&ldquo;Combining&rdquo; as a compilation technique for VLIW architectures
Authors: T. Nakatani, K. Ebcioğlu
Venue: ACM SIGMICRO Newsletter (1989)

Combining is a local compiler optimization technique that can enhance the performance of global compaction techniques for VLIW machines. Given two adjacent operations of a certain class that are flow (read-after-write) dependent and that cannot be placed in the same micro-instruction, the combining technique can transform the operations so that the modified operations have no dependence. The transformed operations can be executed in the same micro-instruction, thus allowing the total execution time of the program to be reduced. In this paper, combining a pair of flow-dependent operations into a wide instruction word is suggested as an important compilation technique for VLIW architectures. Combining is particularly effective with software pipelining and loop unrolling since combinable operations can come together with a higher probability when these compilation techniques are used. We implemented combining in our parallelizing compiler for the wide instruction word architecture, which is now being built at the IBM T. J. Watson Research Center. It is shown that ten percent speedup is obtained on the Stanford integer benchmarks and other sequential-matured C programs, in comparison to compaction techniques that do not use combining. For a class of inner loops, combining can remove the inter-iteration dependencies completely and can improve performance in the same ratio as the loop is unrolled.
Requirements analysis for large Ada programs: lessons learned on CCPDS-R
Authors: C. Grauling
Venue: Proceedings of the conference on Tri-Ada '89: Ada technology in context: application, development, and deployment (1989)

This paper summarizes the experiences of the software requirements team on the Command Center Processing and Display System Replacement (CCPDS-R) program. The CCPDS-R program involves the development of large amount of command and control software while using a new approach to the entire software development process. The major challenges that the software requirements team faced include: performance constraints, dealing with uncertainty in a fixed price development environment, and incompatibility of the required deliverable documentation (as specified in DODSTD-2167) with real project needs. The techniques included: a small team with good tools, concurrent software development, extensive prototyping and performance modeling, and DID tailoring. The focus of this paper is on the process, techniques and tools that supported the critical front end of a successful large scale Ada development program.
QED on the connection machine
Authors: C. F. Baillie, S. L. Johnsson, L. Ortiz, G. S. Pawley
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

Physicists believe that the world is described in terms of gauge theories. A popular technique for investigating these theories is to discretize them onto a lattice and simulate numerically by a computer, yielding so-called lattice gauge theory. Such computations require at least 1014 floating-point operations, necessitating the use of advanced architecture supercomputers such as the Connection Machine made by Thinking Machines Corporation. Currently the most important gauge theory to be solved is that describing the sub-nuclear world of high energy physics: Quantum Chromo-dynamics (QCD). The simplest example of a gauge theory is Quantum Electro-dynamics (QED), the theory which describes the interaction of electrons and photons. Simulation of QCD requires computer software very similar to that for the simpler QED problem. Our current QED code achieves a computational rate of 1.6 million lattice site updates per second for a Monte Carlo algorithm, and 7.4 million site updates per second for a microcanonical algorithm. The estimated performance for a Monte Carlo QCD code is 200,000 site updates per second (or 5.6 Gflops/sec).
An overview of deterministic functional RAM chip testing
Authors: A. J. van de Goor, C. A. Verruijt
Venue: ACM Computing Surveys (CSUR) (1990)

This paper presents an overview of deterministic functional RAM chip testing. Instead of the traditional ad-hoc approach toward developing memory test algorithms, a hierarchy of functional faults and tests is presented, which is shown to cover all likely functional memory faults. This is done by presenting a novel way of categorizing the faults. All (possible) fault combinations are discussed. Requirements are put forward under which conditions a fault combination can be detected. Finally, memory test algorithms that satisfy the given requirements are presented.