ppxscal/embedding_network huggingface dataset:
The berkeley UNIX consultant project
Authors: Robert Wilensky, David N. Chin, Marc Luria, James Martin, James Mayfield, Dekai Wu
Venue: Computational Linguistics (1988)

UC (UNIX Consultant) is an intelligent, natural language interface that allows naive users to learn about the UNIX2 operating system. UC was undertaken because the task was thought to be both a fertile domain for artificial intelligence (AI) research and a useful application of AI work in planning, reasoning, natural language processing, and knowledge representation.The current implementation of UC comprises the following components: a language analyzer, called ALANA, produces a representation of the content contained in an utterance; an inference component, called a concretion mechanism, that further refines this content; a goal analyzer, PAGAN, that hypothesizes the plans and goals under which the user is operating; an agent, called UCEgo, that decides on UC's goals and proposes plans for them; a domain planner, called KIP, that computes a plan to address the user's request; an expression mechanism, UCExpress, that determines the content to be communicated to the user, and a language production mechanism, UCGen, that expresses UC's response in English.UC also contains a component, called KNOME, that builds a model of the user's knowledge state with respect to UNIX. Another mechanism, UCTeacher, allows a user to add knowledge of both English vocabulary and facts about UNIX to UC's knowledge base. This is done by interacting with the user in natural language.All these aspects of UC make use of knowledge represented in a knowledge representation system called KODIAK. KODIAK is a relation-oriented system that is intended to have wide representational range and a clear semantics, while maintaining a cognitive appeal. All of UC's knowledge, ranging from its most general concepts to the content of a particular utterance, is represented in KODIAK.
Extension and software development
Authors: D. Notkin, W. G. Griswold
Venue: Proceedings of the 10th international conference on Software engineering (1988)

Enhancement is the most costly phase of the software development life-cycle. By developing an extension mechanism that allows users to augment a software system without modifying the underlying source code, we address enhancement directly. We describe the design and implementation of the extension mechanism. We also demonstrate how the availability of this flexible mechanism alters not only the enhancement phase of the life-cycle, but the design and implementation phases as well.
Coordinated motion planning for two independent robots
Authors: M. Sharir, S. Sifrony
Venue: Proceedings of the fourth annual symposium on Computational geometry (1988)

We present an &Ogr;(n2) algorithm for planning a coordinated collision-free motion of two independent robot systems of certain kinds, each having two degrees of freedom, which move in the plane amidst polygonal obstacles having a total of n corners. We exemplify our technique in the case of two &ldquo;planar Stanford arms&rdquo;, but also discuss the case of two discs or convex translating objects. The algorithm improves previous algorithms for this kind of problems, and can be extended to a fairly simple general technique for obtaining efficient coordinated motion planning algorithms.
A Functional Correctness Model of Program Verification
Authors: Marvin V. Zelkowitz
Venue: Computer (1990)

A model whose verification conditions depend only on elementary symbolic execution of a trace table is presented. The method is applied to rather simple programs. However, even in large complex implementations, the techniques can be applied informally to determine the functionality of complex interactions. The technique is easy to learn (it is used in a freshman computer science course) and lends itself to automation.
Optimal separations between concurrent-write parallel machines
Authors: R. B. Boppana
Venue: Proceedings of the twenty-first annual ACM symposium on Theory of computing (1989)

We obtain tight bounds on the relative powers of the Priority and Common models of parallel random-access machines (PRAMs). Specifically we prove that: The Element Distinctness function of n integers, though solvable in constant time on a Priority PRAM with n processors, requires &OHgr;(A(n,p)) time to solve on a Common PRAM with p &ge; n processors, where A(n,p) = n log n/p log (n/p log n + 1). One step of a Priority PRAM with n processors can be simulated on a Common PRAM with p processors in &Ogr;(A(n,p)) steps. As an example, the results show that the time separation between Priority and Common PRAMs each with n processors is &THgr;(log n/log log n).
A fetch-and-op implementation for parallel computers
Authors: G. J. Lipovski, P. Vaughan
Venue: ACM SIGARCH Computer Architecture News (1988)

An efficient fetch-and-op circuit is described. A bit-serial circuit-switched implementation requires only 5 gates per node in a binary tree. This versatile circuit is also capable of test-and-set primitives (priority circuits) and swap operators, as well as AND and OR operations used in SIMD tests such as &ldquo;branch on all carries set.&rdquo; It provides an alternative implementation for the combining fetch-and-add circuit to the one designed for the Ultracomputer project; this implementation is suited to SIMD computing and can be adapted to MIMD computing.
High-speed processing schemes for summation type and iteration type vector instructions on Hitachi supercomputer S-820 system
Authors: H. Wada, K. Ishil, M. Fukagawa, H. Murayama, S. Kawabe
Venue: Proceedings of the 2nd international conference on Supercomputing (1988)

The HITACHI supercomputer S-820 system has been developed as Hitachi's top end supercomputer. It is also rated as one of the most powerful supercomputers in the world. Among the vector instructions which supercomputers support, summation type vector instructions and iteration type vector instructions are not suitable for parallel processing, since elements to be processed are not independent in these instructions. The S-820 employs high-speed processing schemes for summation type vector instructions and iteration type vector instructions; the performance of summation type instructions is enhanced by high-speed post-processing scheme and the performance of iteration type instructions is enhanced by high-speed parallelizing scheme for iteration arithmetic. Thanks to these schemes, the execution speeds for Kernel 3 and Kernel 4 of the Lawrence Livermore Laboratory's 24 Kernels become 838.7 MFLOPS and 258.5 MFLOPS respectively, and those for Kernel 5, Kernel 6 and Kernel 11 of the Lawrence Livermore Laboratory's 14 Kernels become 114.6 MFLOPS, 111.8 MFLOPS and 98.4 MFLOPS, respectively.
Surfaces from Stereo: Integrating Feature Matching, Disparity Estimation, and Contour Detection
Authors: William A. Hoff, Narendra Ahuja
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

An approach is described that integrates the processes of feature matching, contour detection, and surface interpolation to determine the three-dimensional distance, or depth, of objects from a stereo pair of images. Integration is necessary to ensure that the detected surfaces are smooth. Surface interpolation takes into account detected occluding and ridge contours in the scene; interpolation is performed within regions enclosed by these contours. Planar and quadratic patches are used as local models of the surface. Occluded regions in the image are identified, and are not used for matching and interpolation. A coarse-to-fine algorithm is presented that generates a multiresolution hierarchy of surface maps, one at each level of resolution. Experimental results are given for a variety of stereo images.
A new fixed point approach for stable networks stable marriages
Authors: T. Feder
Venue: Proceedings of the twenty-first annual ACM symposium on Theory of computing (1989)

In a network stability problem, the aim is to find stable configurations for a given network of Boolean gates. For general networks, the problem is known to be computationally hard. Mayr and Subramanian [22,23] introduced an interesting class of networks by imposing fanout restrictions at each gate, and showed that network stability on this class of networks is still sufficiently rich to express as special cases the well-known stable marriage and stable roommate problems. In this paper we study the sequential and parallel complexity of network stability on networks with restricted fanout. Our approach builds on structural properties of these networks, and exposes close ties with the theory of retracts and isometric embeddings for product graphs. This structure gives then new efficient algorithms for questions of representation, enumeration and optimality in stable matching.
Visualizing Performance Debugging
Authors: T. Lehr, Z. Segall, D. F. Vrsalovic, E. Caplan, A. L. Chung
Venue: Computer (1989)

The authors examine a special software development environment called the Parallel Programming and Instrumentation Environment (PIE). PIE is designed to develop performance-efficient parallel and sequential computations. Following an explanation of PIE's general theory and features, PIE's visualization tools are used to isolate and repair the parallelism problem of an eight-process computation. Two more difficult examples using PIE are discussed. Some of the issues involved in correctly presenting visual information, such as the features users ask for and what can be done about a performance monitor's perturbation of computations, are addressed.
Controlling propagation of operations using attributes on relations
Authors: James Rumbaugh
Venue: ACM SIGPLAN Notices (1988)

Controlling the propagation of operations through a collection of objects connected by various relationships has been a problem both for the object-oriented and the data base communities. Operations such as copy, destroy, print, and save must propagate to some, but not all, of the objects in a collection. Such operations can be implemented using ad hoc methods on objects, at the cost of extra work and loss of clarity. The use of propagation attributes on the relationships between objects permits a concise, intuitive specification of the manner in which operations should propagate from one object to another. These concepts have been implemented in the object-oriented language DSM and have been used to write applications.
Two-level grammars as a technique for formalizing programming schemes
Authors: M. Saacks, J. Hassell
Venue: Proceedings of the 17th conference on ACM Annual Computer Science Conference (1989)

This paper addresses the issue of formalizing programming schemes (or programming plans). Research in problem solving and in programming has shown a hierarchical organization of program solutions. This organization suggests that a hierarchical formal definition can be used to eliminate the ambiguity inherent in previous natural language definitions. This paper uses the hierarchy implicit in two-level grammars to define programming schemes. It gives examples to illustrate how the definition can be used for a particular scheme.
Evaluation of current software costing tools
Authors: R. Martin
Venue: ACM SIGSOFT Software Engineering Notes (1988)

Much effort has been expended over the last several years to construct various tools which predict the development schedules and costs of software projects. The organizations which contract out system development work are starting to request that the contractor use a specific costing tool during the bid.This paper reports the results and recommendations of a software costing tool evaluation project which was recently carried out at MacDonald Dettwiler. The primary project goal was to model a suite of the company's completed projects and determine if currently available commercial tools could predict effort and elapsed project time.
A hardware mechanism for priority queue
Authors: Tsong-Chih Hsu, Ling-Yang Kung
Venue: ACM SIGARCH Computer Architecture News (1989)

In this paper a hardware mechanism for supporting priority queues is described that provides the primitive operations on a priority queue. The principle mechanism for attaining this goal are a fast fully parallel Content Associative Memory (CAM), a high speed priority memory, and a good multiple--response resolver.
The fast Hartley transform on the hypercube multiprocessors
Authors: X. Lin, T. F. Chan, W. J. Karplus
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

The Fast Hartley Transform is a promising alternative to the Fast Fourier Transform when the processed data are real numbers. The hypercube implementation of the FHT is largely dependent on the way the computation is partitioned. A partitioning algorithm is presented which generates evenly-loaded tasks on each node and demands only a regular communication topology &mdash; the Hartley graph. Mapping from the Hartley graph to the Gray graph (binary n-cube) is straightforward, since the Hartley graph has a similar structure as the Gray graph. However, the communication is not always between the nearest neighbors and thus may take some extra time. Moreover, the slowness of the communication in the presently available architectures imposes a limitation on the speedup when a large number of processors are used.
An evaluation and selection methodology of microcomputer training software: Implications for human resource managers and computer personnel
Authors: S. F. Rushinek, A. Rushinek
Venue: Proceedings of the ACM SIGCPR conference on Management of information systems personnel (1988)

This paper illustrates the selection of Microcomputer Training Software (TS). A recommendation report ranks the TS in descending order of their correlations to user needs. Implications for human resources directors and computer personnel managers are discussed.
Parallelism in processing queries on complex objects
Authors: T. Harder, H. Schoning, A. Sikeler
Venue: Proceedings of the first international symposium on Databases in parallel and distributed systems (2000)

Complex objects to support non-standard database applications require the use of substantial computing resources because their powerful operations and their related integrity constraints must be performed and maintained in an interactive environment. Since the exploitation of parallelism within such operations seems to be promising, we investigate the principal approaches for processing a query on complex objects (molecules) in parallel. A number of arguments favor methods based on inter-molecule parallelism as against intramolecule parallelism. Retrieval of molecules may be optimized by multiple storage structures and access paths. Hence, maintenance of such storage redundancy seems to be another good application area to explore the use of parallelism. Deferred update seems to be a bad idea, whereas concurrent update strategies incorporate salient application features. For performance reasons, we have chosen a multiprocessor system sharing an instruction addressable common memory which is used for buffer management, synchronization, and logging/recovery. Activation of concurrent requests is supported by a nested transaction concept which allows a safe and effective execution control within parallel actions of an operation.
Pattern recognition by neural network model on hypercubes
Authors: W. Furmanski
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

The objective of this work is to study the performance characteristics of the back-propagation model for pattern recognition. Specifically, the test case of recognition of Chinese characters is studied on an ELXSI-6400 and MARK III hypercube. Preliminary results indicate that local spatial decomposition of characters in the training set leads to simple parallel implementation of the neural net model on hypercubes, and also serves as an effective pre-processor which provides high quality of recognition and good efficiency.
A tree-based algorithm for distributed mutual exclusion
Authors: Kerry Raymond
Venue: ACM Transactions on Computer Systems (TOCS) (1989)

We present an algorithm for distributed mutual exclusion in a computer network of N nodes that communicate by messages rather than shared memory. The algorithm uses a spanning tree of the computer network, and the number of messages exchanged per critical section depends on the topology of this tree. However, typically the number of messages exchanged is O(log N) under light demand, and reduces to approximately four messages under saturated demand. Each node holds information only about its immediate neighbors in the spanning tree rather than information about all nodes, and failed nodes can recover necessary information from their neighbors. The algorithm does not require sequence numbers as it operates correctly despite message overtaking.
Determining average program execution times and their variance
Authors: V. Sarkar
Venue: ACM SIGPLAN Notices (1989)

This paper presents a general framework for determining average program execution times and their variance, based on the program's interval structure and control dependence graph. Average execution times and variance values are computed using frequency information from an optimized counter-based execution profile of the program.
Propositional production systems for dialog description
Authors: Dan R. Olsen,  Jr.
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Empowering people (1990)

The Propositional Production System (PPS) for describing interactive dialogs is defined. It is shown to be a superset of state machines, window event translation tables and event response systems. It is shown how dialogs can be expanded by means of inheritance and how semantic control information can be uniformly integrated into the dialog model. Optimizations are defined which can tune the executable machine for either minimal space or minimal execution time.
Combinatorial dimension theory of algebraicvarieties
Authors: Marc Giusti
Venue: Journal of Symbolic Computation (1988)

Several algorithms are already known to compute the dimension of a projective algebraicvariety. But they all rely on the construction of the whole standard basis of the defining ideal, leading to non optimal worst case complexities. We present below a new algorithm, based on a truncation idea, with better complexity.
Users' preferences among different techniques for displaying the evaluation of LISP functions in an interactive debugger
Authors: J. M. Hary, L. A. Cohan, M. J. Darnell
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems (1988)

Two experiments investigated various techniques for displaying the evaluation of LISP functions in an interactive debugger. The studies examined three techniques of highlighting the flow of evaluation in a LISP function and two display formats for displaying LISP function information. The subjects in both experiments included highly experienced LISP programmers and occasional LISP users with moderate to little LISP experience. The dependent measure was the subjects' preference rating for each display technique. The results showed that occasional LISP users preferred range highlighting, an interlaced display of evaluation results, and a simultaneous display of called functions. However, expert LISP programmers had no differential preferences for highlighting techniques.
A type driven hardware engine for Prolog clause retrieval over a large knowledge base
Authors: K.-F. Wong, M. H. Williams
Venue: ACM SIGARCH Computer Architecture News (1989)

Whereas existing Prolog systems are very effective at handling small knowledge bases, they are not very efficient at and often incapable of handling large sets of clauses. Large knowledge bases which may comprise millions of clauses and are shared by a number of users, may need to reside in secondary memory. In such cases exhaustive search is inordinately slow. Various approaches have been put forward for handling the problem, most of which involve coupled systems (loosely or tightly coupled). A Prolog data/knowledge based system which provides an integrated solution to the problem is being developed. An essential element in this system is the CLAuse Retrieval Engine, CLARE, which is a special purpose hardware engine designed to perform selective retrieval of data from disk in order to identify all potential clauses which will be required for full unification during a query. The engine consists of two separate hardware components, which together form a two-stage filtering configuration. This paper concentrates on the second stage filter which is concerned with partial test unification.
Gr&ouml;bner basis, integration and transcendental functions
Authors: N. Takayama
Venue: Proceedings of the international symposium on Symbolic and algebraic computation (1990)

It is well known that Gr&ouml;bner basis is a fundamental and powerful tool to solve problems of polynomials ([Buch*],[JSC] etc). Recently, it is revealed that we can use Gr&ouml;bner basis of Weyl algebra to solve the problems of integrations and formula verifications of transcendental functions ([Zei*], [Tak*], [AZ], [WZ*]). The purpose of the paper is to survey the theory of Gr&ouml;bner basis of the ring of differential operators and its applications to the following problems: Computation of differential equations for a definite integral with parameters. Zero recognition of an expression that contains special functions or binomial coefficients etc., i.e. formula verification by a computer. Derivations of some of special functions identities. Solving a definite integral or obtaining an asymptotic expansion of a definite integral with parameters.
An experimental facility for cooperative processing in APL
Authors: S. Kaneko
Venue: ACM SIGAPL APL Quote Quad (1987)

The Cooperative Processing Facility was designed to allow cooperation between active workspaces on a host and a workstation. This facility consists of two auxiliary processors on each system. When a workstation is connected to a host system by an appropriate emulator, this facility enables an APL user on the workstation easily to develop the application giving access to the active workspace of the host APL system. A prototype was developed for APL2 and Japanese APL, and its effectiveness was verified by implementing it experimentally.