ppxscal/embedding_network huggingface dataset:
Ensemble: a graphical user interface development system for the design and use of interactive toolkits
Authors: M. K. Powers
Venue: Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology (1989)

User Interface Development Systems (UIDS), as opposed to User Interface Management Systems or UI Toolkits focus on supporting the design and implementation of the user interface. This paper describes Ensemble, an experimental UIDS that begins to explore the electronic creation of interaction techniques as well as the corresponding design processes. Issues related to the impact on the components of the development system are discussed. Finally, problems with the current implementation and future directions are presented.
A Note on the Linear Transformation Method for Systolic Array Design
Authors: Wei-Ming Lin, V. K. Prasanna-Kumar
Venue: IEEE Transactions on Computers (1990)

The use of the linear transformation method to systolize the Warshall algorithm for computing the transitive closure of a graph on a mesh-connected array (without wraparound connections) is discussed. The technique is extended to design linear systolic arrays. The advantage of this approach is easy verification of correctness, as well as synthesis of a family of arrays with tradeoffs between I/O bandwidth, number of processing elements, and local storage. The technique can be further refined to cope with problems that entail nonconstant dependency vectors.
Music in computer science courses using inexpensive, exciting technology to teach programming principles
Authors: R. Foss
Venue: ACM SIGCSE Bulletin (1989)

I teach three courses in the Computer Science department at Rhodes University. I lecture computer organization to second year students, operating systems to third year students, and computer music tools to fourth years. Computer control of musical instruments naturally forms an integral part of the fourth year course. However, I have also included elements of musical device control (albeit very simpl e devices) into my other two courses. In all cases, the inclusion of musical device control has served to highlight certain important concepts and programming techniques in a way that has proved to be both fun and insightful. In this article, I will describe how I have gone about this inclusion.
SAUCI: a knowledge-based interface architecture
Authors: S. W. Tyler
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems (1988)

Most current approaches to the design of the human-computer interface result in systems that are difficult for users to master. This can be attributed to the absence of several key features, including: interface modularity; adaptability to the individual user; direct support of user intentions; and an intelligent advising capability. An architecture for the interface which facilitates the attainment of these four criteria is proposed. The architecture relies upon production system rules and various kinds of knowledge bases to tailor the user-computer dialogue to the ongoing context of the interaction. A prototype of this architecture has been implemented in LOOPS for interfacing to the UNIX system, and has been shown to enhance substantially the performance of novice users of the system.
A shading approach to non-convex clipping
Authors: Thomas L. Springall, Gustav Tollet
Venue: ACM SIGAPL APL Quote Quad (1990)

The conventional way of clipping a graphic object with a rectangular window or any convex polygon is to cut the object along a line tangent to each side of the polygon. Parts of the object on the exterior side of the line are thrown away. After repeating the process for all of the sides, what remains is the clipped object. However, this process fails if the clipping window is non-convex, i.e., has one or more corners that point inward, or if the window consists of more than one polygon. Too much then gets clipped away. One way of dealing with this situation is to break up the window into simple convex polygons. The object is clipped with each polygon in turn, and the results are joined together to form the final result. A different approach, presented here, is to use shading logic. The window is seen as an area to be shaded, and the object, as the shading pattern. That is, the window is shaded with the object. The method yields not only the clipped object, but also, as a by-product, the reverse clipping, i.e., that part of the object that lies outside the window. This is an advantage in graphics editing where both clippings are often needed in parallel.
Solving the heat equation symbolically with MuSimp
Authors: C. P. Mawata
Venue: Journal of Symbolic Computation (1988)

Algorithms are derived to solve the heat equation symbolically using Widder's ''Heat Polynomials''. The algorithms have been implemented in MuSimp.
Caching on a microcomputer, part 2
Authors: Percy G. Wood
Venue: ACM SIGSMALL/PC Notes (1988)

The article in the previous issue presented the idea of a disk cache and outlined the programming necessary to use it for read accesses. This article continues with the relevant programming for write accesses, using some of the subroutines contained in the previous article, and continues with other implementation details. It picks up with the branch not taken there; that is, the I/O command is not a read.
Concurrency control in groupware systems
Authors: C. A. Ellis, S. J. Gibbs
Venue: ACM SIGMOD Record (1989)

Groupware systems are computer-based systems that support two or more users engaged in a common task, and that provide an interface to a shared environment. These systems frequently require fine-granularity sharing of data and fast response times. This paper distinguishes real-time groupware systems from other multi-user systems and discusses their concurrency control requirements. An algorithm for concurrency control in real-time groupware systems is then presented. The advantages of this algorithm are its simplicity of use and its responsiveness: users can operate directly on the data without obtaining locks. The algorithm must know some semantics of the operations. However the algorithm's overall structure is independent of the semantic information, allowing the algorithm to be adapted to many situations. An example application of the algorithm to group text editing is given, along with a sketch of its proof of correctness in this particular case. We note that the behavior desired in many of these systems is non-serializable.
APLO: a simple modern APL
Authors: A. Graham
Venue: ACM SIGAPL APL Quote Quad (1989)

APL0 is a simple modern APL written entirely in APL2. It is smaller than APL2 (or even VSAPL) but is more powerful. APL0 is implemented as a shell that translates APL0 statements into standard APL2. Details such as symbol table and workspace management are all handled by native APL2. The result is a powerful and malleable APL system.
Building bilingual microcomputer systems
Authors: Murat Tayli, Abdulah I. Al-Salamah
Venue: Communications of the ACM (1990)

In the Arab world the need for bilingual microcomputer systems is ever increasing. In addition to the ability to process the Arabic and English scripts, an ideal system should support the use of existing applications with Arabic data and the access to the system facilities through Arabic interfaces. The Integrated Arabic System (IAS) was developed to study the feasibility of building such systems using existing microcomputers and software solutions.
A diagnostic expert system for analyzing multiple-failure transients in nuclear power plants
Authors: Robert P. Martin, B. Nassersharif
Venue: Proceedings of the 1st international conference on Industrial and engineering applications of artificial intelligence and expert systems - Volume 1 (1988)

CATALISP (Computer Aided Transient Analysis coded in Lisp) is a prototype expert system which is the result of a project investigating and implementing event confidence-levels (used by reactor safety experts in reactor transient analysis) in the form of an expert system. Currently, CATALISP is designed to diagnose reactor transients by analyzing simulated sensor and plant thermal hydraulic information from a system simulation. CATALISP uses a knowledge base of existing emergency nuclear plant operating guidelines and detailed thermal-hydraulic calculation results correlated to confidence-levels. CATALISP can diagnose a number of reactor transients (for example, loss-of-coolant accidents, steam-generator-tube ruptures, loss-of-offsite power, etc.). Future work includes the expansion of the knowledge base and improvement of the &ldquo;deep-knowledge&rdquo; qualitative models.
An efficient implementation of Boolean functions nd finite state machine as self-timed circuit
Authors: Llana David, Ran Ginosar, Michael Yoeli
Venue: ACM SIGARCH Computer Architecture News (1989)

Self-timed logic provides a method for designing logic circuits such that their correct behavior depends neither on the speed of their components nor on the delay along the communication wires. General synthesis methods for efficiently implementing self-timed combinational logic (CL) and finite state machines (FSM) are presented. The resulting CL is shown to require less gates than other proposed methods. The FSM is implemented by interconnecting a CL module with aself-timed master-slave register. The FSM synthesis method is also compared with other approaches. A formal system of behavioral sequential constraints is presented for each of the systems, and their behavior is proven correct. Thus, the synthesized CLs and FSMs can serve as "correct-by-construction" building blocks for self-timed silicon system compilation.
DSM: an object-relationship modeling language
Authors: A. V. Shah, J. H. Hamel, R. A. Borsari, J. E. Rumbaugh
Venue: Conference proceedings on Object-oriented programming systems, languages and applications (1989)

The Data Structure Manager (DSM) combines object-oriented programming with semantic data modeling concepts in the context of the C language. DSM is a full-featured object-oriented language which includes single and multiple inheritance, class descriptor objects, metaclasses, choice of method binding time, error handling, persistent objects, modularity, and an interactive interpreter in an efficient manner. In addition, DSM supports the association and aggregation relationships as part of the Object Modeling Technique (OMT) used for conceptual design. DSM has been used since 1986 to build a variety of research and production-quality software such as an advanced CAF/CAD system.
Hardware-Assisted Software Clock Synchronization for Homogeneous Distributed Systems
Authors: P. Ramanathan, Dilip D. Kandlur, Kang G. Shin
Venue: IEEE Transactions on Computers (1990)

A clock synchronization scheme that strikes a balance between hardware and software solutions is proposed. The proposed scheme is a software algorithm that uses minimal additional hardware to achieve reasonably tight synchronization. Unlike other software solutions, the guaranteed worst-cast skews can be made insensitive to the maximum variation of message transit delay in the system. The scheme is particularly suitable for large partially connected distributed systems with topologies that support simple point-to-point broadcast algorithms. Examples of such topologies include the hypercube and the mesh interconnection structures.
On estimating the cardinality of the projection of a database relation
Authors: Rafiul Ahad, K. V. Bapa, Dennis McLeod
Venue: ACM Transactions on Database Systems (TODS) (1989)

We present an analytical formula for estimating the cardinality of the projection on certain attributes of a subset of a relation in a relational database. This formula takes into account a priori knowledge of the semantics of the real-world objects and relationships that the database is intended to represent. Experimental testing of the formula shows that it has an acceptably low percentage error, and that its worst-case error is smaller than the best-known formula. Furthermore, the formula presented here has the advantage that it does not require a scan of the relation.
Models of a very large distributed database
Authors: M. Blakey
Venue: Proceedings of the ACM workshop on Frontiers in computer communications technology (1987)

The problems inherent in managing a database distributed over a very large number of sites are considered. The applications of such databases to the provision of telecommunications and other public services are discussed. It is shown that the distribution and maintenance of the directory information describing object locations poses some fundamental problems. A new partially informed class of distributed databases is described which distributes the directory information on a &ldquo;needs-to-know&rdquo; basis. The class is described by models of the network topology, and by the knowledge available to each site. These proposals are sufficiently general to support the partitioning of data relations into distribution fragments, and for those fragments to be replicated at multiple sites.
A Highly Parallel Algorithm for Root Extraction
Authors: T. A. Rice, L. H. Jamieson
Venue: IEEE Transactions on Computers (1989)

A parallel algorithm for extracting the roots of a polynomial is presented. The algorithm is based on Graeffe's method, which is rarely used in serial implementations, because it is slower than many common serial algorithms, but is particularly well suited to parallel implementation. Graeffe's method is an iterative technique, and parallelism is used to reduce the execution time per iteration. A high degree of parallelism is possible, and only simple interprocessor communication is required. For a degree-n polynomial executed on an (n+1)-processor SIMD machine, each iteration in the parallel algorithm has arithmetic complexity of approximately 2n and a communications overhead n. In general, arithmetic speedup is on the order of p/2 for a p-processor implementation.
Multiplicative complexity of polynomial multiplication over finite fields
Authors: Michael Kaminski, Nader H. Bshouty
Venue: Journal of the ACM (JACM) (1989)

Let Mq(n) denote the number of multiplications required to compute the coefficients of the product of two polynomials of degree n over a q-element field by means of bilinear algorithms. It is shown that Mq(n) &nge; 3n - o(n). In particular, if q/2 < n &lne; q + 1, we establish the tight bound Mq(n) = 3n + 1 [q/2].The technique we use can be applied to analysis of algorithms for multiplication of polynomials modulo a polynomial as well.
Quantifier elimination in the theory of an algebraically-closed field
Authors: D. Ierardi
Venue: Proceedings of the twenty-first annual ACM symposium on Theory of computing (1989)

In this paper we develop a fast parallel procedure for deciding when a set of multivariate polynomials with coefficients in an arbitrary field K have a common algebraic solution. Moreover, since the proposed algorithm is algebraic, it easily yields a procedure for quantifier elimination in the theory of an arbitrary algebraically closed field. More precisely, we show how to decide whether m polynomials in n variables, each of degree at most d, with coefficients in an arbitrary field K have a common zero in the algebraic closure of K, using sequential time (mn)&Ogr;(n)d&Ogr;(n)2), or parallel time &Ogr;(n3 log3 d log m) with (mn)&Ogr;(n)d&Ogr;(n)2) processors, in the operations of the coefficient field K. Using randomization, this may be improved to (mn)&Ogr;(1)d&Ogr;(n) time. In addition, the construction is used give a direct EXPSPACE algorithm for quantifier elimination in the theory of an algebraically-closed field, which runs in PSPACE or parallel polynomial time when restricted to formulas with a fixed number of alternations of quantifiers.
A natural language interface to a multiple databased office information system
Authors: Bipin C. Desai, Richard J. Pollock, Philip J. Vincent
Venue: ACM SIGOIS Bulletin (1988)

As an organization grows through mergers and acquisitions and through the integration of independently designed information sub-systems, it could find itself faced with a collection of databases implemented on heterogeneous database management systems. This paper presents a system to provide integrated access to multiple, independently designed databases through a portable natural language front-end and a multiple database access system back-end.The overall system is divided into a natural language interface (NLI) front-end and a multiple database access system (MDAS) back-end. The MDAS integrates the various conceptual views into a single global external schema. In a prototype of the overall system, the NLI will accept a natural language query and produce a relational calculus query expression over a global external schema. The MDAS will construct the response to the query by accessing the separate constituent databases through the local database management systems (DBMS's).
The Role of Visualization in the Simulation of Quantum Electronic Transport in Semiconductors
Authors: Norman C. Kluksdahl, Alfred M. Kriman, David K. Ferry
Venue: Computer (1989)

Using the Wigner function to simulate semiconductor processes and depicting the results graphically is leading to new insights concerning these devices. The Wigner function, which uses a formalism that correctly incorporates all the quantum mechanics inherent in a problem, is the Fourier transform of the density matrix, taken with respect to a difference variable. The tunneling problem and the simulation of the resonant tunneling diode are discussed.
Scheduling Support for Concurrency and Parallelism in the Mach Operating System
Authors: David L. Black
Venue: Computer (1990)

The shared use of general-purpose uniprocessors is examined. Support for common uniform-memory-access architectures that have all memory equidistant from all processors in terms of access time is emphasized. This work is also applicable to non-uniform-memory-access machines, whose memory access times depend on the physical distance between the processor and the accessed memory, but it does not provide a complete solution to load-balancing problems for this class of machine. The discussion covers time-sharing scheduling, the Mach scheduler, programming models, scheduling concurrency support, processor allocation, and related work.
Distributed Ada for deadline driven applications
Authors: T. Griest
Venue: Proceedings of the conference on TRI-Ada '88 (1989)

This talk describes a project that utilized distributed Ada tasking with multiple processors executing a single Ada program. Concerns of performance are emphasized to address the problems of deadline driven systems. The Ada tasking model was selected for distributed communication to provide a consistent approach to the representation of concurrency.
Lines in space-combinators, algorithms and applications
Authors: B. Chazelle, H. Edelsbrunner, L. Guibas, M. Sharir
Venue: Proceedings of the twenty-first annual ACM symposium on Theory of computing (1989)

We study combinatorial and algorithmic problems involving arrangements of n lines in 3-dimensional space, and then present applications of our results to a variety of problems on polyhedral terrains. Our main results include: A tight &THgr;(n2) bound on the complexity of the space of all lines passing above all the n given lines (their &ldquo;upper envelope&rdquo;) and satisfying a certain orientation consistency constraint. A preprocessing procedure using near-quadratic time and storage that builds a structure supporting &Ogr;(log n) time queries for testing if a line lies above all the given lines. An &Ogr;(n4/3+&egr;) randomized expected time algorithm, for any fixed &egr; > 0, that tests the &ldquo;towering property&rdquo;: do n given red lines lie all above n given blue lines? A preprocessing procedure for a polyhedral terrain &Sgr; with n edges, that uses near-quadratic time and storage and builds a structure supporting &Ogr;(log2 n) time rayshooting queries for computing the first intersection of an arbitrary query ray with &Sgr;. Finding the smallest vertical distance between two disjoint polyhedral terrains with a total of n edges, in time &Ogr;(n4/3+&egr;), for any &egr; > 0. Computing the upper envelope (pointwise maximum) of two polyhedral terrains with a total of n edges, in time &Ogr;(n1.5+&egr; + klog2 n), for any &egr; > 0, where &kgr; is the size of the output envelope. The tools used to obtain these results include Pl&uuml;cker coordinates for lines in space, random sampling in geometric problems, and a new variant of segment trees.
Efficient Database Access from Prolog
Authors: Stefano Ceri, Georg Gottlob, Gio Wiederhold
Venue: IEEE Transactions on Software Engineering (1989)

In designing the interface between a relational database and a Prolog interpreter, efficiency is a major issue. The authors present a method for loading into the memory-resident database of Prolog facts permanently stored in secondary storage. The rationale of the method is to save access to the database by never repeating the same query and by storing in main memory, in a compact and efficient way, information about the past interaction with the database. The authors discuss how to reduce subsumption rests required by the method to pattern matching in many relevant cases. They also describe a simulator of the method, which validates their approach, and they discuss the results of the simulation.
Combining version control with automatic program building
Authors: M. Gordon
Venue: ACM SIGSOFT Software Engineering Notes (1989)

In the Unix1 system, the problem of rebuilding a program of file when one or more source files change is solved separately (by make from the problem of maintaining past versions of the program source files (solved by SCCS or RCS). This paper describes a practical system that combines these functions and shows that by doing so, additional common software development problems can also be solved. These include tracking and recovering a complete set of the source files necessary to build an arbitrary release of a product, support for multiple developers working on products that share source code, and identifying the source file versions that went into any given software build. This system is called the Portable Configuration Management System. Other improvements upon past methods include compression of the source revisions, the ability to handle non-ASCII source files, and the ability to identify revisions of files by timestamp or 32-bit CRC in lieu of to the version number.
The Effect of Data Abstraction on Loop Programming Techniques
Authors: Judy M. Bishop
Venue: IEEE Transactions on Software Engineering (1990)

It is shown how loop algorithms can be encompassed in an iterator and then activated for any data type for which a generator can be defined. It takes the iterator-generator idea a step further than previous work in that it permits variations of the iterators to be defined dynamically through the use of selectors and actors, without loss of efficiency or clarity. It is further shown that selectors can be employed in the definition of a truly generic sorting routine. Guidelines for the decomposition of a system into generic data types, abstract data types, iterators, generators, and the programs that exercise them are given, and several complete programs show the implementation of the techniques in Ada.
On oraclizable networks and Kahn's principle
Authors: James R. Russell
Venue: Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1989)

In this paper we investigate generalizations of Kahn's principle to nondeterministic dataflow networks. Specifically, we show that for the class of &ldquo;oraclizable&rdquo; networks a semantic model in which networks are represented by certain sets of continuous functions is fully abstract and has the fixed-point property. We go on to show that the oraclizable networks are the largest class representable by this model, and are a proper superclass of the networks implementable with the infinity fair merge primitive. Finally, we use this characterization to show that infinity fair merge networks and oraclizable networks are proper subclasses of the networks with Egli-Milner monotone input-output relations.