ppxscal/embedding_network huggingface dataset:
Cooperative work in the Andrew message system
Authors: Nathaniel S. Borenstein, Chris A. Thyberg
Venue: Proceedings of the 1988 ACM conference on Computer-supported cooperative work (1988)

The Andrew Message System, a distributed system for multi-media electronic communication, has a number of special features that support cooperative work. After a brief discussion of the system itself, these features are described and discussed in more detail. Examples of how organizations actually use these features are then presented and discussed, with particular attention paid to the &ldquo;Advisor&rdquo; system for electronic consulting.
Using modula-2 to teach data abstraction
Authors: J. Mohr
Venue: ACM SIGCSE Bulletin (1989)

The principle of abstraction has assumed a central role in modern software engineering. Most modern textbooks on data structures and algorithms propound the advantages of abstraction as a programming tool. Aho, Hopcroft, and Ullman cite generalization and encapsulation as the two primary advantages of both data and procedural abstraction.Allen Tucker echoes these advantages, defining abstraction as "a conscious process of generalizing a type, procedure, or data structure in such a way that it can serve more purposes than the one for which it was originally designed," and encouraging the packaging of procedures in libraries "to promote their wide utility through generalization."Michael Feldman focuses on the use of abstraction to reduce complexity through information hiding. Encapsulating the details of a representation allows us to "concentrate on the mathematical properties of these entities, their visible structure, and the set of operations that can be performed on them."Robert Kruse shows how distinguishing between a general concept and a particular implementation can clarify code, which often allows us to recognize similiarities between situations which were presumed to be different. He also clearly outlines the various levels at which we solve problems: the abstract (conceptual), data structures (algorithmic), implementation and application (programming) levels.Unfortunately, many students have trouble grasping the concept of abstraction. They see Kruse's hierarchical approach to problem solving as a complication rather than a tool, and have difficulty distinguishing one level from another. (Perhaps this problem is unique to the students I have encountered . . . but I doubt it.)Part of the problem in teaching abstraction is that Pascal, C, and most of the other languages which are widely used in data structures courses do not enforce the use of abstraction. Writing a high-level procedure which uses a lower-level one to do its work seems to be merely a stylistic issue ("The prof wants us to write it this way.") The power of hierarchical structure for controlling complexity is easily overlooked when it just seems to make one's program longer.Modula-2 is one of the more recent languages which support data abstraction by separating the definition of an abstract data type (ADT) from its implementation in separately compiled modules. We have used Modula-2 in our data structures and algorithms class for the past two years, and are converting our introductory programming courses (CS1 and CS2) to Modula-2 beginning this fall. We are convinced that the use of Modula-2 helps students understand data abstraction by experiencing it in a concrete way. In essence, the hierarchical view of a problem is not merely encouraged, but can be enforced by the modular nature of the language.
Caution on criteria: on the context dependency of selection criteria for expert systems projects
Authors: Helmut Krcmar
Venue: ACM SIGMIS Database (1988)

The growing interest in the use of expert systems (ES) necessitates procedures to determine when the use of ES-techniques is appropriate. This paper describes some recently suggested proposed criteria and reviews them in light of the use of ES in business. Here medium-size, embedded ES and not large, single purpose stand-alone ES dominate. Presently proposed criteria do not focus entirely on what is characteristic of ES in business. The paper then develops a classification for the situations in which ES-techniques can be used. Based upon this classification it recommends a situation based methodology to generate appropriate goals for the use of ES-techniques and suggests adapted criteria for evaluation.
The transcendental Risch differential equation
Authors: Manuel Bronstein
Venue: Journal of Symbolic Computation (1990)

We present a new rational algorithm for solving Risch differential equations in towers oftranscendental elementary extensions. In contrast to a recent algorithm of Davenport we do not require a progressive reduction of the denominators involved, but use weak normality to obtain a formula for the denominator of a possible solution. Implementation timings show this approach to be faster than a Hermite-like reduction.
Dynamic typing in a statically-typed language
Authors: M. Abadi, L. Cardelli, B. Pierce, G. Plotkin
Venue: Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1989)

Statically-typed programming languages allow earlier error checking, better enforcement of disciplined programming styles, and generation of more efficient object code than languages where all type-consistency checks are performed at runtime. However, even in statically-type languages, there is often the need to deal with data whose type cannot be known at compile time. To handle such situations safely, we propose to add a type Dynamic whose values are pairs of a value v and a type tag T where v has the type denoted by T. Instances of Dynamic are built with an explicit tagging construct and inspected with a type-safe typecase construct. This paper is an exploration of the syntax, operational semantics, and denotational semantics of a simple language with the type Dynamic. We give examples of how dynamically-typed values might be used in programming. Then we discuss an operational semantics for our language and obtain a soundness theorem. We present two formulations of the denotational semantics of this language and relate them to the operational semantics. Finally, we consider the implications of polymorphism and some implementation issues.
Compiling separable recursions
Authors: Jeffrey F. Naughton
Venue: Proceedings of the 1988 ACM SIGMOD international conference on Management of data (1988)

In this paper we consider evaluating queries on relations defined by a combination of recursive rules. We first define separable recursions. We then give a specialized algorithm for evaluating selections on separable recursions. Like the Generalized Magic Sets and Generalized Counting algorithms, thus algorithm uses selection constants to avoid examining irrelevant portions of the database, however, on some simple recursions this algorithm is &Ogr;(n), whereas Generalized Magic Sets is &OHgr;(n2) and Generalized Counting is &OHgr;(2n)
Distributed Computing with Single Read-Single Write Variables
Authors: Patrick M. Lenders
Venue: IEEE Transactions on Software Engineering (1989)

Single-read-single-write (SRSW) variables are presented for synchronous and asynchronous communication between processes. The operational semantics of the instruction accessing these variables is quite simple: a SRSW variable can be written if it is free, and, once written, it becomes busy. A SRSW variable can be read when busy, and, once read, it becomes free. A process attempting to read a free SRSW variable or write a busy SRSW variable is put in a wait state until the state of the variable changes. The advantages of SRSW variables are multiple. The syntax of a regular sequential language can be used without any change, other than the introduction of a new SRSW data type. Parallel programs tend to be concise and easy to prove correct. The message passing paradigm can be very easily modeled with SRSW variables.
An Expert-System Shell Using Structured Knowledge: An Object-Oriented Approach
Authors: K. S. Leung
Venue: Computer (1990)

An architecture for an expert-system shell that mixes declarative nd procedural knowledge, overcoming a major problem of conventional shells, is presented. The prototype shell uses structured knowledge representations and its built-in database interface not only allows automatic extraction of data from a database management system but also provides a fuzzy database query facility. The shell's object-oriented approach to knowledge representation supports data and knowledge acquisition and management. Another feature is encapsulation which prevents object manipulation except by defined operations. A comparison of representation methods and two case studies showing System X-I's power and flexibility are included.
Two- -Two, a high level system for retrieving pairs of documents
Authors: Stephen J. Wiesner
Venue: ACM SIGOIS Bulletin (1988)

This paper describes the design and operation of Two- amp;-Two, a program for finding pairs of documents which form a bridge between two inputs. Two- amp;-Two is built on top of Finder, a retrieval system based on relevance feedback that operates on the massively parallel Connection Machine System.
On computing the canonical form for a binary form of odd degree
Authors: Arne Dür
Venue: Journal of Symbolic Computation (1989)

A new method is proposed to compute the canonical form for binary forms of odd degree, with coefficients in a field of characteristic 0. The method is based on an extension of Berlekamp's algorithm for the decoding of Reed-Solomon codes.
Selecting a CASE tool
Authors: L. Zucconi
Venue: ACM SIGSOFT Software Engineering Notes (1989)

Selecting a Computer-Aided Software Engineering (CASE) tool can be a bewildering task, considering the number and variety of systems on the market. This paper presents a rigorous step-by-step selection process for choosing CASE tools. This algorithm requires that a set of CASE requirements be developed to meet the needs of the software development organization. Other selection steps include contacting vendors for information, conducting a preliminary screening of vendors to obtain a list of semi-finalists, and requesting a written response to the CASE requirements from the vendors and a loan of the tools for evaluation. The last steps inlcude site visits or non-disclosure meetings with the finalist vendors, and then the final selection.
A pictorial aid for programming expert systems
Authors: Edward N. Schwartz
Venue: Issue 106 (October 1988) (1988)

The knowledge engineering and software development tasks involved in constructing software for an expert system are very different from the task of designing an imperative program. Some of the problems in the construction of a rule-based expert system include deducing the heuristics of the expert, converting these heuristics into a working taxonomy and rule base, and ordering the rule base so that the system performs efficiently and correctly. A pictorial method of knowledge representation that we call a "k-tree" greatly facilitates these tasks.
Distributed training: the MSU computer laboratory departmental trainer program's second year
Authors: Bill Brown, Marilyn Everingham
Venue: Proceedings of the 16th annual ACM SIGUCCS Conference on User Services (1988)

With the advent of microcomputers, distributed computing is here to stay. With distributed computing comes distributed expertise; people must learn to run their own computing centers, no matter what the size of the computers. In trying to deal with increased demands for training in a limited-resource environment, we have taken the natural step of distributing the responsibility for the training. With appropriate training materials, a person who knows how to use a program can lead someone else through the process of learning. The training materials must be sufficiently detailed to include training on all major features of the software that people regularly use and include conceptual material that takes the place of lectures. The commitment to distributed training must be real. Sufficient staff must be devoted to developing training materials because the materials must continue to evolve with the software it teaches and new materials must be created to meet the demands for training on new software.
Assessing the benefits of fine-grain parallelism in dataflow programs
Authors: D. E. Culler, G. K. Maa
Venue: Proceedings of the 1988 ACM/IEEE conference on Supercomputing (1988)

A method for assessing the benefits of fine-grain parallelism in &ldquo;real&rdquo; programs is presented. The method is based on parallelism profiles and speedup curves derived by executing dataflow graphs on an interpreter under progressively more realistic assumptions about processor resources and communication costs. It is shown that programs, even using traditional algorithms, exhibit ample parallelism when parallelism is exposed at all levels, i.e., within expressions, across nested loops and function calls, and in producer-consumer relationships on individual elements of data structures. Since only dataflow graphs compiled from the high level language Id are considered, the bias introduced by the language and the compiler is examined. A method of estimating speedup through analysis of the ideal parallelism profile is developed, avoiding repeated execution of programs. It is shown that fine-grain parallelism can be used to mask large, unpredictable memory latency and synchronization waits in architectures employing dataflow instruction execution mechanisms. Finally, the effects of grouping portions of dataflow programs, such as function invocations or loop iterations, and requiring that the operators in a group execute on a single processor, are explored.
Executing real-time structured analysis specifications
Authors: R. Blumofe, A. Hecht
Venue: ACM SIGSOFT Software Engineering Notes (1988)

This paper describes a prototype system, Teamwork/ES trade;, that executes a real-time structured analysis specification in an interactive, intuitive, and graphical manner. The approach has been to integrate the work as an extension of an accepted real-time analysis environment. This integrated, graphical system is different from previous textual or tool-kit systems, and offers a natural way of simulating system specifications. The system can also perform dynamic reachability tests and deadlock detection. Additionally, the execution is run orthogonally to the viewing and editing of analysis objects.
Mistaking identity
Authors: Jacob Stein, T. Lougenia Anderson, David Maier
Venue: Proceedings of the second international workshop on Database programming languages (1989)

We examine the use and abuse of identity in object-oriented data management systems. We then examine mechanisms for reducing the abuse while preserving the advantages of identity. In particular, we are concerned with reintroducing traditional database amenities, such as value based reference, that have been lost in the transition from traditional data management systems.
Integrating relational databases with support for updates
Authors: M. Samy Gamal-Eldin, G. Thomas, R. Elmasri
Venue: Proceedings of the first international symposium on Databases in parallel and distributed systems (2000)

Most work on database integration has considered only support for data retrieval, not support for updates, and often the use of a special semantically rich data model has been required. In this paper we present an approach to database integration which supports updates and which uses only the standard relational data model. Many of the ideas used in this approach are applicable to database integration in the context of other data models as well.
Pictures and category labels as navigational aids for catalog browsing
Authors: C. Egido, J. Patterson
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems (1988)

We describe two experiments that compare the relative utility of pictures, labels, and the combination of both as navigational aids for computerized catalog browsing. The results point to the usefulness of example pictures as search aids in the context of menu traversal through hierarchically structured pictorial databases. We take this outcome to be a reflection of the disambiguating role that pictures can play for verbal category labels.
Optimal communication algorithms for regular decompositions on the hypercube
Authors: G. C. Fox, W. Furmanski
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

We discuss optimal communication and decomposition algorithms for a class of regular problems on concurrent computers with a hypercube topology, using a general technique we call the method of cube geodesics. We address the calculation of various transformations ( convolutions, functionals etc. ) of data distributed over the hypercube; examples are the Fast Fourier Transform, matrix algorithms, global scalar products and vector sums, sorting. These all involve long distance inter-node interactions and require more intricate communication that the simple local problems with static spatial decomposition such as partial differential equations. We believe that our library of optimal communication routines is applicable to these and many other problems. The simple example of a database application is sketched. We implement the algorithms on the Caltech/JPL Mark II hypercube and present a detailed performance analysis.
Cache performance of vector processors
Authors: K. So, V. Zecca
Venue: ACM SIGARCH Computer Architecture News (1988)

An instruction-level simulator for IBM 3090 with VF (vector facility) has been developed for studying the performance of vector processors and their memory hierarchies. Initial use of the simulator is to understand the program locality of real vectorized applications. Observation on several large scientific applications indicates that the program locality of vector execution can be significantly different from that of the scalar execution of the same application. Although these large applications generally do not exhibit a locality as strong as that of the conventional mainframe applications, their cache hit ratios are high enough to take advantage of a cache. The cache performance of these applications with respect to various cache parameters is also presented.
The role of external representation in the writing process: implications for the design of hypertext-based writing tools
Authors: C. M. Neuwirth, D. S. Kaufer
Venue: Proceedings of the second annual ACM conference on Hypertext (1989)

The long-range goal of the research reported here is to study the role of hypertext-based external representations in augmenting performance on a cognitively complex task, in particular, on a synthesis writing task. The production of a written synthesis is a challenging task that requires managing large amounts of information over an extended period of time. Thus, synthesis writing is a task that is well-suited for testing the potential of hypertext technologies to support work on complex tasks. From a case study of experts and novices, we have developed a theory of the cognitive processes involved in producing a written synthesis. We have also developed a preliminary theory of the role of external representations in the writing process. We have drawn upon these two theories to design several hypertext-based external representations that we believe will augment writers' performance on a written synthesis task. The hypertext-based applications include a general graph object and a table object; these objects form the foundation for a set of specialized tools to support synthesis writing, namely, a summary graph, synthesis grid and synthesis tree.
Commitment in a partitioned distributed database
Authors: K. V. S. Ramarao
Venue: Proceedings of the 1988 ACM SIGMOD international conference on Management of data (1988)

Network partition is among the hardest failure types in a distributed system even if all processors and links are of fail-stop type. We address the transaction commitment problem in a partitioned distributed database. It is assumed that partitions are detectable. The approach taken is conservative - that is, the same transaction cannot be committed by one site and aborted by another. A new and very general formal model of protocols operating in a partitioned system is introduced and protocols more efficient than the existing ones are constructed.
Queueing Analysis of an Optical Disk Jukebox Based Office System
Authors: John N. Daigle, Robert B. Kuehl, Joseph D Langford
Venue: IEEE Transactions on Computers (1990)

The system is modeled as a single-server queueing system having a finite number of each of two types of worker: document user and document entry operator. Worker think times are assumed to be exponentially distributed while job service times are drawn from general distributions; worker think times and job service times are dependent upon worker type. Throughput and waiting times as a function of the number of users of each type are analyzed under a nonpreemptive rule in which document use has priority over document entry.
Can video research escape the technology? some reflections on the problems and possibilities of A. V. research
Authors: Kathy Carter, B. Anderson
Venue: ACM SIGCHI Bulletin (1989)

There is no doubt that the use of video technology offers a major opportunity for research in a number of domains within the Social Sciences. At EuroPARC, we are developing initiatives in several distinct but clearly interrelated areas. The major heads under which these initiatives can be gathered are:(a) Video as a research technique(b) Video as a technology(c) Audio-video infrastructure
C-TODOS: an automatic tool for office system conceptual design
Authors: B. Pernici, F. Barbic, R. Maiocchi, M. G. Fugini, J. R. Rames, C. Rolland
Venue: ACM Transactions on Information Systems (TOIS) (1989)

Designers of office information systems, which share various features with information systems and software development, need to carefully consider special issues such as document and communication flows, user roles, user interfaces, and available technology. The ESPRIT Project, Automatic TOols for Designing Office Information Systems (TODOS), proposes an integrated environment for office design with tools for requirements collection and analysis, conceptual design, rapid prototyping, and architecture selection. Conceptual design is a central phase of office system design: It provides correct and complete functional requirements from which the office prototype will be developed and the final architecture chosen. C-TODOS, the conceptual design support tool developed within TODOS, is presented in this paper. The purpose of C-TODOS is to give the designer tools for supporting conceptual modeling activities with the goal of obtaining correct, consistent, and good quality office-functional specifications. This paper presents C-TODOS within the TODOS development environment and describes the basic features of the tool: the TODOS Conceptual Model, the Specification Database, and the Modeling, Query and Consistency Checking Modules. The use of C-TODOS, through illustration of the development of a test case, and possible future research are discussed.