ppxscal/embedding_network huggingface dataset:
Marquise: creating complete user interfaces by demonstration
Authors: Brad A. Myers, Richard G. McDaniel, David S. Kosbie
Venue: Proceedings of the INTERACT '93 and CHI '93 conference on Human factors in computing systems (1993)

Marquise is a new interactive tool that allows virtually all of the user interfaces of graphical editors to be created by demonstration without programming. A &ldquo;graphical editor&rdquo; allows the user to create and manipulate graphical objects with a mouse. This is a very large class of programs and includes drawing programs like MacDraw, graph layout editors like MacProject, visual language editors, and many CAD/CAM programs. The primary innovation in Marquise is to allow the designer to demonstrate the overall behavior of the interface. To implement this, the Marquise framework contains knowledge about palettes for creating and specifying properties of objects, and about operations such as selecting, moving, and deleting objects. The interactive tool uses the framework to allow the designer to demonstrate most of the end user's actions without programming, which means that Marquise can be used by non-programmers.
State assignment for hardwired VLSI control units
Authors: Bernhard Eschermann
Venue: ACM Computing Surveys (CSUR) (1993)

Finding a binary encoding of symbolic control states, such that the implementation area of a digital control unit is minimized is well known to be NP-complete. Many heuristic algorithms have been proposed for this state assignment problem. The objective of this article is to present a comprehensive survey and systematic categorization of the various techniques, in particular, for synchronous sequential circuits with nonmicroprogrammed implementations. The problem is partitioned into the generation and the satisfaction of coding constraints. Three types of coding constraints&mdash;adjacency, covering, and disjunctive constraints&mdash;are widely used. The constraint satisfaction algorithms are classified into column-based, row-based, tree-based, dichotomy-based, and global minimization approaches. All of them are illustrated with examples. Special coding requirements and testability-related aspects of state assignment are considered in a separate section. Different implementations of the algorithms presented are also compared.
Memory consistency models
Authors: David Mosberger
Venue: ACM SIGOPS Operating Systems Review (1993)

This paper discusses memory consistency models and their influence on software in the context of parallel machines. In the first part we review previous work on memory consistency models. The second part discusses the issues that arise due to weakening memory consistency. We are especially interested in the influence that weakened consistency models have on language, compiler, and runtime system design. We conclude that tighter interaction between those parts and the memory system might improve performance considerably.
On the complexity of functions for random access machines
Authors: Nader H. Bshouty
Venue: Journal of the ACM (JACM) (1993)

Tight bounds are proved for Sort, Merge, Insert, Gcd of integers, Gcd of polynomials, and Rational functions over a finite inputs domain, in a random access machine with arithmetic operations, direct and indirect addressing, unlimited power for answering YES/NO questions, branching, and tables with bounded size. These bounds are also true even if additions, subtractions, multiplications, and divisions of elements by elements of the field are not counted. In a random access machine with finitely many constants and a bounded number of types of instructions, it is proved that the complexity of a function over a countable infinite domain is equal to the complexity of the function in a sufficiently large finite subdomain.
Parallel triangular decompositions of an oil refining simulation
Authors: Xiaodong Zhang
Venue: Proceedings of the 7th international conference on Supercomputing (1993)

One important process in oil refining is to separate the crude oil into various oil products. This process is called distillation. In designing a complex distillation column, a large computer simulation is conducted. This paper presents our experience with parallelizing an oil refining simulation application that computes the composition of the various oil products in designed refining columns operated under a given set of conditions. Mathematical models for the simulation form large sparse nonlinear systems of equations. Triangular decompositions of sparse nonlinear systems are fundamental numerical methods in this simulation computing. Different approaches have been applied to carry out this simulation in parallel. Parallelisms of the simulation are exploited at three levels&mdash;direct parallelization, structured parallelization and a synchronous parallelization of the problem. The approaches of this practical research provide insight into some important issues of parallel computing for real-world applications. The parallel programs were implemented and run on the Intel iPSC/860. Parallel computing results are presented with comparisons and discussions.
Balanced scheduling: instruction scheduling when memory latency is uncertain
Authors: Daniel R. Kerns, Susan J. Eggers
Venue: Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation (1993)

Traditional list schedulers order instructions based on an optimistic estimate of the load delay imposed by the implementation. Therefore they cannot respond to variations in load latencies (due to cache hits or misses, congestion in the memory interconnect, etc.) and cannot easily be applied across different implementations. We have developed an alternative algorithm, known as balanced scheduling, that schedule instructions based on an estimate of the amount of instruction level parallelism in the program. Since scheduling decisions are program-rather than machine-based, balanced scheduling is unaffected by implementation changes. Since it is based on the amount of instruction level parallelism that a program can support, it can respond better to variations in load latencies. Performance improvements over a traditional list scheduler on a Fortran workload and simulating several different machine types (cache-based workstations, large parallel machines with a multipath interconnect and a combination, all with non-blocking processors) are quite good, averaging between 3% and 18%.
Deriving fold/unfold transformations of logic programs using extended OLDT-based abstract interpretation
Authors: Dmitri Boulanger, Maurice Bruynooghe
Venue: Journal of Symbolic Computation (1993)

An extension of OLDT based abstract interpretation for definite logic programs is presented. The extension can abstract the behavior of programs under different computation rules. The abstract behavior is captured in an EOLDT structure. It is shown that this EOLDT structure can guide an automatic equivalence preserving fold/unfold transformation. By making the appropriate choices during the abstract interpretation phase, one can obtain EOLDT structures which lead to a very broad range of transformations. It is argued that the approach provides a unifying framework for a large class of transformations.
Computational reflection in PowerEpsilon
Authors: Ming-Yuan Zhu
Venue: ACM SIGPLAN Notices (1994)

Reflective programming languages were introduced in order to study programs that need knowledge of their own behavior. In artificial intelligence, this kind of knowledge is heeded, for example, in programs that must explain their behavior to a user. In the study of programming languages, a similar phenomenon occurs in extensible languages, that is, languages in which one can write programs that change the language itself. In this paper, we present an investigation of computational reflection mechanism in a higher-order lambda;-calculus - PowerEpsilon. We will show that PowerEpsilon is an extremely rich and powerful language for reflective computation.
Performance evaluation of ephemeral logging
Authors: John S. Keen, William J. Dally
Venue: Proceedings of the 1993 ACM SIGMOD international conference on Management of data (1993)

Ephemeral logging (EL) is a new technique for managing a log of database activity on disk. It does not require periodic checkpoints and does not abort lengthy transactions as frequently as traditional firewall logging for the same amount of disk space. Therefore, it is well suited for highly concurrent databases and applications which have a wide distribution of transaction lifetimes. This paper briefly explains EL and then analyzes its performance. Simulation studies indicate that it can offer significant savings in disk space, at the expense of slightly higher bandwidth for logging and more main memory. The reduced size of the log implies much faster recovery after a crash as well as cost savings. EL is the method of choice in some but not all situations. We assess the limitations of our current knowledge about EL and suggest promising directions for further research.
Concurrent replicating garbage collection
Authors: James O'Toole, Scott Nettles
Venue: Proceedings of the 1994 ACM conference on LISP and functional programming (1994)

We have implemented a concurrent copying garbage collector that uses replicating garbage collection. In our design, the client can continuously access the heap during garbage collection. No low-level synchronization between the client and the garbage collector is required on individual object operations. The garbage collector replicates live heap objects and periodically synchronizes with the client to obtain the client's current root set and mutation log. An experimental implementation using the Standard ML of New Jersey system on a shared-memory multiprocessor demonstrates excellent pause time performance and moderate execution time speedups.
Non-linear type extensions
Authors: Bob Brown
Venue: ACM SIGPLAN Notices (1994)

Type extension is a language facility proposed by N. Wirth and included in the programming language Oberon. The facility allows a type to be created based on another type while maintaining a hierarchic type relationship. This paper gives an introduction to the type extension facility as it is implemented in Oberon and shows how it can be generalised to allow a non-linear type hierarchy to be constructed and discriminated.
Neural networks for optimization problems with inequality constraints: the knapsack problem
Authors: Mattais Ohlsson, Carsten Peterson, Bo Söderberg
Venue: Neural Computation (1993)

A strategy for finding approximate solutions to discrete optimization problems with inequality constraints using mean field neural networks is presented. The constraints x d 0 are encoded by x&ndash;(x) terms in the energy function. A careful treatment of the mean field approximation for the self-coupling parts of the energy is crucial, and results in an essentially parameter-free algorithm. This methodology is extensively tested on the knapsack problem of size up to 103 items. The algorithm scales like NM for problems with N items and M constraints. Comparisons are made with an exact branch and bound algorithm when this is computationally possible (N d 30). The quality of the neural network solutions consistently lies above 95% of the optimal ones at a significantly lower CPU expense. For the larger problem sizes the algorithm is compared with simulated annealing and a modified linear programming approach. For "nonhomogeneous" problems these produce good solutions, whereas for the more difficult "homogeneous" problems the neural approach is a winner with respect to solution quality and/or CPU time consumption. The approach is of course also applicable to other problems of similar structure, like set covering.
A methodology for implementing highly concurrent data objects
Authors: Maurice Herlihy
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1993)

A concurrent object is a data structure shared by concurrent processes. Conventional techniques for implementing concurrent objects typically rely on critical sections; ensuring that only one process at a time can operate on the object. Nevertheless, critical sections are poorly suited for asynchronous systems: if one process is halted or delayed in a critical section, other, nonfaulty processes will be unable to progress. By contrast, a concurrent object implementation is lock free if it always guarantees that some process will complete an operation in a finite number of steps, and it is wait free if it guarantees that each process will complete an operation in a finite number of steps. This paper proposes a new methodology for constructing lock-free and wait-free implementations of concurrent objects. The object's representation and operations are written as stylized sequential programs, with no explicit synchronization. Each sequential operation is atutomatically transformed into a lock-free or wait-free operation using novel synchronization and memory management algorithms. These algorithms are presented for a multiple instruction/multiple data (MIMD) architecture in which n processes communicate by applying atomic read, write, load_linked, and store_conditional operations to a shared memory.
Options in physical database design
Authors: Goetz Graefe
Venue: ACM SIGMOD Record (1993)

A cornerstone of modern database systems is physical data independence, i.e., the separation of a type and its associated operations from its physical representation in memory and on storage media. Users manipulate and query data at the logical level; the DBMS translates these logical operations to operations on files, indices, records, and disks. The efficiency of these physical operations depends very much on the choice of data representations. Choosing a physical representation for a logical database is called physical database design. The number of possible choices in physical database design is very large; moreover, they very often interact with each other. We attempt to list and classify these choices and to explore their interactions. The purpose of this paper is to provide an overview of possible options to the DBMS developer and some guidance to the DBMS administrator and user. While much of our discussion will draw on the relational data model, physical database design is of even more importance for object-oriented and extensible systems. The reasons are simple: First, the number of logical data types and their operations is larger, requiring and permitting more choices for their representation. Second, the state of the art in query optimization for these systems is much less developed than for relational systems, making careful physical database design even more imperative for object-oriented database systems.
A modified form of software science measures
Authors: K. K. Aggarwal, Yogesh Singh
Venue: ACM SIGSOFT Software Engineering Notes (1994)

In attempting to describe the quality of computer software, one of the most frequently mentioned measurable attributes is the complexity of the flow of control. During the past several years, there have been many attempts to quantify this aspect of computer program, approaching the problem from such diverse points of view as graph theory and software science. Existing software science provides a general measure of program complexity, but it fails to adequately quantify program control flow complexity except for the linearization issue. In this paper, weights are assigned to the operators and operands which are part of the control structures. Although similar type of approach was used by Ramamurthy amp; Melton for few control structures, there was a need for a generalized approach and this paper is an attempt in this direction.
Inferring Evolutionary History from DNA Sequences
Authors: Sampath K. Kannan, Tandy J. Warnow
Venue: SIAM Journal on Computing (1994)

One of the longstanding problems in computational molecular biology is the Character Compatibility Problem, which is concerned with the construction of phylogenetic trees for species sets, where the species are defined by characters. The character compatibility problem is NP-Complete in general. In this paper an $O(n^2 k)$ time algorithm is described for the case where the species are described by quaternary characters. This algorithm can be used to construct phylogenetic trees from DNA sequences.
A conceptual framework for software development
Authors: Spiros Mancoridis, Richard C. Holt, David A. Penny
Venue: Proceedings of the 1993 ACM conference on Computer science (1993)

Large scale software development is an intrinsically difficult task. Developers use a set of specialized tools to alleviate some of this difficulty. The problem is that most of these tools are not integrated and do little to help developers and managers maintain an overall view of the development by organizing the software entities, created by tools, in a consistent fashion. Our solution, called the Software Landscape, provides developers with a conceptual framework of integrated tools while providing a metaphor for managing the complexities of large-scale software development. The Software Landscape is a metaphor of a country-side viewed from above in which each major entity, such as a software project, appears as a large plot of land, and each minor entity, such as a source C module, is contained within a plot. Plots can be libraries of reusable software as well as ongoing developments. A Software Landscape can be used as a mechanism that allows the developer to navigate around the entities created during the software development process, much the way a flight simulator allows one to &ldquo;fly&rdquo; and optionally to dive down to entities of interest. During this flight, and controls their level of visible detail. This model is constructive, allowing the developer to manipulate, as well as view, the entities of the Landscape.
Polymorphism and subtyping in interface
Authors: Dinesh Katiyar, David Luckham, John Mitchell
Venue: Proceedings of the workshop on Interface definition languages (1994)

RAPIDE is a programming language framework designed for the development of large, concurrent, real-time systems by prototyping. The framework consists of a type language and default executable, specification and architecture languages, along with associated programming tools. Interfaces are the central construct of the type system. This document describes RAPIDE interfaces, their expressiveness and their use as a typing construct.
Common elements in today's graphical user interfaces: the good, the bad, and the ugly
Authors: A. Brady Farrand
Venue: Proceedings of the INTERACT '93 and CHI '93 conference on Human factors in computing systems (1993)

This panel will identify some of the similarities amongst the different familiar graphical user interfaces that make them seem so indistinguishable. This panel will then identify some of the similarities that don't belong in any modern user interface.
Markov analysis of software specifications
Authors: James A. Whittaker, J. H. Poore
Venue: ACM Transactions on Software Engineering and Methodology (TOSEM) (1993)

A procedure for modeling software usage with the finite state, discrete parameter Markov chain is described. It involves rigorous analysis of the specification before design and coding begin. Many benefits emerge from this process, including the ability to synthesize a macro level usage distribution from a micro level understanding of how the software will be used. This usage distribution becomes the basis for a statistical test of the software, which is fundamental to the Cleanroom development process. Some analytical results known for Markov chains that have meaningful implications and interpretations for the software development process are described.
Optimal response time retrieval of replicated data (extended abstract)
Authors: Ling Tony Chen, Doron Rotem
Venue: Proceedings of the thirteenth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1994)

This work deals with the problem of finding efficient access plans for retrieving a set of pages from a multi-disk system with replicated data. This paper contains two results related to this problem: (a) We solve the problem of finding an optimal access path by transforming it into a network flow problem. We also indicate how our method may be employed in dynamic environments where some (or all) of the disks have a preexisting load, are heterogeneous, and reside on different servers. (b) We present a lower bound for the worst case response time of a request under all replication schemes, and also discuss the replication scheme that results in this lower bound. We then use simulation to show how this replication scheme can also greatly reduce the average case response time.
SCARFS, an efficient polynomial zero-finder system
Authors: Tien Chi Chen
Venue: ACM SIGAPL APL Quote Quad (1993)

Programs in SCARFS makes a top-down search for zeros which are leaves in a polynomial tree, in which internal nodes represent clusters of high symmetry. Using new schemes for multiplicity estimation and iterate repositioning upon local rebounds by clusters, zeros are found one at a time with deflation in between. For arbitrary polynomials, a zero usually is found in fewer than 10 complex arithmetic iterations, showing significant gain in accuracy and speed over prior methods.
Checklist for security and contingency planning
Venue: ACM SIGSAC Review (1993)

That parody of Kipling has become a cliche, but it can be an apt characterization of the manager confronting a data processing (DP) emergency. Well-prepared DP managers, however, may keep their heads, and their jobs, for a much more laudable reason: because they know that their contingency plans are adequate to deal with the situations they encounter. With organizational dependence on DP growing at unprecedented rates, little could be more important today.
Using virtual lines to enhance locality exploitation
Authors: O. Temam, Y. Jegou
Venue: Proceedings of the 8th international conference on Supercomputing (1994)

Because the spatial locality of numerical codes is significant, the potential for performance improvements is important. However, large cache lines cannot be used in current on-chip data caches because of the important pollution they breed. In this paper, we propose a hardware design, called the Virtual Line Scheme, that allows the utilization of large virtual cache lines when fetching data from memory for better exploitation of spatial locality, while the actual physical cache line is smaller than currently found cache lines for better exploitation of temporal locality. Simulations show that a 17% to 64% reduction of the average memory access time can be obtained for a 20-cycle memory latency. It is also shown how simple software informations can be used to significantly decrease memory traffic, a flaw associated with the utilization of large cache lines.
Encapsulating knowledge for intelligent automatic interaction objects selection
Authors: Jean M. Vanderdonckt, François Bodart
Venue: Proceedings of the INTERACT '93 and CHI '93 conference on Human factors in computing systems (1993)

TRIDENT is a set of interactive tools that automatically generates a user interface for highly-interactive business-oriented applications. It includes an intelligent interaction objects selection based on three different concepts. First, on object oriented typology classifies abstract interaction objects to allow a presentation independent selection. Second, guidelines are translated into automatic rules to select abstract interaction objects from both an application data model and a dialog model. Third, these guidelines are encapsulated in a decision tree technique to make the reasoning obvious to the user. This approach guarantees a target environment independent user interface. Once this specified, abstract interaction objects are mapped into concrete interaction objects to produce the observable interface.
An introduction to ultimately periodic sets of integers
Authors: Armando B. Matos
Venue: ACM SIGACT News (1994)

We summarize some of the theory and an application of a new method for representing "periodic" sets of integers. A much more detailed discussion will be presented in [5].