ppxscal/embedding_network huggingface dataset:
Mutation analysis using mutant schemata
Authors: Roland H. Untch, A. Jefferson Offutt, Mary Jean Harrold
Venue: Proceedings of the 1993 ACM SIGSOFT international symposium on Software testing and analysis (1993)

Mutation analysis is a powerful technique for assessing and improving the quality of test data used to unit test software. Unfortunately, current automated mutation analysis systems suffer from severe performance problems. This paper presents a new method for performing mutation analysis that uses program schemata to encode all mutants for a program into one metaprogram, which is subsequently compiled and run at speeds substantially higher than achieved by previous interpretive systems. Preliminary performance improvements of over 300% are reported. This method has the additional advantages of being easier to implement than interpretive systems, being simpler to port across a wide range of hardware and software platforms, and using the same compiler and run-time support system that is used during development and/or deployment.
Genetic algorithm application in a machine scheduling problem
Authors: Mahesh C. Gupta, Yash P. Gupta Anup Kumar
Venue: Proceedings of the 1993 ACM conference on Computer science (1993)

In this paper, we address an n-job, single machine scheduling problem with an objective to minimize the flow time variance. We propose heuristic procedure based on Genetic Algorithms with the potential to address more generalized objective function such as weighted flow time variance. The development and implementation of the algorithm is supported with an extensive literature review and statistical analysis of the results. Some general guidelines to select the parameter values of the genetic algorithm are also developed using an experimental design approach.
Load/store range analysis for global register allocation
Authors: Priyadarshan Kolte, Mary Jean Harrold
Venue: Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation (1993)

Live range splitting techniques improve global register allocation by splitting the live ranges of variables into segments that are individually allocated registers. Load/store range analysis is a new technique for live range splitting that is based on reaching definition and live variable analyses. Our analysis localizes the profits and the register requirements of every access to every variable to provide a fine granularity of candidates for register allocation. Experiments on a suite of C and FORTRAN benchmark programs show that a graph coloring register allocator operating on load/store ranges often provides better allocations than the same allocator operating on live ranges. Experimental results also show that the computational cost of using load/store ranges for register allocation is moderately more than the cost of using live ranges.
A practical soft type system for Scheme
Authors: Andrew K. Wright, Robert Cartwright
Venue: Proceedings of the 1994 ACM conference on LISP and functional programming (1994)

Soft typing is a generalization of static type checking that accommodates both dynamic typing and static typing in one framework. A soft type checker infers types for identifiers and inserts explicit run-time checks to transform untypable programs into typable form. Soft Scheme is a practical soft type system for R4RS Scheme. The type checker uses a representation for types that is expressive, easy to interpret, and supports efficient type inference. Soft Scheme supports all of R4RS Scheme, including uncurried procedures of fixed and variable arity, assignment, and continuations.
Learning the Korn shell
Authors: Bill Rosenblatt
Venue:  (1993)

A thorough introduction to the Korn shell, both as a user interface and as a programming language. This book provides a clear explanation of the Korn shell's features, including ksh string operations, co-processes, signals and signal handling, and command-line interpretation. Learning the Korn Shell also includes real-life programming examples and a Korn shell debugger (kshdb).
Take CoVer: exploiting version support in cooperative systems
Authors: Anja Haake
Venue: Proceedings of the INTERACT '93 and CHI '93 conference on Human factors in computing systems (1993)

Current CSCW applications support one or more modes of cooperative work. The selection of and transition between these modes is usually placed on the users. At IPSI we built the SEPIA cooperative hypermedia authoring environment supporting a whole range of situations arising during collaborative work and the smooth transitions between them. While early use of the system shows the benefits of supporting smooth transitions between different collaborative modes, it also reveals some deficits regarding parallel work, management of alternative documents, or reuse of document parts. We propose to integrate version support to overcome these limitations. This leads to a versioned data management and an extended user interface enabling concurrent users to select a certain state of their work, to be aware of related changes, and to cooperate with others either asynchronously or synchronously.
A Construction of Difference Sets in High Exponent 2-Groups Using Representation Theory
Authors: James A. Davis, Ken Smith
Venue: Journal of Algebraic Combinatorics: An International Journal (1994)

Nontrivial difference sets in groups of order a power of 2 are part of the family of difference sets called Menon difference sets (or Hadamard), and they have parameters (22d+2, 22d+1&plusmn;2d, 22d&plusmn;2d). In the abelian case, the group has a difference set if and only if the exponent of the group is less than or equal to 2d+2. In &lsqb;14&rsqb;, the authors construct a difference set in a nonabelian group of order 64 and exponent 32. This paper generalizes that result to show that there is a difference set in a nonabelian group of order 22d+2 with exponent 2d+3. We use representation theory to prove that the group has a difference set, and this shows that representation theory can be used to verify a construction similar to the use of character theory in the abelian case.
Dynamic Load Balancing for Parallel Polygon Rendering
Authors: Scott Whitman
Venue: IEEE Computer Graphics and Applications (1994)

Using parallel processing for visualization speeds up computer graphics rendering of complex data sets. A parallel algorithm designed for polygon scan conversion and rendering is presented which supports fast rendering of highly complex data sets using advanced lighting models. Dedicated graphics rendering engines do not necessarily suit such data sets, although they can support real-time update of moderately complex scenes using simple lighting. Advantages to using a software-based approach include the feasibility of adding special rendering features to the program and the capability of integrating a parallel scientific application with a parallel graphics renderer. A new work decomposition strategy presented, called task adaptive, is based on dynamically partitioning the amount of computational work left at a given time. The algorithm uses a heuristic for dynamic task decomposition in which image space tasks are partitioned without requiring interruption of the partitioned processor. A sophisticated memory referencing strategy lets local memory access graphics data during rendering. This permits implementation of the algorithm on a distributed memory multiprocessor. An in-depth analysis of the overhead costs accompanying parallel processing shows where performance is adequate or could be improved.
Fixpoint computation for polyvariant static analyses of higher-order applicative programs
Authors: J. Michael Ashley, Charles Consel
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1994)

This paper presents an optimized general-purpose algorithm for polyvariant, static analyses of higher-order applicative programs. A polyvariant analysis is a very accurate form of analysis that produces many more abstract descriptions for a program than does a conventional analysis. It may also compute intermediate abstract descriptions that are irrelevant to the final result of the analysis. The optimized algorithm addresses this overhead while preserving the accuracy of the analysis. The algorithm is also parameterized over both the abstract domain and degree of polyvariance. We have implemented an instance of our algorithm and evaluated its performance compared to the unoptimized algorithm. Our implementation runs significantly faster on average than the other algorithm for benchmarks reported here.
LH: Linear Hashing for distributed files
Authors: Witold Litwin, Marie-Anne Neimat, Donovan A. Schneider
Venue: Proceedings of the 1993 ACM SIGMOD international conference on Management of data (1993)

LH* generalizes Linear Hashing to parallel or distributed RAM and disk files. An LH* file can be created from objects provided by any number of distributed and autonomous clients. It can grow gracefully, one bucket at a time, to virtually any number of servers. The number of messages per insertion is one in general, and three in the worst case. The number of messages per retrieval is two in general, and four in the worst case. The load factor can be about constant, 65-95%, depending on the file parameters. The file can also support parallel operations. An LH* file can be much faster than a single site disk file, and/or can hold a much larger number of objects. It can be more efficient than any file with a centralized directory, or a static parallel or distributed hash file.
Embedding computer-based critics in the contexts of design
Authors: Gerhard Fischer, Kumiyo Nakakoji, Jonathan Ostwald, Gerry Stahl, Tamara Sumner
Venue: Proceedings of the INTERACT '93 and CHI '93 conference on Human factors in computing systems (1993)

Computational critiquing mechanisms provide an effective form of computer-human interaction supporting the process of design. Critics embedded in domain-oriented design environments can take advantage of additional knowledge residing in these environments to provide less intrusive, more relevant critiques. Three classes of embedded critics have been designed, implemented, and studied: Generic critics use domain knowledge to detect problematic situations in the design construction. Specific critics take advantage of additional knowledge in the partial specification to detect inconsistencies between the design construction and the design specification. Interpretive critics are tied to perspective mechanisms that support designers in examining their artifact from different viewpoints.
Object-oriented concurrent programming (abstract)
Authors: Jean-Pierre Briot
Venue: Addendum to the proceedings on Object-oriented programming systems, languages, and applications (Addendum) (1992)

Object-Oriented Concurrent Programming Jean-Pierre Briot, Institute Blaise Pascal, France This tutorial treats object-oriented concurrent programming (OOCP) as the natural generalization of object-oriented programming. OOCP decomposes a large program into a collection of small modules that run and interact concurrently and are capable of exploiting parallel hardware. The tutorial describes various levels of integration between object-oriented programming and concurrency, leading to the notion of an active object, which unifies object and activity, message passing and synchronization. The tutorial introduces Concurrent Smalltalk to describe concepts, constructs, and methodology. Examples include programming with continuations, divide and conquer, and pipelining. It also shows how to implement active objects, and uses Actalk as an example. Finally, it compares various OOP models and languages, with a special focus on the Actor computation model. Although the tutorial uses Smalltalk for examples, you dont need to know Smalltalk to understand it; a quick introduction to Smalltalk syntax is included. It assumes that you understand object-oriented programming well, but little more about concurrency than intuitive concepts of processes and synchronization.
Solving queries by tree projections
Authors: Yehoshua Sagiv, Oded Shmueli
Venue: ACM Transactions on Database Systems (TODS) (1993)

Suppose a database schema D is extended to D&macr; by adding new relation schemas, and states for D are extended to states for D&macr; by applying joins and projections to existing relations. It is shown that certain desirable properties that D&macr; has with respect to D. These properties amount to the ability to compute efficiently the join of all relations in a state for D from an extension of this state over D&macr;. The equivalence is proved for unrestricted (i.e., both finite and infinite) databases. If D&macr; is obtained from D by adding a set of new relation schemas that form a tree schema, then the equivalence also holds for finite databases. In this case there is also a polynomial time algorithm for testing the existence of a tree projection of D&macr; with respect to D.
Performance analysis of file organizations that use multibucket data leaves with partial expansions
Authors: Gabriel Matsliach
Venue: ACM Transactions on Database Systems (TODS) (1993)

We present an exact performance analysis, under random insertions, of file organizations that use multibucket data leaves and perform partial expansions before splitting. We evaluate the expected disk space utilization of the file and show how the expected search and insert costs can be estimated. The analytical results are confirmed by simulations. The analysis can be used to investigate both the dynamic and the asymptotic behaviors.
Rounding errors in certain algorithms involving Markov chains
Authors: Winfried K. Grassmann
Venue: ACM Transactions on Mathematical Software (TOMS) (1993)

A number of algorithms involving Markov chains contain no subtractions. This property makes the analysis of rounding errors particularly simple. To show this, some principles for analyzing the propagation and generation of rounding errors in algorithms containing no subtraction are discussed first. These principles are then applied in the context of a simple recursive algorithm involving the transient solution of discrete-time Markov chains, Jensen's algorithm, and state reduction. Jensen's algorithm, also known as randomization or uniformization, is an algorithm for finding transient solutions of continuous-time Markov chains. State reduction is a method for finding equilibrium probabilities for discrete-time or continuous-time Markov chains.
The practice of business process reengineering: radical planning and incremental implementation in an IS organization
Authors: Michael Albers, Ritu Agarwal, Mohan Tanniru
Venue: Proceedings of the 1994 computer personnel research conference on Reinventing IS : managing information technology in changing organizations: managing information technology in changing organizations (1994)

Business process reengineering has been proposed as a viable methodology whenever a radical shift in the way an organization performs its functions is desired. However, implementing the outcomes of a business process reengineering effort, viz., a new process, is no easy matter. This is especially true when an organization is uncertain of the potential of the new process and is also resource constrained. Nevertheless, a lack of commitment to quickly implement new process designs does not diminish the value an organization gains from such a critical examination of current practices. In this paper we argue that business process reengineering ought to be regarded as a radical, administrative, process-oriented organizational innovation. We present the approach taken by an IS organization to reengineer one of its key business processes&mdash;change management&mdash;and the issues and challenges that surfaced during the reengineering exercise. Although the suggestions for process redesign generated represented a radical departure from existing practice, the organization has elected to implement the ideas in an incremental fashion. The implementation strategy is examined in light of the nature of the innovation signified by business process reengineering.
A concurrent, generational garbage collector for a multithreaded implementation of ML
Authors: Damien Doligez, Xavier Leroy
Venue: Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1993)

This paper presents the design and implementation of a &ldquo;quasi real-time&rdquo; garbage collector for Concurrent Caml Light, an implementation of ML with threads. This two-generation system combines a fast, asynchronous copying collector on the young generation with a non-disruptive concurrent marking collector on the old generation. This design crucially relies on the ML compile-time distinction between mutable and immutable objects.
Scheduling time-critical instructions on RISC machines
Authors: Krishna V. Palem, Barbara B. Simons
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1993)

We present a polynomial time algorithm for constructing a minimum completion time schedule of instructions from a basic block on RISC machines such as the Sun SPARC, the IBM 801, the Berkeley RISC machine, and the HP Precision Architecture. Our algorithm can be used as a heuristic for RISC processors with longer pipelines, for which there is no known optimal algorithm. Our algorithm can also handle time-critical instructions, which are instructions that have to be completed by a specific time. Time-critical instructions occur in some real-time computations, and can also be used to make shared resources such as registers quickly available for reuse. We also prove that in the absence of time-critical constraints, a greedy scheduling algorithm always produces a schedule for a target machine with multiple identical pipelines that has a length less than twice that of an optimal schedule. The behavior of the heuristic is of interest because, as we show, the instruction scheduling problem becomes NP-hard for arbitrary length pipelines, even when the basic block of code being input consists of only several independent streams of straightline code, and there are no time-critical constraints. Finally, we prove that the problem becomes NP-hard even for small pipelines, no time-critical constraints, and input of several independent streams of straightline code if either there is only a single register or if no two instructions are allowed to complete simultaneously because of some shared resource such as a bus.
Computation migration: enhancing locality for distributed-memory parallel systems
Authors: Wilson C. Hsieh, Paul Wang, William E. Weihl
Venue: ACM SIGPLAN Notices (1993)

We describe computation migration, a new technique that is based on compile-time program transformations, for accesing remote data in a distributed-memory parallel system. In contrast with RPC-style access, where the access is performed remotely, and with data migration, where the data is moved so that it is local, computation migration moves part of the current thread to the processor where the data resides. The access is performed at the remote processor, and the migrated thread portion continues to run on that same processor; this makes subsequent accesses in the thread portion local. We describe an implementation of computation migration that consists of two parts: an implementation that migrates single activation frames, and a high-level language annotation that allows a programmer to express when migration is desired. We performed experiments using two applications; these experiments demonstrate that computation migration is a valuable alternative to RPC and data migration.
Fault tolerance: synchronization of redundancy
Authors: Alexander B. Romanovsky
Venue: ACM SIGOPS Operating Systems Review (1993)

The purpose of this paper is to single out and generalize about the essential features and properties of synchronization and to argue in favour of the idea of designing and developing fault tolerance for distributed computer system on the basis of a multilevel synchronization system. We propose to consider designing and developing a hierarchical system of synchronizing redundant components in these systems the first and foremost stage in providing fault tolerance in application systems. The general peculiarities of using synchronization system for this end are considered.
Is the effectiveness of formal end-user software training a mirage?
Authors: Conrad Shayo, Lorne Olfman
Venue: Proceedings of the 1993 conference on Computer personnel research (1993)

Formal methods are perceived to play an important role in end-user software training and learning. However, evidence does not exist to support the effectiveness of formalized training on future use of the target software. This study uses qualitative research methods to explore the views of end-users with respect to the most recent formal software training session they attended. We use concepts from theories of self-regulation to generate questions and propositions that guide our analysis. Goals and intentions, self-efficacy and expectancy, individual characteristics, feedback and support were the subject of our questions. It was clear that pre-training goals were not matched with trainer goals, and that most trainees who adopted the software needed a second round of training before they began to use it on the job. Our interviewees provide recommendations for trainers, administrators, and software vendors with respect to software training. They advocate the need to establish training relevance early and ensure congruence of the goals of all the stakeholders. We discuss the findings and implications of the study and suggest areas for further study.
Testing of Ada compiler diagnostics
Authors: Vitali Sh. Kaufman, Mikhail V. Pavlov, Sergei I. Rybin
Venue: ACM SIGAda Ada Letters (1993)

This paper presents the main results obtained by the research group of the Computer Science Department of Moscow State University in developing methods and tools for validating compiler diagnostics.Methods of diagnostic test design based on partially formalized models are shown. In addition, a diagnostic test suite and results of its application are described.
A window system with leafing through mode: BookWindow
Authors: Kyoichi Arai, Teruo Yokoyama, Yutaka Matsushita
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems (1992)

This paper describes &ldquo;Book Window&rdquo; that we implemented, a window system based on the &ldquo;book&rdquo; metaphor, that displays information not by scrolling but by using the animation of paging through. The BookWindow system equips some bookmarks, tabs, etc., by which we can access to an expected page through our requirements. BookWindow can support our work environment which navigates us through information space flexibly, because human beings are quite familiar with &ldquo;books&rdquo;.