ppxscal/embedding_network huggingface dataset:
Distributed last call optimization for portable parallel logic programming
Authors: Balkrishna Ramkumar
Venue: ACM Letters on Programming Languages and Systems (LOPLAS) (1992)

A difficult but challenging problem is the efficient exploitation of AND and OR parallelism in logic programs without making any assumptions about the underlying target machine(s). In earlier papers, we described the design of a binding environment for AND and OR parallel execution of logic programs on shared and nonshared memory machines and the performance of a compiler (called ROLOG) using this binding environment on a range of MIMD parallel machines. In this paper, we present an important optimization for portable parallel logic programming, namely distributed last-call optimization, an analog of the tail recursion optimization for sequential Prolog. This scheme has been implemented in the ROLOG compiler, which ports unchanged on several shared memory and nonshared memory machines. We describe the effect of this optimization on several OR, AND/OR and AND parallel benchmark programs.
Graphical animation of object-oriented software designs (abstract)
Authors: Marko Heikkinen, Petri Pulli
Venue: ACM SIGPLAN OOPS Messenger (1993)

We have built an extension to a prototype CASE tool called ESPEX, that makes it possible to execute graphically Wassermans Object-Oriented Structured Design (OOSD) notation. The tool itself is implemented in the Smalltalk 80 programming environment. The tool contains a window-based menu-driven graph editor and an integrated graph simulator with animation support. Animation means that the movements of data items and messages between objects are visualized on a workstation display. We have implemented simulation for object instances. We are using moving tokens with data values attached on top of them. Tokens flow from objects to other objects, carrying the essential data with them. The moving tokens indicate clearly the active parts of the model, while the data values also make it possible to visualize the actual computations that take place in the objects. Another advantage of moving tokens is that it is possible to attach time stamps to tokens. With the help of the time stamps it is possible to simulate experimenting with animation techniques for dynamic creation and deletion of objects. We model objects hierarchically, so that an object can be composed of other lower level objects. At the lowest level objects are described with predicate/transition Petri nets, and the computations with IPTBS Meta-IV, Smalltalk-80, or C. The work presented demonstrates that it is possible and feasible to animate object-oriented design notation using a token moving approach. However, there is still much work to be done on the animation of dynamic instantiations and deletion of objects. We believe that graphical animation tools are the enabling technology for teamwork and for conceptual communication in the future concurrent engineering working environments. The work presented in this demo was carried out in the IPTES project. IPTBS is partially funded by the European Communities under the ESPRIT programme.
A New Approach to Stable Matching Problems
Authors: Ashok Subramanian
Venue: SIAM Journal on Computing (1994)

It is shown that Stable Matching problems are the same as problems about stable configurations of X-networks. Consequences include easy proofs of old theorems, a new simple algorithm for finding a stable matching, an understanding of the difference between Stable Marriage and Stable Roommates, NP-completeness of Three-party Stable Marriage, CC-completeness of several Stable Matching problems, and a fast parallel reduction from the Stable Marriage problem to the Assignment problem.
Comments on Balloon Help
Authors: Jonathan Price
Venue: ACM SIGDOC Asterisk Journal of Computer Documentation (1993)

In his excellent article, David Farkas points out several ways in which Balloon Help can encourage absolute beginners to explore and become familiar with the basics of the Macintosh interface. Too many of us who are intermediate and expert users dismiss Balloon Help as a joke because it soon gets in the way, it is stupid about our intentions, and it rarely answers task-oriented questions, despite the creators' obvious attempts to weave procedural instructions into the definitions.
Recontamination does not help to search a graph
Authors: Andrea S. LaPaugh
Venue: Journal of the ACM (JACM) (1993)

This paper is concerned with a game on graphs called graph searching. The object of this game is to clear all edges of a contaminated graph. Clearing is achieved by moving searchers, a kind of token, along the edges of the graph according to clearing rules. Certain search strategies cause edges that have been cleared to become contaminated again. Megiddo et al. [9] conjectured that every graph can be searched using a minimum number of searchers without this recontamination occurring, that is, without clearing any edge twice. In this paper, this conjecture is proved. This places the graph-searching problem in NP, completing the proof by Megiddo et al. that the graph-searching problem is NP-complete. Furthermore, by eliminating the need to consider recontamination, this result simplifies the analysis of searcher requirements with respect to other properties of graphs.
Identifying different paradigms for managing information technology
Authors: Sven J. Fischer, Jan Achterberg, Tsvi G. Vinig
Venue: Proceedings of the 1993 conference on Computer personnel research (1993)

Organizations are shaped based on a number of implicit and explicit assumptions. Usually, these assumptions are made by the founder of a company. Management of Information Technology (IT) is shaped in much the same way. It is based on several assumptions how to carry out information systems development, maintenance, information services, and how to plan for and control all these activities. Based on such assumptions, the authors identify four different approaches or paradigms to management of IT. A model is presented to position organizations in detail according to these paradigms. Potential ways of using the model are presented. Based on results of three types of empirical research, two ways of using the model are discussed in detail: the development of a necessary vision on the management of IT, and the identification of critical issues for the management of IT. The empirical results and the discussion of vision and critical issues lead to two major conclusions. First, there seemed to be no single goal to which IT organizations grow, i.e. all paradigms for managing IT were visible in practice. Second, although all paradigms were visible in practice, one paradigm, the paradigm of management control, dominated, despite the fact that for a lot of organizations this paradigm may not be the most obvious to rely upon. &ldquo;Ja mach' nur einen Plan!/ Sei nur ein grosses Licht!/ Und mach' dann noch'nen Zweiten Plan,/ Geh'n tun sie beide nicht&rdquo; (Bertold Brecht, Die Dreigroschenoper, Hofstede, 1978).
Computational diversity in a formal model of the insect olfactory macroglomerulus
Authors: C. Linster, C. Masson, M. Kerszberg, L. Personnaz, G. Dreyfus
Venue: Neural Computation (1993)

We present a model of the specialist olfactory system of selected moth species and the cockroach. The model is built in a semirandom fashion, constrained by biological (physiological and anatomical) data. We propose a classification of the response patterns of individual neurons, based on the temporal aspects of the observed responses. Among the observations made in our simulations a number relate to data about olfactory information processing reported in the literature; others may serve as predictions and as guidelines for further investigations. We discuss the effect of the stochastic parameters of the model on the observed model behavior and on the ability of the model to extract features of the input stimulation. We conclude that a formal network, built with random connectivity, can suffice to reproduce and to explain many aspects of olfactory information processing at the first level of the specialist olfactory system of insects.
The shared regions approach to software cache coherence on multiprocessors
Authors: Harjinder S. Sandhu, Benjamin Gamsa, Songnian Zhou
Venue: ACM SIGPLAN Notices (1993)

The effective management of caches is critical to the performance of applications on shared-memory multiprocessors. In this paper, we discuss a technique for software cache coherence tht is based upon the integration of a program-level abstraction for shared data with software cache management . The program-level abstraction, called Shared Regions, explicitly relates synchronization objects with the data they protect. Cache coherence algorithms are presented which use the information provided by shared region primitives, and ensure that shared regions are always cacheable by the processors accessing them. Measurements and experiments of the Shared Region approach on a shared-memory multiprocessors accessing them. Measurements and experiments of the Shared Region approach on a shared-memory multiprocessor are shown. Comparisons with other software based coherence strategies, including a user-controlled strategy and an operating system-based strategy, show that this approach is able to deliver better performance, with relatively low corresponding overhead and only a small increase in the programming effort. Compared to a compiler-based coherence strategy, the Shared Regions approach still performs better than a compiler that can achieve 90% accuracy in allowing cacheing, as long as the regions are a few hundred bytes or larger, or they are re-used a few times in the cache.
Conjectures on the Quotient Ring by Diagonal Invariants
Authors: Mark D. Haiman
Venue: Journal of Algebraic Combinatorics: An International Journal (1994)

We formulate a series of conjectures (and a few theorems) on the quotient of the polynomial ring {\Bbb Q}[x_1,\ldots , x_n, y_1, \ldots , y_n] in two sets of variables by the ideal generated by all Sn invariant polynomials without constant term. The theory of the corresponding ring in a single set of variables X &equals; &lcub;x1, &hellip;, xn&rcub; is classical. Introducing the second set of variables leads to a ring about which little is yet understood, but for which there is strong evidence of deep connections with many fundamental results of enumerative combinatorics, as well as with algebraic geometry and Lie theory.
A history of CLU
Authors: Barbara Liskov
Venue: The second ACM SIGPLAN conference on History of programming languages (1993)

The idea of a data abstraction has had a significant impact on the development of programming languages and on programming methodology. CLU was the first implemented programming language to provide direct linguistic support for data abstraction. This paper provides a history of data abstraction and CLU. CLU contains a number of other interesting and influential features, including its exception handling mechanism, its iterators, and its parameterized types.
Optimal code motion: theory and practice
Authors: Jens Knoop, Oliver Rüthing, Bernhard Steffen
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1994)

An implementation-oriented algorithm for lazy code motion is presented that minimizes the number of computations in programs while suppressing any unnecessary code motion in order to avoid superfluous register pressure. In particular, this variant of the original algorithm for lazy code motion works on flowgraphs whose nodes are basic blocks rather than single statements, since this format is standard in optimizing compilers. The theoretical foundations of the modified algorithm are given in the first part, where t-refined flowgraphs are introduced for simplifying the treatment of flow graphs whose nodes are basic blocks. The second part presents the &ldquo;basic block&rdquo; algorithm in standard notation and gives directions for its implementation in standard compiler environments.
ActorSpace: an open distributed programming paradigm
Authors: Gul Agha, Christian J. Callsen
Venue: ACM SIGPLAN Notices (1993)

We present a new programming paradigm called ActorSpace. ActorSpace provides a new communication model based on destination patterns. An actorSpace is a computationally passive container of actors which acts as a context for matching patterns. Patterns are matched against listed attributes of actors and actorSpaces that are visible in the actorSpace. Both visibility and attributes are dynamic. Messages may be sent to one or all members of a group defined by a pattern. The paradigm provides powerful support for component-based construction of massively parallel and distributed applications. In particular, it supports open interfaces to servers and pattern-directed access to software repositories.
Indexing for data models with constraints and classes (extended abstract)
Authors: Paris C. Kanellakis, Sridhar Ramaswamy, Darren E. Vengroff, Jeffrey S. Vitter
Venue: Proceedings of the twelfth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1993)

We examine I/O-efficient data structures that provide indexing support for new data models. The database languages of these models include concepts from constraint programming (e.g., relational tuples are generalized to conjunctions of constraints) and from object-oriented programming (e.g., objects are organized in class hierarchies). Let n be the size of the database, c the number of classes, B the secondary storage page size, and t the size of the output of a query. Indexing by one attribute in the constraint data model (for a fairly general type of constraints) is equivalent to external dynamic interval management, which is a special case of external dynamic 2-dimensional range searching. We present a semi-dynamic data structure for this problem which has optimal worst-case space O(n/B) pages and optimal query I/O time O(logBn+t/B) and has O(logBn+(log2Bn)/B) amortized insert I/O time. If the order of the insertions is random then the expected number of I/O operations needed to perform insertions is reduced to O(logBn). Indexing by one attribute and by class name in an object-oriented model, where objects are organized as a forest hierarchy of classes, is also a special case of external dynamic 2-dimensional range searching. Based on this observation we first identify a simple algorithm with good worst-case performance for the class indexing problem. Using the forest structure of the class hierarchy and techniques from the constraint indexing problem, we improve its query I/O time from O(log2c logBn + t/B) to O(logB + log2B).
Lowness: a yardstick for NP-P
Authors: Lane A. Hemaspaandra
Venue: ACM SIGACT News (1993)

This column gives a quick introduction to lowness theory [Sch83], which classifies the complexity of problems that are in NP but seem to be neither in P nor NP-complete.
Design of the commercial data masking facility data privacy algorithm
Authors: Don B. Johnson, Stephen M. Matyas, An V. Le, John D. Wilkins
Venue: Proceedings of the 1st ACM conference on Computer and communications security (1993)

This paper presents the details of the new Commercial Data Masking Facility (CDMF) data privacy algorithm1. When implemented appropriately, products containing the CDMF algorithm can, in general, be freely exported from the United States. A short discussion of the requirements and rationale of the new algorithm is given.This paper is an abbreviated version of a paper scheduled to be published in the March 1994 issue of the IBM Journal of Research and Development. The full paper will include a more extensive discussion of the requirements and rationale as well as a discussion of its strength under various threat scenarios and testcases to help ensure a correct implementation.
Security for individual computing environments
Authors: Elizabeth A. Unger
Venue: ACM SIGICE Bulletin (1994)

This issue of the SIGICE Bulletin has a focus of those aspects of security called secrecy and availability. Many of us, like the authors of one of the articles, asks the question, "Is security for PC's and workstations an oxymoron?" Individual Computing Environments (ICE), i.e., PC's, workstations, etc. often appear to most of us as being extremely vulnerable to a variety of secrecy and availability breaches with little one can do about the problems. What you will learn from the articles presented in this volume is that despite the vulnerability, these machines can be secured to the point of reducing the risk to a level one is willing to tolerate. The solutions suggested go beyond the commonly used virus detection and elimination software. I urge all who own or use individual computing environments on which data and programs reside to read this series of articles.
Incremental Boundary Evaluation Using Inference of Edge Classifications
Authors: James R. Miller
Venue: IEEE Computer Graphics and Applications (1993)

An incremental boundary-evaluation algorithm that exploits adjacency information in B-reps to minimize the number of explicit edge classifications required is presented. Evaluations of the implemented algorithm show that it performs reliably and well, although global optimization schemes could increase performance significantly. The steps of the algorithm, which include self-edge partitioning, cross-edge self-edge (CESE) classification, inference of self-edge classifications, and checking for split and merged shells, are discussed.
Comprehension syntax
Authors: Peter Buneman, Leonid Libkin, Dan Suciu, Val Tannen, Limsoon Wong
Venue: ACM SIGMOD Record (1994)

The syntax of comprehensions is very close to the syntax of a number of practical database query languages and is, we believe, a better starting point than first-order logic for the development of database languages. We give an informal account of a language based on comprehension syntax that deals uniformly with a variety of collection types; it also includes pattern matching, variant types and function definition. We show, again informally, how comprehension syntax is a natural fragment of structural recursion, a much more powerful programming paradigm for collection types. We also show that a very small "abstract syntax language" can serve as a basis for the implementation and optimization of comprehension syntax.
Interpreting a reconstructed relational calculus (extended abstract)
Authors: Aaron Watters
Venue: Proceedings of the 1993 ACM SIGMOD international conference on Management of data (1993)

This paper describes a method for answering all relational calculus queries under the assumption that the domain of data values is sufficiently large. The method extends recent theoretical results that use extended relation representations to answer domain dependent queries, without the use of auxilliary variables or invented constants or an explicit enumeration of the active domain. The method is shown to be logically correct and to have polynomial data complexity. By identifying relational algebra operations with relational calculus queries this approach extends relational algebra to a full boolean algebra, where intersection, union, and difference are defined between any two relations, whether or not they are union compatible. An example illustrates that this approach can be useful in distributed query optimization.
Simple characterizations of P(#P) and complete problems
Authors: Seinosuke Toda
Venue: Journal of Computer and System Sciences (1994)

In this paper, P(#P) and PF(#P) are characterized in terms of a largely different computation structure, where P(#P) (resp., PF(#P)) is the class of sets (resp., functions) that are polynomial-time Turing reducible to #P functions. Let MidP be the class of functions that give the medians in the outputs of metric Turing machines, where a metric Turing machine is a polynomial-time bounded nondeterministic Turing machine such that each branch writes a binary number on an output tape. Then it is shown that every function in PF(#P) is polynomial-time one-Turing reducible to a function in MidP and MidP @? PF (#P); that is, PF(#P) = PF(MidP[1]). Furthermore, it is shown that for all sets L, L is in P(#P) if and only if there is a function F @? MidP, such that for every string x, x @? L, iff F(x) is odd. Thus the problem of computing medians in the outputs of metric Turing machines captures the computational complexity of P(#P) and PF(#P). As applications of the results, several natural polynomial-time many-one complete problems for P(#P) are shown, for example, given an undirected graph with integer edge weights, checking that the parity of the middle cost among all the simple circuits is complete for P(#P).
An Ada 9X subset for inheritance-based reuse and its translation to Ada 83 (Part 1)
Authors: Michael Hirasuna
Venue: ACM SIGAda Ada Letters (1994)

An object oriented reuse strategy based on the Ada 9X inheritance syntax is presented. This paper defines a minimal Ada 9X subset that implements inheritance-based reuse, and outlines its translation to Ada 83. Inheritance allows software modules to be reused without modification to the original source. It is preferred to the "copy and tailor" approach, which has limited software life-cycle benefit since tailored copies need to be tested and maintained.Reuse may be applied at the low level, for components, or at higher levels, for subsystems. Inheritance may be used at any level of reuse, but it is more important for the higher levels. Ada 83 does not support inheritance, but low-level reuse can still be implemented in the form of generic components [BOO87]. The cost advantage from low-level reuse is already assumed when planning today's software systems. Further cost savings must come from high-level reuse, which needs inheritance to be implemented properly. Inheritance will be fully supported in Ada 9X.The approach presented here may be used in a reuse plan for a system that will start development before Ada 9X becomes viable. The Ada 9X subset allows the system software to be structured for reuse, to be implemented in Ada 83, and to be ready for migration to Ada 9X.This is the first part of a two-part paper. This part will discuss the reuse strategy and define an Ada 9X subset that will implement it. In the second part, a translation from the Ada 9X subset to Ada 83 will be outlined.
Cost of state saving rollback
Authors: John Cleary, Fabian Gomes, Brian Unger, Zhonge Xiao, Raimar Thudt
Venue: Proceedings of the eighth workshop on Parallel and distributed simulation (1994)

Approaches to state saving and rollback for a shared memory, optimistically synchronized, simulation executive are presented. An analysis of copy state saving and incremental state saving is made and these two schemes are compared. Two benchmark programs are then described, one a simple, all overhead, model and one a performance model of a regional Canadian public telephone network. The latter is a large SS7 common channel signalling model that represents a very challenging, practical, test application for parallel simulation. Experimental results are presented which show the necessity and sufficiency of incremental state saving for this application.
Fips: a functional-imperative language for explorative programming
Authors: Jacek Passia, Klaus-Peter Löhr
Venue: ACM SIGPLAN Notices (1993)

Fips is a language that integrates functional and imperative programming in a clean way. On the one hand, it is a full-fledged functional language with pattern matching, non-strict functions, polymorphism and data abstraction. On the other hand, it can be viewed as an imperative language which uses side-effect-free functions and, due to the functional heritage, is markedly more expressive than conventional languages. In addition, Fips features an unusual treatment of undefined values which allows for simple exception handling and backtracking.