ppxscal/embedding_network huggingface dataset:
Database theory column
Authors: P. Kanellakis, S. Abiteboul
Venue: ACM SIGACT News (1989)

The study of database logic programs, popularly known as Datalog programs, is one of the principal research themes in database theory today. Datalog is the simplest formalism available for describing rule-based programming and, thus, of interest to the larger computer science community. A key optimization problem is to estimate the depth of recursion of a database logic program, as a function of the size of its input database. Deciding bounded recursion for a given program, i.e., determining whether its depth of recursion is bounded by a constant independent of the input, turns out to be a basic and surprisingly subtle task. In the first database theory column, we review the progress made on understanding bounded recursion and list some of the outstanding open questions. For the readers, who are not familiar with the terminology, we include the relevant definitions.
Understanding concurrent programming through program animation
Authors: M. Zimmermann, F. Perrenoud, A. Schiper
Venue: ACM SIGCSE Bulletin (1988)

Program animation has mainly been developed for sequential programs. Animation of concurrent programs is much more uncommon, mainly because of the important technical problems. This paper presents a project whose objective is to animate any concurrent program written in the language Portal, a real time language close to Modula. The usefulness of animation in the context of teaching is shown by a few examples.
Cumulating the science of HCI: from s-R compatibility to transcription typing
Authors: B. E. John, A. Newell
Venue: ACM SIGCHI Bulletin (1989)

In keeping with our claim that an applied psychology of HCI must be based on cumulative work within a unified framework, we present two extensions of the Model Human Processor. A model of immediate response behavior and stimulus-response (S-R) compatibility is presented and extended to a new domain: transcription typing. Parameters are estimated using one S-R compatibility experiment, used to make a priori predictions in four other S-R compatibility tasks, and then carried over into the area of typing. A model of expert transcription typing is described and its prediction of typing phenomena is demonstrated and summarized.
A comparison of serial and parallel processing simulation models of pilot workload
Authors: T. F. Schuppr
Venue: Proceedings of the 21st conference on Winter simulation (1989)

This paper discusses and evaluates several options for modeling a pilot while he performs normal cockpit duties. Using a queueing analogy, with the pilot modeled as the server and the pilot's tasks as customers, two discrete-event simulation models were developed. The main issue examined was the relative accuracy of a model which processes tasks in series versus one which processes tasks in parallel. Each of these models employed a priority system with preemption. The serial model processed one task at a time while the number of tasks that could be processed simultaneously in the parallel model was dependent on the mix of tasks currently demanding the pilot's resources. Three different measures from the simulation models were evaluated as workload surrogates: pilot idle time, task interrruption rate, and the simulataneous task rate. Workload model predictions were validated by comparison to workload measurements taken under identical conditions in a high-fidelity flight simulator. The models' validation process suggests that the technique has merit and continued investigation is warranted.
Optimal Semijoins for Distributed Database Systems
Authors: J. K. Mullin
Venue: IEEE Transactions on Software Engineering (1990)

A Bloom-filter-based semijoin algorithm for distributed database systems is presented. This algorithm reduces communications costs to process a distributed natural join as much as possible with a filter approach. An optimal filter is developed in pieces. Filter information is used both to recognize when the semijoin will cease to be effective and to optimally process the semijoin. An ineffective semijoin will be quickly and cheaply recognized. An effective semijoin will use all of the transmitted bits optimally.
Partition trees for triangle counting and other range searching problems
Authors: E. Welzl
Venue: Proceedings of the fourth annual symposium on Computational geometry (1988)

The range searching problems which allow partition trees where every query enters only a sublinear number of nodes are characterized as those with finite Vapnik - Chervonenk is dimension.The concrete combinatorial bounds obtained imply&mdash;among others &mdash; that every set of n points in the planecan be stored in an &Ogr;(n) space data structure which allows triangle counting queries in &Ogr;(&radic;n&middot; log3n) time, andcan be stored in an &Ogr;(n &middot; log n) space data structure which allows disk counting queries in &Ogr;(&radic;n&middot; log3n) time; the preprocessing time for the data structures is polynomial. Recent results by Chazelle entail that these bounds for space and query time are optimal up to polylog &mdash; factors.
The connection machines CM-1 and CM-2: solving nonlinear network problems
Authors: S. A. Zenios, R. A. Lasken
Venue: Proceedings of the 2nd international conference on Supercomputing (1988)

Massively parallel computers &mdash; like the Connection Machines CM-1 and CM-2 &mdash; have demonstrated remarkable performance in applications like pattern recognition, database searching, dense linear algebra computations and so on. In this paper we discuss the use of these systems for the solution of nonlinear network optimization problems that appear is operations research, transportation, engineering design, financial modeling and other areas. We describe the implementation of a distributed relaxation algorithm for strictly convex network problems on a massively parallel computer. A Connection Machine CM-1 configured with 16,384 processing elements serves as the primary testbed of the implementation. Experiments are also conducted on a CM-2. Computational results are reported with a series of stick percolation and quadratic transportation problems. The algorithm is compared with an implementation of the primal truncated Newton on an IBM 3081-D mainframe, an Alliant FX/8 shared memory vector multiprocessor and the IBM 3090-600 vector supercomputer.
Object derivation and validation from a data base definition
Authors: A. Dinsart, B. Hucq, N. Piperakis, P. J. Thollembeck
Venue: ACM SIGSOFT Software Engineering Notes (1989)

The MONSYS (MONtage SYStem) method and tool has been developed by the SIEMENS Systems Development . Division with the objective to increase the efficiency and quality of the integration process for the BS2000 System Software. Presently MONSYS is used to integrate new BS2000 versions. This paper does not detail all the MONSYS features. It focuses on the management of the object code level. The derivation of a software configuration is detailed with emphasis on the derivation environment concept, the use of the MONSYS Data Base, and feed back from that industrial experience.
Lightweight remote procedure call
Authors: B. Bershad, T. Anderson, E. Lazowska, H. Levy
Venue: Proceedings of the twelfth ACM symposium on Operating systems principles (1989)

Lightweight Remote Procedure Call (LRPC) is a communication facility designed and optimized for communication between protection domains on the same machine. In contemporary small-kernel operating systems, existing RPC systems incur an unnecessarily high cost when used for the type of communication that predominates &mdash; between protection domains on the same machine. This cost leads system designers to coalesce weakly-related subsystems into the same protection domain, trading safety for performance. By reducing the overhead of same-machine communication, LRPC encourages both safety and performance. LRPC combines the control transfer and communication model of capability systems with the programming semantics and large-grained protection model of RPC. LRPC achieves a factor of three performance improvement over more traditional approaches based on independent threads exchanging messages, reducing the cost of same-machine communication to nearly the lower bound imposed by conventional hardware. LRPC has been integrated into the Taos operating system of the DEC SRC Firefly multiprocessor workstation.
A structured approach to program optimization
Authors: Pasquale Armenise
Venue: IEEE Transactions on Software Engineering (1989)

Software engineering should provide software engineers with methodologies and tools suitable for use in that small number of applications where efficiency is really important. In order to do that, the optimization process should be a clearly visible phase of the software lifecycle (regardless of the particular software development paradigm adopted), so that it can be regulated, securing the production of good quality and efficient software. With this in mind, the author suggests an approach to program optimization based on a paradigm, a method, some principles and guidelines, and some well-known techniques.
The landmark hierarchy: a new hierarchy for routing in very large networks
Authors: P. F. Tsuchiya
Venue: Symposium proceedings on Communications architectures and protocols (1988)

Landmark Routing is a set of algorithms for routing in communications networks of arbitrary size. Landmark Routing is based on a new type of hierarchy, the Landmark Hierarchy. The Landmark Hierarchy exhibits path lengths and routing table sizes similar to those found in the traditional area or cluster hierarchy. The Landmark Hierarchy, however, is easier to dynamically configure using a distributed algorithm. It can therefore be used as the basis for algorithms that dynamically configure the hierarchy on the fly, thus allowing for very large, dynamic networks. This paper describes the Landmark Hierarchy, analyzes it, and compares it with the area hierarchy.
Implementation of quasi-random generators and their use in discrete event simulation
Authors: T. R. Davenport, R. C.H. Cheng
Venue: Proceedings of the 21st conference on Winter simulation (1989)

One of the most recent constructions of quasi-random sequences is due to Niederreiter (1988). These sequences, which possess the lowest known discrepancy of all such sequences, have not yet been implemented as practical computer code. In this paper we gather together relevant results and theorems presented by Niederreiter (1988) to produce a concrete construction of such a sequence. An algorithm and practical routines for the generation of the sequence are presented, together with an unusual practical application from the area of discrete event simulation.We consider the estimation of daily gas demand and conclude that significant gains can be made by selecting a quasi-random sequence in preference to the traditional approach of using crude Monte Carlo.The Sobol' (1967) and Faure (1982) sequences have played an important role in the development of this, the most recent sequence. They have only marginally higher discrepancies, and so for comparison simulation results are also included for these sequences.
Natural language techniques for intelligent information retrieval
Authors: P. S. Jacob, L. F. Rau
Venue: Proceedings of the 11th annual international ACM SIGIR conference on Research and development in information retrieval (1988)

Neither natural language processing nor information retrieval is any longer a young field, but the two areas have yet to achieve a graceful interaction. Mainly, the reason for this incompatibility is that information retrieval technology depends upon relatively simple but robust methods, while natural language processing involves complex knowledge-based systems that have never approached robustness. We provide an analysis of areas in which natural language and information retrieval come together, and describe a system that joins the two fields by combining technology, choice of application area, and knowledge acquisition techniques.
A TEX-REDUCED-Interface
Authors: W. Antweiler, A. Strotmann, V. Winkelmann
Venue: ACM SIGSAM Bulletin (1989)

REDUCE is a well known computer algebra system invented by Anthony C. Hearn. While every effort was made to improve the system's algebraic capabilities, the readability of the output remained poor by modern typesetting standards. Although a pretty-printer is already incorporated in REDUCE, the output is produced only in line-printer quality. The simple idea to produce high quality output from REDUCE is to link REDUCE with Donald E. Knuth's famous TEX typesetting language. This draft reviews our efforts in this direction. Our majors goals we pursue with TRI are: bull; We want to produce REDUCE-output in typesetting quality. bull; The interlnediate files (TEX-input files) should be easy to edit. The reason is that it is likely that the proposed line-breaks are sub-optilnal from the user's point of view. bull; We apply a TEX-like algorithm which "optimizes" the line-breaking over the whole expression. This differs fundamentally from the standard left-to-right, one-line look-ahead pretty-printers of REDUCE, LISP and the like.
Completeness theorems for non-cryptographic fault-tolerant distributed computation
Authors: Michael Ben-Or, Shafi Goldwasser, Avi Wigderson
Venue: Proceedings of the twentieth annual ACM symposium on Theory of computing (1988)

Every function of n inputs can be efficiently computed by a complete network of n processors in such a way that: If no faults occur, no set of size t < n/2 of players gets any additional information (other than the function value), Even if Byzantine faults are allowed, no set of size t < n/3 can either disrupt the computation or get additional information. Furthermore, the above bounds on t are tight!
Compiler-Assisted Synthesis of Algorithm-Based Checking in Multiprocessors
Authors: Vijay Balasubramanian, Prithviraj Banerjee
Venue: IEEE Transactions on Computers (1990)

The task of synthesizing algorithm-based checking techniques for general applications is investigated. The problem is approached at the compiler level by identifying linear transformations in Fortran DO loops and restructuring program statements to convert nonlinear transformations to linear ones. System-level checks based on this property are proposed. The approach is demonstrated with example problems of matrix multiplication and the LINPACK routine: DGEFA.
Picasso: an experiment in hypercube operating system design
Authors: D. K. Bradley, B. A.A. Nazief, D. C. Grunwald, D. A. Reed
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

Any new computer system organization raises many questions about hardware, system software, algorithms, and programming; multicomputers are no exception. The commercial emergence of hypercubes has made it possible to move many research questions from theoretical to experimental venues. However, hardware availability does more than permit implementation of previously tested ideas. The feasibility of many application and operating system algorithms can only be determined experimentally. We believe it is difficult, if not impossible, to experimentally examine these issues singly &mdash; they interact in both obvious and subtle ways. This paper describes the Picasso hypercube operating system, a part of the Picasso project at the University of Illinois. Motivated by the need for a flexible operating system testbed, the design of Picasso has exposed several important, and necessary, features of multicomputer operating systems designed for research. We present the design and current performance of Picasso, discuss the lessons learned, and conclude with an overview of future research plans.
On t-Error Correcting/All Unidirectional Error Detecting Codes
Authors: M. Blaum, H. van Tilborg
Venue: IEEE Transactions on Computers (1989)

The authors present families of binary systematics codes that can correct t random errors and detect more than t unidirectional errors. The first step of the construction is encoding the k information symbols into a codeword of an (n', k, 2t+1) error-correcting code. The second step involves adding more bits to this linear error-correcting code in order to obtain the detection capability of all unidirectional errors. Asymmetric error-correcting codes turn out to be a powerful tool in the proposed construction. The resulting codes significantly improve previous results. Asymptotic estimates and decoding algorithms are presented.
Cepstral Filtering on a Columnar Image Architecture: A Fast Algorithm for Binocular Stereo Segmentation
Authors: Y,  Yeshurun, E. L. Schwartz
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

Many primate visual cortex architectures have a prominent feature responsible for the mixing of left and right eye visual data: ocular dominance columns represent thin (about 5-10 minutes of arc) strips of alternating left and right eye input to the brain. It is shown that such an architecture, when operated upon with a cepstral filter, provides a strong cue for binocular stereopsis. Specifically, the vector of binocular disparity may be easily identified in the output of the (columnar based) cepstral filter. This algorithm is illustrated with application to a random dot stereogram and to natural images. The authors suggest that this provides a fast algorithm for stereo segmentation, in a machine vision context. In a biological context, it may provide a computational rationale for the existence of columnar systems with regard to both ocular mixing and other visual modalities that have a columnar architecture.
Organizational issues of end-user computing
Authors: Donald L. Amoroso
Venue: ACM SIGMIS Database (1988)

End-user computing environments are rapidly growing in many organizations. This growth is due primarily to the proliferation of microcomputers and the availability of user-friendly software. However, the end-user computing environment is still poorly understood by practitioners, academics, and vendors. Most managers agree that a basic understanding of the end-user computing environment is necessary in order to effectively manage it. This article attempts to define the scope of the end-user computing and integrate a variety of publications into a common research framework. Several managerial frameworks are presented which address the risks of end-user development. Finally, implications are drawn from the available literature in order to provide managerial direction to firms with growing end-user computing environments.
Regular curves and proper parametrizations
Authors: D. Manocha
Venue: Proceedings of the international symposium on Symbolic and algebraic computation (1990)

We present an algorithm for determining whether a given rational parametric curve, defined as vector valued function over a finite domain, has a regular parametrization. A curve has a regular parametrization if it has no cusps in its defining interval. It has been known that the vanishing of the derivative vector is a necessary condition for the existence of cusps. We show that if a curve is properly parametrized, then the vanishing of the derivative vector is a necessary and sufficient condition for the existence of cusps. If a curve has no cusps in its defining interval, its proper parametrization is a regular parametrization. We present a simple algorithm to compute the proper parametrization of a polynomial parametric curve which is used to analyze for cusps and later on reduce the problem of detecting cusps in a rational curve to that of a polynomial curve.
Synchronization using counting semaphores
Authors: V. Sarkar
Venue: Proceedings of the 2nd international conference on Supercomputing (1988)

This paper studies the optimization problem of enforcing a dependence graph with the minimum number of synchronization operations. For a dependence graph with N vertices, it is shown that binary semaphores may require &Ogr;(N2) operations, compared to &Ogr;(N) operations for counting semaphores. Though the optimization problem of using the minimum number of counting semaphore operations is shown to be NP-complete, we present an approximation algorithm that is observed to be very close to optimal (within 0.5%) on small, randomly generated dependence graphs. A surprising property of the problem is that the inclusion (rather than removal) of transitive edges can actually help reduce the number of synchronization operations. We characterize as class of dependence graphs for which the approximation algorithm is optimal. This class includes forests of fan-in trees, fan-out trees and series-parallel graphs. The number of synchronization operations needed for binary and counting semaphores are compared for randomly generated dependence graphs, using an implementation of the approximation algorithm in LISP/VM. The experimental results show that the use of counting semaphores significantly reduces the total number of synchronization operations, compared to binary semaphores.
Modeling human-computer decision making with covariance structure analysis
Authors: M. D. Coovert, J. LaLomia
Venue: ACM SIGCHI Bulletin (1989)

The development of a complete theory of human-computer interaction has been hindered by the lack of full scale testable models. To date, those models which have been tested are primarily low-level (e.g., key-stroke; Card, Moran, amp; Newell, 1983). Although providing clear predictions, they rarely provide information on more than just a few low level variables. Other models, such as those provided by mental representations (e.g., Gentner amp; Stevens, 1983), are often not testable or do not provide quantified information concerning the importance of variables and their interrelations.
A difference tack to providing persistence in a language
Authors: Peri L. Tarr, Jack C. Wileden, Alexander L. Wolf
Venue: Proceedings of the second international workshop on Database programming languages (1989)

Persistence is the preservation of a data object beyond the execution of a program that creates or manipulates that object. The need for persistence gave rise to file systems and databases. A fresh approach to persistence is emerging that seeks to make the programming of applications relying on persistence easier, less prone to error, and more flexible. That approach is based on incorporating the persistence mechanism into the programming language itself. Looking at current research efforts, we see that the predominant methods of incorporating persistence into a language involve the development of a completely new language, the modification of an existing language in some substantial way, and/or the use of a language that has at most dynamic type checking and at worst no type checking at all. We chose to take a different tack, namely to use the inherent abstraction capabilities of an existing strongly typed, statically type-checked language as the means of providing a persistence mechanism to developers of applications written in that language. We have described elsewhere the model of persistence that we have adopted. In this paper we concentrate on the implementation of that model. Specifically, we describe our prototype preprocessor-based implementation of persistent graph data types in Ada, its mechanism for incorporating non-graph types, and a software architecture that facilitates experimentation with various aspects of the implementation.
Computer viruses: can it happen at IU?
Authors: Mark Sheehan
Venue: ACM SIGUCCS Newsletter (1989)

In the past few months, the popular press has been full of articles about "computer viruses." The New York Times, the Chicago Tribune, the Chronicle of Higher Education, and any number of university computer center newsletters have featured stories on these diseases and others. While there have been no reports of computer viruses breaking out on the Bloomington campus of IU, it's important that our computing community be aware of them and take as many practical steps as possible to protect itself from them. The probability that a serious computer disease will eventually break out on our campus is high.