ppxscal/embedding_network huggingface dataset:
Virtual video editing in interactive multimedia applications
Authors: Wendy E. Mackay, Glorianna Davenport
Venue: Communications of the ACM (1989)

Drawing examples from four interrelated sets of multimedia tools and applications under development at MIT, the authors examine the role of digitized video in the areas of entertainment, learning, research, and communication.
Programming as process: a &ldquo;novel&rdquo; approach to teaching programming
Authors: Rex E. Gantenbein
Venue: ACM SIGCSE Bulletin (1989)

This paper introduces the process model as a way of incorporating the software life cycle into beginning computer science courses. This approach, patterned after a successful method for teaching English composition, provides students with an understanding of how all phases of programming can be accomplished. A five-step model of the process and some useful tools for each step are presented as an example and discussed.
The elucidation of non-monoTONous reasoning and related notions in artificial intelligence
Authors: S. M. Humphrey
Venue: Issue 108 (April 1989) (1989)

It is recognized that an intelligent agent must be capable of reasoning about the world it inhabits, must possess various forms of knowledge and beliefs about its world, and must use these to infer information about its world in order to plan, act, make decisions, respond to other agents, and so forth. The technical problem for AI is to characterize the patterns of reasoning required by intelligent agents, and to computerize them in some way.
Techniques for the trace-driven simulation of cache performance
Authors: S. J. Eggers, E. D. Lazowska, Y. B. Lin
Venue: Proceedings of the 21st conference on Winter simulation (1989)

In contemporary computers, cache memories are interposed between processors and primary memories in order to decrease access time and bus traffic. Because the design of the cache is critical and the factors affecting its performance are complex, trace-driven simulation is widely used and studied. This paper surveys three interesting techniques for the trace-driven simulation of cache designs: stack analysis methodologies that make it possible to obtain performance measures for a wide variety of cache designs from a single run of the simulator, compression algorithms specifically tailored to memory reference traces, and an approach to parallel trace-driven simulation of multiprocessor caches that dramatically reduces the simulation's synchronization and thus its running time.
An Experimental Study of Memory Fault Latency
Authors: R. Chillarege, R. K. Iyer
Venue: IEEE Transactions on Computers (1989)

The difficulty with the measurement of fault latency is due to the lack of observability of the fault occurrence and error generation instants in a production environment. The authors describe an experiment, using data from a VAX 11/780 under real workload, to study fault latency in the memory subsystem accurately. Fault latency distributions are generated for stuck-at-zero (s-a-0) and stuck-at-one (s-a-1) permanent fault models. The results show that the mean fault latency of an s-a-0 fault is nearly five times that of the s-a-1 fault. An analysis of variance is performed to quantify the relative influence of different workload measures on the evaluated latency.
Toward a typed foundation for method specialization and inheritance
Authors: John C. Mitchell
Venue: Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1989)

This paper discusses the phenomenon of method specialization in object-oriented programming languages. A typed function calculus of objects and classes is presented, featuring method specialization when methods are added or redefined. The soundness of the typing rules (without subtyping) is suggested by a translation into a more traditional calculus with recursively-defined record types. However, semantic questions regarding the subtype relation on classes remain open.
Information delivery systems in the 1990's: the Local INtegrated Knowledge NETwork (LINKNET)
Authors: Detmar W. Straub, Cynthia Mathis Beath
Venue: ACM SIGMIS Database (1990)

In the late 80's, managers, professionals, analysts, and researchers are finding it increasingly difficult to manage the vast array of data and text that are available to them. The fragmentation in media and sources of information, and discontinuities between the information bureaucracies, particularly Information Systems and the library, hinder ready access to information. In the future, this paper argues, a department-level Local INtegrated Knowledge NETwork (LINKNET), will help individuals locate and integrate needed information. The LINKNET environment as conceived here consists of data and human resources at departmental locations that constitute a technological and organizational infrastructure for information delivery. In particular it makes available those information technologies specializing in information integration--integrative software, sharable resources like computerized storage devices, and information collections--and essential human resources like information resource management, consulting, and training.
A method for specializing logic programs
Authors: A. Bossi, N. Cocco, S. Dulli
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1990)

A specialization method for logic programs that allows one to restrict a general program to special cases by means of constraint predicates is presented. A set of basic transformation operations, which are shown to produce equivalent programs, is defined. The method uses these operations for propagating the constraint information through the program and for consequently simplifying it whenever possible. Some examples of specializations are given, and some improvements and developments of the method are discussed.
Our &ldquo;miracle": self-supporting student microcomputer labs
Authors: Karen Stallworth, Jim Strasma
Venue: Proceedings of the 16th annual ACM SIGUCCS Conference on User Services (1988)

During the 1987-88 school year, Western Illinois University began a successful experiment to create a self-supporting microcomputer lab. From conversations we've had at recent ACM conferences, we feel this experience is rare enough that reading about it will help other schools. Naturally, we credit our success to the dedication and excellence of the people involved, but beyond that, the success of the lab was also due to several key management decisions: Obtaining support from top administrators before starting Planning and operating in cooperation with several departments Keeping lab funds in a separate account, used only by the lab. Knowing and carefully following the rules of the university Isolating and meeting student needs: Providing ready help to lab users Staying open throughout student study hours Thinking of ourselves as sales clerks, not bureaucrats Starting small and seeking maximum benefits from each dollar Using inexpensive computers and sharing printers Using donated older versions of popular software The results of these decisions speak for themselves: The lab is self-supporting Its financial records are in good order
A concurrent debugger for iPSC/2 programmers
Authors: W. M. Pan, V. Jackson
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

Applications running on the iPSC&reg;/2, a distributed-memory, message-passing concurrent supercomputer, are composed of multiple processes executing concurrently on different nodes of the system. Debugging such applications with traditional one-process debuggers, such as dbx, is simply inadequate. This paper describes a source level debugger, DECON, specifically designed to aid iPSC/2 programmers debug large concurrent applications written in C or FORTRAN. The major challenges of debugging such applications are discussed and the capabilities of DECON which address each challenge are described. To illustrate Deacon's ease of use and flexibility a simple iPSC/2 application is debugged.
A cluster-based cylindrical algebraic decomposition algorithm
Authors: Dennis S. Arnon
Venue: Journal of Symbolic Computation (1988)

Let A @? Z [x"1,000, x"r be a finite set. An A-invariant cylindrical algebraic decomposition (cad) is a certain partitlon of r-dlmensional euclidean space E^r into semi-algebralc cells such that the value of each A"i @? A has constant sign (positive, negative, or zero) throug|umt each cell. Two cells are adjacent if their union is connected. Recently a number of mathoda have been given for augmenting Colllns' cad construction algorithm (1975), so that in addition to specifying the cell~ that comprise a cad, it identifies the pairs of adjacent cells. Assuming the availability of such an adjacency algorithm, in this paper we give a modified cad construction algorithm based on the utillzatloa of clusters of cells in a cad (a cluster is a collection of cells whose union is connected). Preliminary observations indicate that the 11ew algorithm can be significantly more efficient in some cases than the original, although in other examples it is somewhat less efficient.
Reconfigurable transputer systems
Authors: C. Jesshope
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

This paper introduces the T800 transputer from INMOS, for use as a component in reconfigurable multiple-processor systems. The architecture of such systems will be considered together with the limitations; being static and of fixed valence. Solutions to these limitations can be found in virtualising the networks, but this introduces inefficiencies and the potential for deadlock. The latter can be eliminated by careful design, but the former requires further chip development. Finally the paper will consider programming methodologies and systems for this and other multiple-processor architectures.
Uncertainty management in intelligent design aiding systems
Authors: Donald E. Brown, Paula Gabbert
Venue: Proceedings of the 1st international conference on Industrial and engineering applications of artificial intelligence and expert systems - Volume 1 (1988)

Uncertainty management is critical to the performance of knowledge-based systems in domains where inference through formal logic is inappropriate. A diverse set of techniques are available for reasoning in these domains. There are disadvantages associated with all of these methods that preclude their universal acceptance. This paper describes a new approach to the management of uncertainty, which is based on information theory. This approach is particularly effective in intelligent design aids for large scale systems design. An example of the use of our approach to uncertainty management in the materials handling system design domain is provided.
On determining lifetime and aliasing of dynamically allocated data in higher-order functional specifications
Authors: Alan Deutsch
Venue: Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1989)

We present a static analysis method for determining aliasing and lifetime of dynamically allocated data in lexically scoped, higher-order, strict and polymorphic languages with first class continuations. The goal is validate program transformations that introduce imperative constructs such as destructive updatings, stack allocations and explicit deallocations in order to reduce the run-time memory management overhead. Our method is based on an operational model of higher order functional programs from which we construct statically computable abstractions using the abstract interpretation framework. Our method provides a solution to a problem left open [Hudak 86]: determining isolation of data in the case of higher order languages with structured data.
Scheduling Processes with Release Times, Deadlines, Precedence and Exclusion Relations
Authors: Jia Xu, David Parnas
Venue: IEEE Transactions on Software Engineering (1990)

An algorithm that finds an optimal schedule on a single processor for a given set of processes is presented. Each process starts executing after its release time and completes its computation before its deadline and a given set of precedence relations and exclusion relations defined on ordered pairs of process segments are satisfied. This algorithm can be applied to the important and previously unsolved problem of automated pre-run-time scheduling of processes with arbitrary precedence and exclusion in hard-real-time systems.
The 1988 CSCW: trip report
Authors: S. Greenberg
Venue: ACM SIGCHI Bulletin (1989)

Computer-supported cooperative work (CSCW) is a new research field focused on the role of the computer in group work. On one hand it is technology-driven, motivated by such things as distributed computing, network file systems, electronic messaging, and high-bandwidth communication channels. On the other hand, it is socially-driven, motivated by studies of group interaction.
Including a user interface management system (UIMS) in the performance relationship model
Authors: J. E Trumbly, K. P. Arnett
Venue: ACM SIGCHI Bulletin (1989)

Improvement of the human computer interface (HCI) is receiving increasing attention as a panacea for many information systems problems; particularly end-user performance. Several experimental research efforts have made significant contributions toward increasing user performance, and vendor implementation of early research findings into commerical applications software have apparently enhanced user satisfaction. This manuscript proposes a model designed to serve as a framework for HCI research efforts, thereby providing a unified structure for the collection and examination of variables utilized in such efforts. The empirical research supporting this model is also highlighted. The performance relationship model is capable of including the concept of a user interface management system (UIMS) very easily.
Toward a common prototyping language
Authors: Jack G. Rudd, James A. Brown
Venue: ACM SIGAPL APL Quote Quad (1990)

Several years ago the U.S. Department of Defense created its Defense Science Board Task Force on Military Software, chaired by Dr. Frederick Brooks, to provide recommendations on how best to solve the problem of escalating military software acquisition costs. The final report (reference 2) of this task force was completed in September 1987, and was widely distributed. Among its several major conclusions are the following: DoD Directive 5000.29 and STD 2167 codify the best 1975 thinking about software, including a so-called 'waterfall' model calling for formal specification, then request for bids, then contracting, delivery, installation, and maintenance. In the decade since the waterfall model was developed, our discipline has come to recognize that setting the requirements is the most difficult and crucial part of the software building process, and one that requires iteration between the designers and users. In best modern practice, the early specification is embodied in a prototype, which the intended users can themselves drive in order to see the consequences of their imaginings. Then, as the design effort begins to yield data on the cost and schedule consequences of particular specifications, the designers and the users revise the specifications. Directive 5000.29 not only does not encourage this best modern practice, it essentially forbids it. We recommend that it be revised immediately to mandate and facilitate early prototyping before the baseline specifications are established. DoD STD-2167 likewise needs a radical overhaul to reflect best modern practice. Draft DoD STD 2167A is a step, but it does not go nearly far enough. As drafted, it continues to reinforce exactly the document-driven, specify-then-build approach that lies at the heart of so many DoD software problems.
ABYSS: An Architecture for Software Protection
Authors: Steve R. White, Liam Comerford
Venue: IEEE Transactions on Software Engineering (1990)

ABYSS (a basic Yorktown security system) is an architecture for protecting the execution of application software. It supports a uniform security service across the range of computing systems. The use of ABYSS in solving the software protection problem, especially in the lower end of the market, is discussed. Both current and planned software distribution channels are supportable by the architecture, and the system is nearly transparent to legitimate users. A novel use-once authorization mechanism, called a token, is introduced as a solution to the problem of providing authorizations without direct communication. Software vendors may use the system to obtain technical enforcement of virtually any terms and conditions of the sale of their software, including such things as rental software. Software may be transferred between systems, and backed up to guard against loss in case of failure. The problem of protecting software on these systems is discussed, and guidelines to its solution are offered.
Probabilistic document indexing from relevance feedback data
Authors: N. Fuhr, C. Buckley
Venue: Proceedings of the 13th annual international ACM SIGIR conference on Research and development in information retrieval (1989)

Based on the binary independence indexing model, we apply three new concepts for probabilistic document indexing from relevance feedback data: Abstraction from specific terms and documents, which overcomes the restriction of limited relevance information for parameter estimation. Flexibility of the representation, which allows the integration of new text analysis and knowledge-based methods in our approach as well as the consideration of more complex document structures or different types of terms (e.g. single words and noun phrases). Probabilistic learning or classification methods for the estimation of the indexing weights making better use of the available relevance information. We give experimental results for five test collections which show improvements over other indexing methods.
Computing the Hough Transform on a Scan Line Array Processor (Image Processing)
Authors: A. L. Fisher, P. T. Highnam
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

A parallel algorithm for a line-finding Hough transform that runs on a linearly connected, SIMD (single-instruction, multiple-data-stream) vector of processors is described. The authors show that a high-precision transform, usually considered to be an expensive global operation, can be performed efficiently, in two to three times real time, with only local, communication on a long vector. The algorithm also illustrates a decomposition principle that has wide application in algorithm design for large linear arrays. A review of straight-line Hough transform implementations is also presented.
Petri Net Tools for the Specification and Analysis of Discrete Controllers
Authors: Reg G. Willson, Bruce H. Krogh
Venue: IEEE Transactions on Software Engineering (1990)

An approach is presented for the specification, modeling, and analysis of discrete-state systems and controllers. The approach features a rule-based state-variable-specification formalism that is translated into Petri net models composed of interconnected statemachines. The concept of reduced reachability graphs is introduced as a means of reducing the computational effort required to isolate and analyze subcomponent behavior within the system. The target application is discrete manufacturing systems where the costs involved in writing, debugging, and maintaining of code for online process control can be significantly reduced through the use of automated modeling and analysis techniques. The approach is illustrated by an example of a simple discrete-state system.
Naming Ada tasks at run-time
Authors: J. Cheng, K. Ushijma
Venue: ACM SIGAda Ada Letters (1989)

This paper proposes a new strategy for uniquely naming Ada tasks at run-time. The strategy has two features. First, it can easily be used to name tasks in their activations. Second, it does not impose a total order with respect to the start of activations and/or executions on the tasks to be named.
A note on the Power Operators &ldquo;loops are harmful&rdquo;
Authors: J. L. F. De Kerf
Venue: ACM SIGPLAN Notices (1989)

Power Operators have been proposed in several papers but have only been implemented in STSC's experimental "NARS". An overview is given of these proposals and implementations. Two forms of a restricted simulation by a defined operator are discussed, the first form incorporating an explicit loop, and the second form applying the execute function ( spades;). Efficiency in cpu time are compared and it is concluded -- once more -- that "Loops are Harmful".
Local atomicity properties: modular concurrency control for abstract data types
Authors: W. E. Weihl
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1989)

Atomic actions (or transactions) are useful for coping with concurrency and failures. One way of ensuring atomicity of actions is to implement applications in terms of atomic data types: abstract data types whose objects ensure serializability and recoverability of actions using them. Many atomic types can be implemented to provide high levels of concurrency by taking advantage of algebraic properties of the type's operations, for example, that certain operations commute. In this paper we analyze the level of concurrency permitted by an atomic type. We introduce several local constraints on individual objects that suffice to ensure global atomicity of actions; we call these constraints local atomicity properties. We present three local atomicity properties, each of which is optimal: no strictly weaker local constraint on objects suffices to ensure global atomicity for actions. Thus, the local atomicity properties define precise limits on the amount of concurrency that can be permitted by an atomic type.
Using computer simulation to optimize flexible manufacturing systems design
Authors: U. Nandkelyar, D. P. Christy
Venue: Proceedings of the 21st conference on Winter simulation (1989)

An FMS is a highly integrated manufacturing system. The inter-relationships between its components are not well understood. Consequently, it has not been possible to develop closed form analytic models of FMSs. Computer simulation has been extensively applied to study their performance. The optimal design of FMSs is an important problem. In this research a computer simulation model of an FMS is interfaced with the Hooke-Jeeves algorithm to search an optimum design without full factorial experimentation. Some modifications of the HJ algorithm are needed to accommodate the stochastic nature of computer simulation.
On local implicit approximation and its applications
Authors: J. H. Chuang, C. M. Hoffmann
Venue: ACM Transactions on Graphics (TOG) (1989)

A method is proposed for computing an implicit approximant at a point to a parametric curve or surface. The method works for both polynomially and rationally parameterized curves and surfaces and achieves an order of contact that can be prescribed. In the case of nonsingular curve points, the approximant must be irreducible, but in the surface case additional safeguards are incorporated into the algorithm to ensure irreducibility. The method also yields meaningful results at most singularities. In principle, the method is capable of exact implicitization and has a theoretical relationship with certain resultant-based elimination methods.