ppxscal/embedding_network huggingface dataset:
How does Fitts' law fit pointing and dragging?
Authors: Douglas J. Gillan, Kritina Holden, Susan Adam, Marianne Rudisill, Laura Magee
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Empowering people (1990)

Two experiments examined selecting text using a movement sequence of pointing and dragging. Experiment 1 showed that, in the Point-Drag sequence, the pointing time was related to the pointing distance but not to the width of the text to be selected; in contrast, pointing time was related to both the pointing distance and the width of the text in the Point-Click sequence. Experiment 2 demonstrated that both the pointing and dragging times for the Point-Drag sequence were sensitive to the height of the text that was selected. The discussion of the results centers around the application of Fitts' Law to pointing and dragging in a point-drag sequence, proposing that the target for pointing is the leftmost edge of the text to be selected, and the target for dragging is the rightmost edge of the text.
Integrating X.400 message handling into the IBM VM/SP environment
Authors: K. Fischer, W. F. Racke
Venue: ACM SIGCOMM Computer Communication Review (1987)

A prototype X.400 message handling system for IBM's VM/SP operating system is discussed. The system is designed to provide smooth integration of X.400 services into the predominantly used means of interpersonal communication in the VM/SP environment (RSCS). The system provides native X.400 services to its users and therefore is not a gateway between RSCS and X.400 protocols.
Mapping of micro data flow computations on parallel microarchitectures
Authors: L. Shih, C. A. Papachristou
Venue: Proceedings of the 21st annual workshop on Microprogramming and microarchitecture (1988)

This paper presents a method for mapping computation algorithms to parallel machines architectures. The approach is based on a fine grain mapping system, FGMS, whose basic rationale is to achieve better matchings between computations and architectures. FGMS consists of four stages, i.e., data flow graph generation, vertical mapping into fine grain graphs, horizontal mapping across interconnected processors and instruction or microcode generation for individual processors.
Toward a dataflow/von Neumann hybrid architecture
Authors: R. A. Iannucci
Venue: ACM SIGARCH Computer Architecture News (1988)

Dataflow architectures offer the ability to trade program level parallelism in order to overcome machine level latency. Dataflow further offers a uniform synchronization paradigm, representing one end of a spectrum wherein the unit of scheduling is a single instruction. At the opposite extreme are the von Neumann architectures which schedule on a task, or process, basis. This paper examines the spectrum by proposing a new architecture which is a hybrid of dataflow and von Neumann organizations. The analysis attempts to discover those features of the dataflow architecture, lacking in a von Neumann machine, which are essential for tolerating latency and synchronization costs. These features are captured in the concept of a parallel machine language which can be grafted on top of an otherwise traditional von Neumann base. In such an architecture, the units of scheduling, called scheduling quanta, are bound at compile time rather than at instruction set design time. The parallel machine language supports this notion via a large synchronization name space. A prototypical architecture is described, and results of simulation studies are presented. A comparison is made between the MIT Tagged-Token Dataflow machine and the subject machine which presents a model for understanding the cost of synchronization in a parallel environment.
Performance evaluation for multiprocessors programmed using monitors
Authors: B. J. Lucier
Venue: Proceedings of the 1988 ACM SIGMETRICS conference on Measurement and modeling of computer systems (1988)

We present a classification of synchronization delays inherent in multiprocessor systems programmed using the monitor paradigm. This characterization is useful in relating performance of such systems to algorithmic parameters in subproblems such as domain decomposition. We apply this approach to a parallel, adaptive grid code for solving the equations of one-dimensional gas dynamics implemented on shared memory multiprocessors such as the Encore Multimax.
Representing control in the presence of first-class continuations
Authors: R. Hieb, R. Kent Dybvig, Carl Bruggeman
Venue: Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation (1990)

Languages such as Scheme and Smalltalk that provide continuations as first-class data objects present a challenge to efficient implementation. Allocating activation records in a heap has proven unsatisfactory because of increased frame linkage costs, increased garbage collection overhead, and decreased locality of reference. However, simply allocating activation records on a stack and copying them when a continuation is created results in unbounded copying overhead. This paper describes a new approach based on stack allocation that does not require the stack to be copied when a continuation is created and that allows us to place a small upper bound on the amount copied when a continuation is reinstated. This new approach is faster than the naive stack allocation approach, and it does not suffer from the problems associated with unbounded copying. For continuation-intensive programs, our approach is at worst a constant factor slower than the heap allocation approach, and for typical programs, it is significantly faster. An important additional benefit is that recovery from stack overflow is handled gracefully and efficiently.
Implementation of predicate logic in APL2
Authors: U. Engelmann, Th. Gerneth, H. P. Meinzer
Venue: ACM SIGAPL APL Quote Quad (1989)

Our aim is the implementation of a knowledge based image analysis system, which combines the capabilities of APL and Artificial Intelligence. The first step is the implementation of predicate logic in APL, based on the suggestions of Brown. A first prototype is now ready, which can be used for PROLOG-like functions in connection with image processing functions.
Questioning persistent types
Authors: Malcolm Atkinson
Venue: Proceedings of the second international workshop on Database programming languages (1989)

The concept of persistence was introduced 10 years ago. At that time it was believed that it was entirely independent of other aspects of language design. The intention, however, in developing that concept was to incorporate more aspects of computation into a consistent semantic framework. As such progress is made, the independence of other language concepts from persistence is challenged. This is examined with respect to the concept of type. New roles for types emerge. Are they incompatible? Do they so change the use of type that it is no longer the same concept? Or overburden the concept so that it fragments? This may lead us to readdress issues such as, what are types and why do we use them?
Simulating hybrid connectionist architectures
Authors: T. E. Lange, J. B. Hodges, M. E. Fuenmayor, L. V. Belyaev
Venue: Proceedings of the 21st conference on Winter simulation (1989)

The symbolic and subsymbolic paradigms each offer advantages and disadvantages in constructing models for understanding the processes of cognition. A number of research programs at UCLA utilize connectionist modeling strategies, ranging from distributed and localist spreading-activation networks to semantic networks with symbolic marker passing. As a way of combining and optimizing the advantages offered by different paradigms, we have started to explore hybrid networks, i.e. multiple processing mechanisms operating on a single network, or multiple networks operating in parallel under different paradigms. Unfortunately, existing tools do not allow the simulation of these types of hybrid connectionist architectures. To address this problem, we have developed a tool which enables us to create and operate these types of networks in a flexible and general way. We present and describe the architecture and use of DESCARTES, a simulation environment developed to accomplish this type of integration.
An on-line help facility for APL2
Authors: J. Sullivan
Venue: Conference proceedings on APL as a tool of thought (1989)

Online documentation is defined as "Communication designed to be presented on VDT screens on order to ease interactions between computer software and the individuals who manage, audit, operate or maintain it" [BRO1]. "It allows people to instantly go to the screen without stopping what they were doing to go to a manual. It better serves the needs of users" [MOR1].This paper sets out a way of interfacing on-line documentation with APL2 programs. It uses GDDM as the full-screen manager, and the text is stored in a VSAM file, although this is pure convenience and a BDAM file could be used by those sites where personnel are not trained in VSAM, or VSAM is not available.The HELP function is shown in the appendix together with the format of a HELP record from the file; these will show that the concept is beautifully simple. Feedback from staff in my organization has shown that this kind of on-line "HELP" facility has been most useful in assisting everybody from the rookie to the veteran to perform their tasks within the timescales laid down by the management team.
Principles of runtime support for parallel processors
Authors: R. Mirchandaney, J. H. Saltz, R. M. Smith, D. M. Nico, K. Crowley
Venue: Proceedings of the 2nd international conference on Supercomputing (1988)

There exists substantial data level parallelism in scientific problems. The PARTY runtime system is an attempt to obtain efficient parallel implementations for scientific computations, particularly those where the data dependencies are manifest only at runtime. This can preclude compiler based detection of certain types of parallelism. The automated system is structured as follows: An appropriate level of granularity is first selected for the computations. A directed acyclic graph representation of the program is generated on which various aggregation techniques may be employed in order to generate efficient schedules. These schedules are then mapped onto the target machine. We describe some initial results from experiments conducted on the Intel Hypercube and the Encore Multimax that indicate the usefulness of our approach.
Preliminary results with the initial implementation of Qlisp
Authors: Ron Goldman, Richard Gabriel
Venue: Proceedings of the 1988 ACM conference on LISP and functional programming (1988)

Qlisp, a dialect, of Common Lisp, has been proposed as a multiprocessing programming language which is suitable for studying the styles of parallel programming at the medium-grain level. An initial version of Qlisp has been implemented on a multiprocessor and a number of experiments with it conducted. This paper describes the implementation and reports on some of the experiments.
TALISMAN: a prototype expert system for spelling correction
Authors: Hal Berghel, Cecily Andreu
Venue: Proceedings of the 1988 ACM SIGSMALL/PC symposium on ACTES (1988)

This paper reports on the status of TALISMAN, a logic-based spelling assistance package for MS-DOS microcomputers which is currently being refined and tested in our laboratory. The essence of the package is described, and is contrasted with current products. The uniqueness of the approach lies in the fact that formal definitions of spelling errors are directly encoded into the program. Some recent benchmark results indicate that TALISMAN may actually out-perform competitive products as well as exceed their accuracy and overall effectiveness.
A parallel VLSI architecture for unformatted data processing
Authors: K. C. Lee, O. Frieder, V. Mak
Venue: Proceedings of the first international symposium on Databases in parallel and distributed systems (2000)

A novel, high performance subsystem for information retrieval called JAS is introduced. The JAS subsystem sustains gigabyte per second comparison rates due to its &ldquo;early-out&rdquo; CMOS substring search processor. The complexity of each JAS unit is independent of the complexity of the query. This query complexity independence is achieved via the utilization of a decoupled instruction set. The JAS subsystem architecture is described and the performance is evaluated.
Responding to :20HUH?&rdquo;: answering vaguely articulated follow-up questions
Authors: J. D. Moore
Venue: ACM SIGCHI Bulletin (1989)

Expert and advice-giving systems produce complex multi-sentential responses to user's queries. Results from analyses of novice/expert dialogues indicate that novices often do not understand an expert's response and rarely ask a well-formulated follow-up question. Thus systems must be able to provide further information in response to vaguely articulated questions. However, current systems cannot clarify misunderstood explanations or elaborate on previous explanations. In this paper we describe an approach to explanation generation that expands a system's explanatory capabilities and enables the production of clarifying or elaborating explanations in response to follow-up questions or indication that the explanation was not understood.
Control-Flow Checking Using Watchdog Assists and Extended-Precision Checksums
Authors: N. R. Saxena, W. K. McCluskey
Venue: IEEE Transactions on Computers (1990)

A control-flow checking method using extended-precision checksums and watchdog assists is proposed. Control-flow checking based on extended-precision checksums is shown to have low error detection latency compared to previously proposed methods. Analytical measures are derived to demonstrate the effectiveness of using extended-precision checksums for control flow checking. It is shown that the error detection latency in the extended-precision-checksum-based control-flow checking remains relatively constant for both single and multiple sequence errors. In the case of signature-based methods, error detection latency increases linearly with the number of sequence errors. A watchdog assist architecture for control-flow checking in programs which addresses several architecture issues is proposed. This watchdog assist architecture can support control-flow checking for multiprocessor, multiprogramming, and cache-based environments. The Hewlett-Packard Precision Architecture is used as an example architecture to demonstrate the feasibility of watchdog assists.
Performance modelling of the Orwell basic access mechanism
Authors: M. Zafirovic, I. G. Niemegeers
Venue: Proceedings of the ACM workshop on Frontiers in computer communications technology (1987)

Orwell is a high speed slotted ring. Its protocol uses destination release of the slots. Because of this the carried load can be much larger than the transmission rate. A new analytical model of the Orwell basic access mechanism is presented in this paper. The model shows to be accurate and usable over a wide range of parameters. The performance analysis of the Orwell basic access mechanism is presented.
Operations on sets of intervals - an exercise for data structures or algorithms
Authors: B. P. Weems
Venue: ACM SIGCSE Bulletin (1989)

Ordered linked lists are introduced in data structures courses and are frequently encountered in the study of algorithms. Set operations (e.g. union, intersection) on sets of real intervals provide a non-trivial exercise in developing correct algorithms for manipulating lists.
Minimum K-partitioning of rectilinear polygons
Authors: Oliver Gunther
Venue: Journal of Symbolic Computation (1990)

A minimum k-partition decomposes a rectilinear polygon with n vertices into aminimum number of disjoint rectilinear components with no more than k vertices each (k=8; most results are also new for k=6.
Designing for a dollar a day
Authors: Morten Kyng
Venue: Proceedings of the 1988 ACM conference on Computer-supported cooperative work (1988)

This paper is about the kind of tools and techniques that are accessible to resource weak groups for use in design and evaluation of computer support. &ldquo;Resource weak&rdquo; means in this connection, that the economic power and the ability to control the &ldquo;local environment&rdquo; of the group is limited. The human resources of such groups are often (potentially) strong, but restrained by the organization of work and society; and although the tools are cheap the activities are demanding in terms of human resources. This kind of work should be seen as a supplement to participation in design processes controlled by others. When end users participate in projects set up by management, these &ldquo;lay&rdquo; designers often lack familiarity with the tools and techniques, they lack the power and resources to influence the choice of questions to be considered, and they are not the ones deciding how to utilize the results of a design project when actually changing the workplace. To give the context of the work on which the paper is based, I first describe the Scandinavian tradition of trade union based end user participation in systems development. Then I discuss some of the issues involved in improving the conditions for independent end user design activities. I go on by presenting a set of &ldquo;cheap tools&rdquo; and techniques, including the use mockup's. This set covers the issues of establishing the possibility of alternatives, of creating visions of new and different uses of technology, and of designing computer support. A central question in relation to the tools and techniques, is their accessibility to end users, and I discuss this based on the notions of family resemblance and &ldquo;hands-on&rdquo; experience.
A denotational semantics for Prolog
Authors: Tim Nicholson, Norman Foo
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1989)

A denotational semantics is presented for the language Pro.og. Metapredicates are not considered. Conventional control sequencing is assumed for Prolog's execution. The semantics is nonstandard, and goal continuations are used to explicate the sequencing.
Assessing the quality of abstract data types written in ADA
Authors: D. W. Embley, S. N. Woodfield
Venue: Proceedings of the 10th international conference on Software engineering (1988)

As software systems have become more complex, a search for better abstraction mechanisms has led to the use of abstract data types (ADTs). To more appropriately use ADTs, however, it is imperative that their properties and characteristics be understood. In this paper we present a method of assessing the quality of ADTs in terms of cohesion and coupling. We argue that an ADT that contains and exports only one domain and exports only operations that pertain to that domain has the best cohesive properties, and we argue that ADTs that make neither explicit nor implicit assumptions about other ADTs in the system have the best coupling properties. Formal definitions are presented for each of the cohesion and coupling characteristics discussed. Their application to Ada&reg; packages is also investigated, and we show how a tool can be developed to assess the quality of an Ada package that represents an ADT. We analyzed nearly one hundred Ada ADT packages found in Ada text books, articles about Ada, and student projects and discovered that more than half of them had inferior cohesive characteristics and almost half of them allowed inferior coupling characteristics.
Inheritance and synchronization with enabled-sets
Authors: C. Tomlinson, V. Singh
Venue: Conference proceedings on Object-oriented programming systems, languages and applications (1989)

We discuss several issues related to the integration of inheritance and concurrency in an object-oriented language to support fine-grain parallel algorithms. We present a reflective extension of the actor model to implement inheritance mechanisms within the actor model. We demonstrate that a particularly expressive and inheritable synchronization mechanism must support local reasoning, be composable, be first-class, and allow parameterization based on message content. We present such a mechanism based on the concept of enabled-sets, and illustrate each property. We have implemented enabled-sets in the Rosette prototyping testbed.
Reasoning about object-oriented programs that use subtypes
Authors: Gary T. Leavens, William E. Weihl
Venue: ACM SIGPLAN Notices (1990)

Programmers informally reason about object-oriented programs by using subtype relationships to classify the behavior of objects of different types and by letting supertypes stand for all their subtypes. We describe formal specification and verification techniques for such programs that mimic these informal ideas. Our techniques are modular and extend standard techniques for reasoning about programs that use abstract data types. Semantic restrictions on subtype relationships guarantee the soundness of these techniques.
Optimum probability estimation based on expectations
Authors: N. Fuhr, H. Huther
Venue: Proceedings of the 11th annual international ACM SIGIR conference on Research and development in information retrieval (1988)

Probability estimation is important for the application of probabilistic models as well as for any evaluation in IR. We discuss the interdependencies between parameter estimation and other properties of probabilistic models. Then we define an optimum estimate which can be applied to various typical estimation problems in IR. A method for the computation of this estimate is described which uses expectations from empirical distributions. Some experiments show the applicability of our method, whereas comparable approaches are partially based on false assumptions or yield estimates with systematic errors.
Optimal Distributed t-Resilient Election in Complete Networks
Authors: Alon Itai, Shay Kutten, Yaron Wolfstahl, Shmuel Zaks
Venue: IEEE Transactions on Software Engineering (1990)

The problem of distributed leader election in an asynchronous complete network, in the presence of faults that occurred prior to the execution of the election algorithm, is discussed. Failures of this type are encountered, for example, during a recovery from a crash in the network. For a network with n processors, k of which start the algorithm that uses at most O(n log k+n+kt) messages is presented and shown to be optimal. An optimal algorithm for the case where the identities of the neighbors are known is also presented. It is noted that the order of the message complexity of a t-resilient algorithm is not always higher than that of a nonresilient one. The t-resilient algorithm is a systematic modification of an existing algorithm for a fault-free network.
I-APL: A portable ISO APL in under 25K
Authors: P. Chapman
Venue: ACM SIGAPL APL Quote Quad (1987)

As part of the I-APL project born at APL86 in Manchester. I was given the job of implementing a new APL interpreter which was portable, small enough to run on micro-computers in use in schools throughout the world, and fully compatible with the final draft of the ISO APL standard [ISO86]. The paper describes the implementation strategy, the use of the ISO standard as a working document, and some of the additional facilities provided.
A spreadsheet interface for logic programming
Authors: M. Spenke, C. Beilken
Venue: ACM SIGCHI Bulletin (1989)

We present PERPLEX, a programming environment intended for the end-user. In its design, the concepts of logic programming and spreadsheets are combined. Thus, on the one hand, logic programming becomes an interactive, incremental task where the user gets direct visual feedback, on the other hand, functionality and scope of a conventional spreadsheet program are considerably extended. In order to perform calculations and queries, constraints are imposed on the contents of the spreadsheet cells. New predicates can be defined using a programming-by-example technique: Rules are extracted from the user's solutions for example problems. Thus, concrete intermediate results take over the role of abstract logic variables in the programming process. PERPLEX has been successfully implemented on a Symbolics Lisp Machine.