ppxscal/embedding_network huggingface dataset:
Implementing ranking strategies using text signatures
Authors: W. Bruce Croft, Pasquale Savino
Venue: ACM Transactions on Information Systems (TOIS) (1988)

Signature files provide an efficient access method for text in documents, but retrieval is usually limited to finding documents that contain a specified Boolean pattern of words. Effective retrieval requires that documents with similar meanings be found through a process of plausible inference. The simplest way of implementing this retrieval process is to rank documents in order of their probability of relevance. In this paper techniques are described for implementing probabilistic ranking strategies with sequential and bit-sliced signature tiles and the limitations of these implementations with regard to their effectiveness are pointed out. A detailed comparison is made between signature-based ranking techniques and ranking using term-based document representatives and inverted files. The comparison shows that term-based representations are at least competitive (in terms of efficiency) with signature files and, in some situations, superior.
Participatory teaching methods in computer science
Authors: James S. Jones
Venue: ACM SIGCSE Bulletin (1987)

This paper discusses the role of participatory teaching methods in the computer science classroom. The list of these methods includes brainstorming, directed dialogues, small discussion groups, role playing, games, debates, panel discussions, and Socratic dialogues. The author has used such methods in Computers and Society classes and to a limited degree in Compiler Design, Computer Architecture and Operating Systems classes and believes that such techniques have a place in the computer science classroom. It is the aim of this paper to provide an overview of participatory teaching methods and their use in computer science education.
A decomposable algorithm for contour surface display generation
Authors: Michael J. Zyda
Venue: ACM Transactions on Graphics (TOG) (1988)

We present a study of a highly decomposable algorithm useful for the parallel generation of a contour surface display. The core component of this algorithm is a two-dimensional contouring algorithm that operates on a single 2 x 2 subgrid of a larger grid. An intuitive procedure for the operations used to generate the contour lines for a subgrid is developed. A data structure, the contouring tree, is introduced as the basis of a new algorithm for generating the contour lines for the subgrid. The construction of the contouring tree is detailed. Space requirements for the contouring tree algorithm are described for particular implementations.
Implications of data quality for spreadsheet analysis
Authors: Donald P. Ballou, Harold L. Pazer, Salvatore Belardo, Barbara Klein
Venue: ACM SIGMIS Database (1987)

This paper examines the impact of deficiencies in data quality on the results generated for spreadsheet applications. The purpose is to describe a framework which can be systematically used to determine the relative importance of potential errors in operational and judgmental data. Special emphasis is placed on analyzing the implications of deficiencies in data quality on projected spreadsheet results.
A unified operational treatment of RPS reconnect delays
Authors: Jeffrey P. Buzen, Annie W. Shum
Venue: Proceedings of the 1987 ACM SIGMETRICS conference on Measurement and modeling of computer systems (1987)

Expressions are presented for RPS reconnect delays in three basic cases: single path, multiple path with static reconnect, multiple path with dynamic reconnect. The assumption of homogeneous reconnects, which is introduced in the analysis, is shown to be implicit in many prior analyses. This assumption simplifies the resulting equations, but more general equations are also presented for the case where homogeneous reconnects are not assumed. These general results have not appeared previously. This paper also uses the assumption of constrained independence to derive a result for static reconnect which has only been derived previously using the maximum entropy principle. In the case of dynamic reconnect, constrained independence yields an entirely new closed form result. In addition to being a consistent extension of the static reconnect case, this new result is the only closed form expression for dynamic reconnect that yields a correct solution in certain saturated cases. Constrained independence can provide a useful alternative assumption in many other cases where complete independence is known to be only approximately correct.
Atomic Remote Procedure Call
Authors: Kwei-Jay Lin, John D. Gannon
Venue: IEEE Transactions on Software Engineering (1985)

Remote procedure call (RPC) is a programming primitive that makes building distributed programs easier. Atomicity, whkh implies totality and serializability, has been recognized as an important property to assure consistency in spite of computing node crashes. We have implemented an atomk remote procedure call mechanism which provides users a simple and reliable language primitive. Concurrency is controlled by attaching a call graph path identifier to each message representing a procedure call. Procedures keep their last accepted calling message paths to compare against incoming message paths. Only calls that can be serialized are accepted. Associated states of static variables are saved in backup processors on procedure entry and restored to corresponding variables in case of procedure crash. Detailed concurrency control and recovery algorithms are given, and illustrated with examples.
Considerations on the insularity of performance evaluation
Authors: Domenico Ferrari
Venue: ACM SIGMETRICS Performance Evaluation Review (1986)

The author argues that systems performance evaluation, in the first twenty years of its existence, has developed in substantial isolation with respect to such disciplines as computer architecture, system organization, operating systems, and software engineering. The possible causes for this phenomenon, which seems to be unique in the history of engineering, are explored. Its positive and negative effects on computer science and technology, as well as on performance evaluation itself, are discussed. In the author's opinion, the drawbacks of isolated development outweigh its advantages. Thus, the author proposes instructional and research initiatives to foster the rapid integration of the performance evaluation viewpoint into the main stream of computer science and engineering.
Consistency in a partitioned network: a survey
Authors: Susan B. Davidson, Hector Garcia-Molina, Dale Skeen
Venue: ACM Computing Surveys (CSUR) (1985)

Recently, several strategies have been proposed for transaction processing in partitioned distributed database systems with replicated data. These strategies are surveyed in light of the competing goals of maintaining correctness and achieving high availability. Extensions and combinations are then discussed, and guidelines are presented for selecting strategies for particular applications.
Mentat: An object-oriented macro data flow system
Authors: Andrew S. Grimshaw, Jane W. S. Liu
Venue: Conference proceedings on Object-oriented programming systems, languages and applications (1987)

Mentat is an object-oriented macro data flow system designed to facilitate parallelism in distributed systems. Its underlying model of computation is the macro data flow model. The Macro data flow model is similar to the traditional, large grain data flow model with two differences: (1) Some macro actors are persistent actors that maintain state information between firings; (2) Program graphs are dynamic. Macro data flow programs are represented by dynamic structures called future lists that may be constructed and modified at run time. This paper discusses the motivation of the macro data flow model; the relationship between objects, actors, and tokens; the use of future lists; extensions to the programming language C++ for writing macro data flow programs; and the structure of a virtual macro data flow machine for executing macro data flow programs.
Problems teaching database design with information complexity to information systems undergraduates
Authors: Judith D. Wilson
Venue: ACM SIGCSE Bulletin (1986)

An undergraduate course in database design is described. The need for such a course, and its appropriateness in the undergraduate information systems curriculum is discussed. Finally, a number of general instructional difficulties are identified. It is claimed that a course like it is needed in the undergraduate information systems curriculum and that remedies to problems teaching it may have to be found outside the traditional business and computing curricula.
School time table scheduling in Prolog
Authors: A Monfroglio
Venue: Issue 96 (April 1986) (1986)

The school Time-Table Scheduling task is a very hard operations research and engineering problem, especially when-implemented in a conventional language. That is due to the imperative, deterministic nature of most conventional languages, such as BASIC and PASCAL and to the long series of constraints and goals inside the problem. The descriptive, logic-based and nondeterministic nature of Prolog language, and its ability to backtrack allows one to easily obtain a deductive data base, mixing the facts, rules, and constraints of the Time-table. Two systems, one nonmonotonic, and one monotonic with a non-monotonic reasoning structure are compared and their performances in a significant test are discussed. The approach may be easily generalized to other analogous engineering, scheduling and operations research problems.
Geometric continuity, shape parameters, and geometric constructions for Catmull-Rom splines
Authors: Tony D. DeRose, Brian A. Barsky
Venue: ACM Transactions on Graphics (TOG) (1988)

Catmull-Rom splines have local control, can be either approximating or interpolating, and are efficiently computable. Experience with Beta-splines has shown that it is useful to endow a spline with shape parameters, used to modify the shape of the curve or surface independently of the defining control vertices. Thus it is desirable to construct a subclass of the Catmull-Rom splines that has shape parameters. We present such a class, some members of which are interpolating and others approximating. As was done for the Beta-spline, shape parameters are introduced by requiring geometric rather than parametric continuity. Splines in this class are defined by a set of control vertices and a set of shape parameter values. The shape parameters may be applied globally, affecting the entire curve, or they may be modified locally, affecting only a portion of the curve near the corresponding joint. We show that this class results from combining geometrically continuous (Beta-spline) blending functions with a new set of geometrically continuous interpolating functions related to the classical Lagrange curves. We demonstrate the practicality of several members of the class by developing efficient computational algorithms. These algorithms are based on geometric constructions that take as input a control polygon and a set of shape parameter values and produce as output a sequence of B&eacute;zier control polygons that exactly describes the original curve. A specific example of shape design using a low-degree member of the class is given.
Coding quality and tools in programming methods
Authors: G Perlman
Venue: ACM SIGSOFT Software Engineering Notes (1986)

Twenty-two programming tools were introduced in coordinated exercises as part of a programming methods course. Twenty-two or twenty-four graduate students with work experience responded to a survey asking about previous and intended use of the tools. The survey showed that many tools were new and useful to the students. My conclusion is that it is worthwhile to incorporate a module on coding quality and tools in software engineering programs.
ACE: an automatic complexity evaluator
Authors: Daniel Le Métayer
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1988)

There has been a great deal of research done on the evaluation of the complexity of particular algorithms; little effort, however, has been devoted to the mechanization of this evaluation. The ACE (Automatic Complexity Evaluator) system is able to analyze reasonably large programs, like sorting programs, in a fully mechanical way. A time-complexity function is derived from the initial functional program. This function is transformed into its nonrecursive equivalent according to MacCarthy's recursion induction principle, using a predefined library of recursive definitions. As the complexity is not a decidable property, this transformation will not be possible in all cases. The richer the predefined library is, the more likely the system is to succeed. The operations performed by ACE are described and the use of the system is illustrated with the analysis of a sorting algorithm. Related works and further improvements are discussed in the conclusion.
OPERA: options price evaluation and risk analysis system
Authors: Barry Bogart
Venue: ACM SIGAPL APL Quote Quad (1987)

This paper describes a decision-support system written in APL and implemented on a Personal Computer. The purpose of the system is to assist in the management of a portfolio of stock and commodity options, so that exposure to risk will be detected as early as possible and corrective action can be effected. The system incorporates an extended version of the Black-Scholes stochastic model for determining the fair value for an option price and its sensitivity, based on the variables stock and option exercise prices, time, interest rate, and stock price volatility. Option prices and 'deltas' are computed for a range of these variables and saved in an APL database from which they are later combined with stock position information to produce tabular and graphical output showing risk exposure across the dimensions of stock price change and the passage of time.
Distributed and Fault-Tolerant Computation for Retrieval Tasks Using Distributed Associative Memories
Authors: J. M. Char, V. Cherkassky, H. Wechsler, G. L. Zimmerman
Venue: IEEE Transactions on Computers (1988)

The distributed associative memory (DAM) model is proposed for distributed and fault-tolerant computation related to retrieval tasks. The fault tolerance is with respect to noise in the input key data and/or local and global failures in the memory itself. Working models for fault-tolerant image reconfiguration and database information retrieval have been developed and backed up by experimental results that show the feasibility of such an approach.
Microcoding an object-oriented instruction set
Authors: David M Harland, Bruno Beloff
Venue: ACM SIGARCH Computer Architecture News (1986)

Most AI applications are still written in LISP, but the recent growth of interest in object oriented programming has given rise to "shell" systems such as LOOPS and KEE, and, thereby, it has emphasised that there is now a need for an AI engine which will efficiently support an arbitrary number of object classes; it seems that it is no Longer sufficient simply to provide for Lists.This paper will demonstrate how the REKURSIV processor and its OBJEKT store can be microcoded to provide an object oriented instruction set like that defined by the SmallTalk-80 virtual machine, and that doing so can lead to an implementation which will run in excess of 250,000 bytecodes/second, a rate which is considerably faster than commerical SmallTalk systems.
A knowledge-based approach to online document retrieval system design
Authors: G Biswas, J C Bezdek, R L Oakman
Venue: Proceedings of the ACM SIGART international symposium on Methodologies for intelligent systems (1986)

A knowledge-based system approach is applied to the design of a document retrieval system for online retrieval of bibliographic material. The main components of the system are a language interface that understands user queries in pseudo natural language (i.e. queries that are restricted to subject domain concepts), a retrieval component that combines the expertise of subject-domain and retrieval experts, a help system that aids users in formulating and reformulating queries, and a user model builder that infers specific user characteristics. A comprehensive mathematical model based on fuzzy sets and fuzzy relations has been defined for the thesaurus and the retrieval mechanism and a prototypical system has been implemented in a modular fashion to test system response to changes in model parameters.
Optimal determination of user-oriented clusters
Authors: J. Deogun, V. Raghavan
Venue: Proceedings of the 10th annual international ACM SIGIR conference on Research and development in information retrieval (1987)

User-oriented clustering schemes enable the classification of documents based upon the user perception of the similarity between documents, rather than on some similarity function presumed by the designer to represent the user criteria. In this paper, an enhancement of such a clustering scheme is presented. This is accomplished by the formulation of the user-oriented clustering as a function-optimization problem. The problem formulated is termed the Boundary Selection Problem (BSP). Heuristic approaches to solve the BSP are proposed and a preliminary for evaluation of these approaches is provided.
Cleanroom Software Development: An Empirical Evaluation
Authors: Richard W. Selby, Victor R. Basili, F. Terry Baker
Venue: IEEE Transactions on Software Engineering (1987)

The Cleanroom software development approach is intended to produce highly reliable software by integrating formal methods for specification and design, nonexecution-based program development, and statistically based independent testing. In an empirical study, 15 three-person teams developed versions of the same software system (800-2300 source lines); ten teams applied Cleanroom, while five applied a more traditional approach. This analysis characterizes the effect of Cleanroom on the delivered product, the software development process, and the developers.
Pointer functionality Sans data-type
Authors: L. Schonfelder, S. Morgan
Venue: ACM SIGPLAN Fortran Forum (1987)

This paper is based on lengthy discussions at recent meetings of X3J3 within the Data Concepts Subgroup. The Subgroup considered in detail how to provide most of the functionality of pointers by the approach suggested in Burch's paper [Ed note: See Fortran Forum, October 1987, page 18]. That is, by using the facilities of IDENTIFY and ALLOCATE/DEALLOCATE, and by relaxing restrictions on the use of the attributes ALLOCATABLE and ALIAS. The paper is a general description of the facility and the required syntax and semantics to implement it consistently in Fortran 8X; it does not give details of editorial changes to the Draft Standard that would be required. Since these would be extensive and intricate, it was not considered reasonable to attempt them without a high probablility of consensus in X3J3.
An object-oriented approach to graphical interfaces
Authors: Paul S. Barth
Venue: ACM Transactions on Graphics (TOG) (1986)

An object-oriented system for building graphical interfaces to programs is discussed. The system, called GROW, facilitates the process of creating interfaces that are highly interactive (including direct manipulation and animation), rich in layout structure, and effectively reusable across applications. These properties are achieved through three techniques: object-based graphics with taxonomic inheritance, interobject relationships such as composition and graphical dependency, and separation of the interface and application. Experience with interfaces for several applications has provided insights on the effectiveness of these techniques. First, object-oriented programming yields significant leverage on specializing and reusing interfaces. Second, layout constraints (such as maintaining the connectivity of a graph) can be managed with simple data dependencies among the attributes of the graphical objects. Finally, separating the interface and application is essential to reusing interface components. This paper describes the techniques in detail, gives examples of interfaces built with GROW, and summarizes experiences using GROW with a variety of applications.
Data-flow algorithms for parallel matrix computation
Authors: Dianne P. O'Leary, G. W. Stewart
Venue: Communications of the ACM (1985)

In this article we develop some algorithms and tools for solving matrix problems on parallel processing computers. Operations are synchronized through data-flow alone, which makes global synchronization unnecessary and enables the algorithms to be implemented on machines with very simple operating systems and communication protocols. As examples, we present algorithms that form the main modules for solving Liapounov matrix equations. We compare this approach to wave front array processors and systolic arrays, and note its advantages in handling missized problems, in evaluating variations of algorithms or architectures, in moving algorithms from system to system, and in debugging parallel algorithms on sequential machines.
Variations on UNIX for parallel-processing computers
Authors: Channing H. Russell, Pamela J. Waterman
Venue: Communications of the ACM (1987)

Porting a familiar UNIX environment to today's parallel-processing computers is challenging, but options abound.
A Parallel Algorithm to Compute the Shortest Paths and Diameter of a Graph and Its VLSI Implementation
Authors: B P Sinha, B B Bhattacharya, S Ghose, P K Srimani
Venue: IEEE Transactions on Computers (1986)

In this correspondence we develop a parallel algorithm to compute the all-pairs shortest paths and the diameter of a given graph. Next, this algorithm is mapped into a suitable VLSI systolic architecture and the performance of this proposed VLSI implementation is evaluated.
Answering queries in categorical databases
Authors: F. M. Malvestuto
Venue: Proceedings of the sixth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1987)

A compatible categorical data base can be viewed as a single (contingency) table by taking the maximum-entropy extension of the component tables. Such a view, here called universal table model, is needed to answer a user who wishes &ldquo;cross-classified&rdquo; categorical data, that is, categorical data resulting from the combination of the information contents of two or more base tables. In order to implement a universal table interface we make use of a query-optimization procedure, which is able to generate an appropriate answer both in the case that the asked data are present in the data base and in the case that they are not and, then, have to be estimated
Computing Poisson probabilities
Authors: Bennett L. Fox, Peter W. Glynn
Venue: Communications of the ACM (1988)

We propose an algorithm to compute the set of individual (nonnegligible) Poisson probabilities, rigorously bound truncation error, and guarantee no overflow or underflow. Work and space requirements are modest, both proportional to the square root of the Poisson parameter. Our algorithm appears numerically stable. We know no other algorithm with all these (good) features. Our algorithm speeds generation of truncated Poisson variates and the computation of expected terminal reward in continuous-time, uniformizable Markov chains. More generally, our algorithm can be used to evaluate formulas involving Poisson probabilities.
A programming environment for CSP
Authors: Norman Delisle, Mayer Schwartz
Venue: Proceedings of the second ACM SIGSOFT/SIGPLAN software engineering symposium on Practical software development environments (1987)

This paper describes a programming environment that supports the development and execution of CSP programs. The prototype environment is primarily intended as a vehicle for learning CSP. Its strengths include graphical animations that illustrate the interactions of CSP processes as they execute. Its main limitations are that CSP programs do not execute particularly fast and that true parallelism is not supported. Both the functionality of the CSP environment and its somewhat unusual multi-language implementation are discussed.