ppxscal/embedding_network huggingface dataset:
Efficient updates to independent schemes in the weak instance model
Authors: Paolo Atzeni, Riccardo Torlone
Venue: ACM SIGMOD Record (1990)

The weak instance model is a framework to consider the relations in a database as a whole, regardless of the way attributes are grouped in the individual relations. Queries and updates can be performed involving any set of attributes. The management of updates is based on a lattice structure on the set of legal states, and inconsistencies and ambiguities can arise In the general case, the test for inconsistency and determinism may involve the application of the chase algorithm to the whole database. In this paper it is shown how, for the highly significant class of independent schemes, updates can be handled efficiently, considering only the relevant portion of the database.
AVANCE: an object management system
Authors: Anders Bjornerstedt, Stefan Britts
Venue: ACM SIGPLAN Notices (1988)

AVANCE1 is an integrated application development and run-time system. It provides facilities for programming with shared and persistent objects, transactions and processes. The architecture is designed with decentralization in mind by having a large object identifier space and a remote procedure call interface to objects. Emphasis in this paper is on the programming language PAL and its relation with the underlying virtual machine.
A cache consistency protocol for multiprocessors with multistage networks
Authors: P. Stenström
Venue: ACM SIGARCH Computer Architecture News (1989)

A hardware based cache consistency protocol for multiprocessors with multistage networks is proposed. Consistency traffic is restricted to the set of caches which have a copy of a shared block. State information is distributed to the caches and the memory modules need not be consulted for consistency actions. The protocol provides two operating modes: distributed write and global read. Distribution of writes calls for efficient multicast methods. Communication cost for multicasting is analyzed and a novel scheme is proposed. Finally, communication cost for the protocol is compared to other protocols. The two-mode approach limits the upperbound for the communication cost to a value considerably lower than that for other protocols.
A Near-Optimal Heuristic Algorithm for Single-Flow Routing
Authors: L. C. Liu, H. C. Du
Venue: IEEE Transactions on Computers (1989)

The authors obtain a tighter lower bound on the street congestion of optimal realizations. Then a heuristic algorithm based on necessary and sufficient conditions of optimality is proposed. Although it cannot be guaranteed that this algorithm always generates optimal realizations, it indeed generates optimal realizations for all the 60 test instances with which they experimented. This algorithm is also shown to be time efficient.
Application-sol interaction: an APL2 approach
Authors: S. Deerhake
Venue: ACM SIGAPL APL Quote Quad (1987)

This paper describes an APL2 application programmer tool which simplifies the development and implementation of APL2 applications which interact with SQL. The described tool consists of a suite of APL2 functions which provide a high level, easy-to-use, application-SQL interface. The interface extends the SQL concepts of tables and operations on tables into the APL2 workspace, providing a simple method of interaction between APL2 applications and SQL. This approach also provides a great deal of isolation between the APL2 code and the SQL code required for manipulating the application's data. Besides simplifying the usage of SQL within APL2 applications, the tool provides a convenient means for &ldquo;tuning&rdquo; an application's use of SQL, particularly the SQL SELECT statements used by the application. It also provides a framework for exploring extensions to SQL statements and syntax. While still somewhat experimental, the described tool has been effectively used by inexperienced APL2 programmers with virtually no knowledge of SQL.
A framework for visualizing object-oriented systems
Authors: Volker Haarslev, Ralf Möller
Venue: Proceedings of the European conference on object-oriented programming on Object-oriented programming systems, languages, and applications (1990)

This paper describes a new approach to visualizing program systems within the object-oriented paradigm. This approach is based on a TEX-like notation which has been extended and generalized for specifying graphical layout of arbitrary objects. The CLOS meta-level architecture is used to associate visualization and application objects. We propose several useful techniques such as indirect values, slot and method demons, and instance-specific meta-objects. Our techniques require no modifications to the systems which are selected for visualization. We demonstrate the feasibility of our approach using application domains such as CLOS debugging and constraint systems.
Computation of cyclic redundancy checks via table look-up
Authors: D. V. Sarwate
Venue: Communications of the ACM (1988)

Cyclic Redundancy Check (CRC) codes provide a simple yet powerful method of error detection during digital data transmission. Use of a table look-up in computing the CRC bits will efficiently implement these codes in software.
An environment for literate Smalltalk programming
Authors: T. Reenskaug, A. L. Skaar
Venue: ACM SIGPLAN Notices (1989)

The programming environment described in this paper is an adaptation of Donald Knuth's concept of literate programming, applied to Smalltalk programs. The environment provides a multi-media document production system including media for Smalltalk class and method definitions. There are two outputs from the system. The first output is a document which contains general descriptions and discussions intermixed with precise definitions of program fragments, test inputs and test results. The second output consists of compiled Smalltalk programs installed and ready for execution. The main idea was to produce program documentation that was just as interesting and fascinating to read as ordinary literature. Our experience showed an added benefit, namely that the literate programming environment was an active aid in the problem solving process. The simultaneous programming and documentation lead to significantly improved quality of both programs and documentation.
Extensions to C for interface programming
Authors: James R. Rhyne
Venue: Proceedings of the 1st annual ACM SIGGRAPH symposium on User Interface Software (1988)

Extending the facilities available to a programmer can be more productive, flexible, and appealing when done via additions to the syntax and semantics of the programming language, than when done by way of procedure packages. Database programming, for example, is now routinely done using query languages that are embedded in programming languages. Interaction dialog programming can be greatly simplified by use of a specification language. Dialog languages are not often integrated with a programming language. In this report, a set of extensions to the C language are presented. These extensions provide a rule-based sublanguage for describing interaction dialogs. A translator and interpreter have been constructed for the extended (C + Dialog) language, and used in a research project investigating gestural interfaces.
Solving implication problems in database applications
Authors: Xian-He Sun, Nabil Kamel, Lionel M. Ni
Venue: ACM SIGMOD Record (1989)

Computing queries from derived relations, optimizing queries from a group of queries, and updating materialized views are important database problems and have attracted much attention. One thing common to these problems is their demand to quickly solve the implication problem &mdash; given two predicates &sgr;Q and &sgr;&tgr;, can &sgr;Q imply &sgr;&tgr; (&sgr;Q&rarr;&sgr;&tgr;)? The implication problem has been solved by converting it into a satisfiability problem. Based on a graph representation, a detailed study of the general implication problem on its own is presented in this paper. We proved that the general implication problem, in which all six comparison operators: =, &ne;, <, >, &le;, &ge;, as well as conjunctions and disjunctions are allowed, is NP-hard. In the case when &ldquo;&ne;&rdquo; operators are not allowed in &sgr;Q and disjunctions are not allowed in &sgr;&tgr;, a polynomial time algorithm is proposed to solve this restricted implication problem. The influence of the &ldquo;&ne;&rdquo; operator and disjunctions are studied. Our theoretical results show that for some special cases the polynomial complexity algorithm can solve the implication problem which allows the &ldquo;&ne;&rdquo; operator or disjunctions in the predicates. Necessary conditions for detecting when the &ldquo;&ne;&rdquo; operator and disjunctions are allowed are also given. These results are very useful in creating heuristic methods.
Structural Approach to the Estimation of the Number of Residual Software Faults Based on the Hyper-Geometric Distribution
Authors: Yoshihiro Tohma, Kenshin Tokunaga, Shinji Nagase, Yukihisa Murata
Venue: IEEE Transactions on Software Engineering (1989)

Models based on the hyper-geometric distribution for estimating the number of residual software faults are proposed. The application of the basic model shows that its fit to real data is good. Two ways of improving the model, using a segmentation technique and composite estimation, respectively, are shown. The segmentation technique appears quite effective, particularly when the growth curve of the cumulative number of detected faults bends sharply. The applications of these models to real data are demonstrated.
Polymorphic unification and ML typing
Authors: P. C. Kanellakis, J. C. Mitchell
Venue: Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1989)

We study the complexity of type inference for a core fragment of ML with lambda abstraction, function application, and the polymorphic let declaration. Our primary technical tool is the unification problem for a class of &ldquo;polymorphic&rdquo; type expressions. This form of unification, which we call polymorphic unification, allows us to separate a combinatorial aspect of type inference from the syntax of ML programs. After observing that ML typing is in DEXPTIME, we show that polymorphic unification is PSPACE hard. From this, we prove that recognizing the typable core ML programs is also PSPACE hard. Our lower bound stands in contrast to the common belief that typing ML programs is &ldquo;efficient,&rdquo; and to practical experience which suggests that the algorithms commonly used for this task do not slow compilation substantially.
Generalization, consistency, and control
Authors: C. Lewis, D. C. Hair, V. Schoenberg
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Wings for the mind (1989)

Easy learning of a user interface depends in part on users being able to generalize successfully about it. Philosophical doctrine, and some recent work in human-computer interaction, argues that causal analysis of interactions can support generalization. But neither the philosophical literature nor the HCI literature provides a rigorous theory of causal analysis adequate for problems in human-computer interaction. We propose such a rigorous theory here, and show how it accounts for two robust generalizations, using certain general assumptions. We then present evidence that these assumptions are accepted by people. Finally we compare this theory with other treatments of consistency.
Line Fitting in a Noisy Image
Authors: I. Weiss
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

The conventional least-squared-distance method of fitting a line to a set of data points is unreliable when the amount of random noise in the input (such as an image) is significant compared with the amount of data correlated to the line itself. Points which are far away from the line (outliers) are usually just noise, but they contribute the most to the distance averaging, skewing the line from its correct position. The author presents a statistical method of separating the data of interest from random noise, using a maximum-likelihood principle.
Techniques for avoiding conditional execute in APL2
Authors: S. M. Mansour
Venue: Conference proceedings on APL as a tool of thought (1989)

Execute ( ) is unique among the APL2 primitive functions in that it is the only one which does not necessarily produce an explicit result. This makes it convenient for executing an APL expression conditionally. Execute is also unique in that it is the only symbolic primitive which permits only a character argument. This tends to produce awkward programming.This paper will look at ways to avoid the use of conditional execute by suggesting alternate methods and ways of thinking which are unique to APL. These methods have been used to great advantage in production code.Most examples of code used in this paper have been taken from an actual APL2 application. Although most of the examples are in APL2, many will work in other APL dialects. Some minor modifications have been made to the code in the interests of security and clarity. Most of these involved changing the names of some functions or variables.
Concurrency control of nested transactions accessing B-trees
Authors: A. Fu, T. Kameda
Venue: Proceedings of the eighth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1989)

This paper presents a concurrency control algorithm for nested transactions accessing B-trees. It combines the idea of B-link tree with that of resilient 2-phase locking [Mos85b]. The I/O automaton model is used in the specification and proofs of correctness of the system. We define &ldquo;strongly-serially correct&rdquo; schedules and use this property as our correctness criterion.
Disaster recovery planning for academic computing centers
Authors: Renate Rohde, Jim Haskett
Venue: Communications of the ACM (1990)

Planning for recovery from a disaster is quickly becoming recognized as a necessity for higher education computing installations. This article presents a structural framework, describes the stages, and tells how to implement a disaster recovery plan specifically geared to an academic computing organization.
Statemaster: A UIMS based on statechart for prototyping and target implementation
Authors: P. D. Wellner
Venue: ACM SIGCHI Bulletin (1989)

Most User Interface Management systems are state based and some use state transition diagrams for dialog specification. Although these diagrams have significant advantages, they suffer from drawbacks that make them impractical for the specification of complex user interfaces. Statecharts are a hierarchical extension of state transition diagrams and are well suited for specification of complex user interface dialogs. Statemaster is a UIMS implemented in C + + that uses statecharts for dialog specification. It has been successfully used both for rapid prototyping and target implementation of user interfaces. This paper describes the use of statecharts for dialog specification and the implementation of Statemaster.
Rule-based query optimization in IRIS
Authors: N. Derrett, M.-C. Shan
Venue: Proceedings of the 17th conference on ACM Annual Computer Science Conference (1989)

In this paper we present the design and initial performance results of a rule-based query optimizer used in Iris, an object-oriented database system [3]. Query optimization methods are expressed as rules and the entire query process is carried out in a way analogous to the operation of production systems in AI. Two kinds of rules are used: the first kind transform a query, represented as a relational algebra expression, into an equivalent, but simpler, query; the second kind add information to the relational algebra representation to specify join order and data access methods. Preliminary results show that the speed of the query optimizer and the performance of the execution plans generated are comparable to those in a traditional relational database system.
Partial orders for parallel debugging
Authors: C. J. Fidge
Venue: ACM SIGPLAN Notices (1989)

Parallel programs differ from sequential programs primarily in that the temporal relationships between events are only partially defined. However, for a given distributed computation, debugging utilities typically linearize the observed set of events into a total ordering, thus losing information and allowing potentially capturable temporal errors to escape detection. We explore use of the partially ordered relation &ldquo;happened before&rdquo; to augment both centralized and distributed parallel debuggers to ensure that such errors are always detected and that the results produced by the debugger are unaffected by the non-determinism inherent in the partial ordering. This greatly reduces the number of tests required during debugging. Assertions are based on time intervals, rather than treating events as dimensionless points.
A Strassen-Newton algorithm for high-speed parallelizable matrix inversion
Authors: D. H. Bailey, H. R. P. Gerguson
Venue: Proceedings of the 1988 ACM/IEEE conference on Supercomputing (1988)

This paper describes techniques to compute matrix inverses by means of algorithms that are highly suited to massively parallel computation. In contrast, conventional techniques such as pivoted Gaussian elimination and LU decomposition are efficient only on vector computers or fairly low-level parallel systems. These techniques are based on an algorithm suggested by Strassen in 1969. Variations of this scheme employ matrix Newton iterations and other methods to improve the numerical stability while at the same time preserving a very high level of parallelism. One-processor Cray-2 implementations of these schemes range from one that is up to 55% faster than a conventional library routine to one that, while slower than a library routine, achieves excellent numerical stability. The problem of computing the solution to a single set of linear equations is discussed, and it is shown that shown that this problem can also be solved efficiently using these techniques.
Toward integration of the imperative and logic programming paradigms: Horn-clause programming in the Pascal environment
Authors: A. Radensky
Venue: ACM SIGPLAN Notices (1990)

This paper introduces a method for integrating the imperative and logic programming paradigms. The integration is implemented in the framework of a language named Paslog. Paslog is an extension of Pascal; it supports Horn clause programming in the Pascal environment. An experimental implementation and some properties of Paslog are discussed.
A faster strongly polynomial minimum cost flow algorithm
Authors: James Orlin
Venue: Proceedings of the twentieth annual ACM symposium on Theory of computing (1988)

We present a new strongly polynomial algorithm for the minimum cost flow problem, based on a refinement of the Edmonds-Karp scaling technique. Our algorithm solves the uncapacitated minimum cost flow problem as a sequence of &Ogr;(n log n) shortest path problems on networks with n nodes and m arcs and runs in &Ogr;(n log n(m + n log n)) steps. Using a standard transformation, this approach yields an &Ogr;(m log n (m + n log n)) algorithm for the capacitated minimum cost flow problem. This algorithm improves the best previous strongly polynomial algorithm due to Galil and Tardos, by a factor of m/n. Our algorithm is even more efficient if the number of arcs with finite upper bounds, say m', is much less than m. In this case, the number of shortest path problems solved is &Ogr;((m + n) log n).
General methods for adding range restrictions to decomposable searching problems
Authors: Hans W. Scholten, Mark H. Overmars
Venue: Journal of Symbolic Computation (1989)

In this paper we consider the problem of adding range restrictions to decomposable searching problems. Two classes of structures for this problem are described. The first class consists of structures that use little storage and preprocessing time but still have reasonable query time. The second class consists of structures that have a much better query time, at the cost of an increase in the amount of storage and preprocessing time. Both classes of structures can be tuned to obtain different trade-offs. First we only describe static structures. To dynamize the structures a new type of weight-balanced multiway tree (the MWB-iree) is introduced that is used as an underlying structure. The MWB-tree might be useful in other applications as well.
Performance of MAP in the Remote Operation of a CNC
Authors: B. Mortazavi
Venue: IEEE Transactions on Software Engineering (1990)

A major issue for the users of the Manufacturing Automation Protocol (MAP) is its performance in servicing time-critical applications. The author describes an experiment in which a computerized numerical controller (CNC) is remotely operated using MAP. A set of critical timing parameters is defined, a performance analysis of the system from the user's point of view is carried out, and a comparison with other similar systems is made. The transfer time between two front-end processors, implementing the seven MAP layers, for a 100-byte-long message is found to be about 18 ms, and the transfer time for the same message between two user processes on the hosts is about 40 ms.
Hypercube experiments with Joyce
Authors: B. Andersen
Venue: ACM SIGPLAN Notices (1989)

Joyce is a programming language for distributed systems. This paper describes an implementation of Joyce, which runs on an Intel iPSC hypercube, and discusses the performance of the implementation based on experiments. The first version of iPSC hypercube is finally concluded to be an inadequate distributed computer for execution of Joyce programs.
Circuits and local computation
Authors: A. C. Yao
Venue: Proceedings of the twenty-first annual ACM symposium on Theory of computing (1989)

This paper contains two parts. In Part I, we show that polynomial-size monotone threshold circuits of depth k form a proper hierarchy in parameter k. This implies in particular that monotone TC0 is properly contained in NC1. In Part II, we introduce a new concept, called local function, which tries to characterize when a function can be efficiently computed using only localized processing elements. It serves as a unifying framework for viewing related and sometimes apparently unrelated results. In particular, it will be demonstrated that the recent results on lower bounds for monotone circuits by Razborov [Ra1] and Karchmer and Wigderson [KW], as well as a main theorem in Part I of this paper, can be regarded as proving certain functions to be nonlocal. We will also suggest an approach based on locality for attacking the conjecture that (nonmonotone) TC0 is properly contained in NC1.
Markov processes in APL
Authors: Alan G. Hawkes
Venue: ACM SIGAPL APL Quote Quad (1990)

Using examples from two areas of application, ion channel models and systems reliability, we illustrate the power of APL as an executable notation for the mathematics of finite-state Markov processes. We stress, in particular, the algebra of partitioned matrices and second-generation features of DYALOG APL which allow a simple natural way of creating certain structured matrices.
Resolving the tension between integrity and security using a theorem prover
Authors: Subhasish Mazumdar, David Stemple, Tim Sheard
Venue: Proceedings of the 1988 ACM SIGMOD international conference on Management of data (1988)

Some information in databases and knowledge bases often needs to be protected from disclosure to certain users. Traditional solutions involving multi-level mechanisms are threatened by the user's ability to infer higher level information from the semantics of the application. We concentrate on the revelation of secrets through a user running transactions in the presence of database integrity constraints. We develop a method of specifying secrets formally that not only exposes a useful structure and equivalence among secrets but also allows a theorem prover to detect certain security lapses during transaction compilation time.