ppxscal/embedding_network huggingface dataset:
Contour Tracking and Corner Detection in a Logic Programming Environment
Authors: B. Bell, L. F. Pau
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1990)

The added functionality such as contour tracking and corner detection which logic programming lends to standard image operators is described. An environment for implementing low-level imaging operations with Prolog predicates is considered. Within this environment, higher-level image predicates (contour tracking and corner detection) are constructed. The emphasis is not on building better corner detectors, but on presenting ways of using the unification and backtracking features of logic programming for these tasks. The performance of this implementation of contour tracking and corner detection has been very good in many more complex images, as it allows for feedback both ways between sensor input and symbolic models. More important is the parameter selection capability in a dynamic version where background properties change. The authors present examples of Prolog predicates for performing the contour and corner detection operations.
The growth of software testing
Authors: D. Gelperin, B. Hetzel
Venue: Communications of the ACM (1988)

We can trace the evolution of software test engineering by examining changes in the testing process model and the level of professionalism over the years. The current definition of a good software testing practice involves some preventive methodology.
Comments, with Reply, on 'Fast Convolution with Laplacian-of-Gaussian Masks' by J.S. Chen et al
Authors: G. E. Sotak,  Jr., K. L. Boyer
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

In a recent paper by J.S. Chen et al. the authors presented a means of decomposing the Laplacian-of-Gaussian (LoG) kernel into the product of a Gaussian and a (smaller) LoG mask. They then proceeded to develop a fast algorithm for convolution which exploits the spatial frequency properties of these operators to allow the image to be decimated (subsampled). Although this approach is both novel and interesting, it is contended that the exposition suffers from some inconsistencies and minor errors. The commenters clarify matters for those who wish to implement this technique. The original authors acknowledge two of the three points raised, and provide further clarification of the other one namely, the claim that the masks (Gaussian and LoG) are too small.
Behavioural and organisational factors involved in the turnover of high tech professionals
Authors: A.-M. Garden
Venue: ACM SIGCPR Computer Personnel (1988)

One of the most critical issues facing managers of high tech companies is keeping their technical employees satisfied and trying to prevent a rapid staff turnover. The shortage of good quality technical people in high tech companies creates a high demand for their skills. This makes it easy for them to change employers and more important for companies to provide working conditions which are attractive enough to keep their technical staff. The managerial problem is to know what are the critical organisational and job features that affect the desire to stay in or leave a company. This commentary provides some insight into this issue. Two main areas are covered; the first is the reasons why technical employees would leave their present company; the second looks at factors influencing the length of time they expect to stay in their present company.The findings presented form part of a much larger study on the motivation of high tech software professionals. The present commentary is based on the preliminary questionnaire results of 302 people from 7 high tech software companies, 3 small companies with less than 50 employees, 3 medium size companies with between 150-200 employees and 1 large company with over 2, 000 employees in total.
Extreme Area-Time Tradeoffs in VLSI
Authors: Binay Sugla, David A. Carlson
Venue: IEEE Transactions on Computers (1990)

Consideration is given to the layout of bounded fan-in and fan-out prefix computation graphs in VLSI, and it is shown that the area requirements of such graphs exhibit this interesting property. A small constant factor reduction in time of computation from 2 log eta to log eta increases the area required to embed an eta node prefix computation graph significantly from O( eta log eta ) to Omega ( eta /sup 2/). The area requirements are also given. This behavior is an example of an extreme area-time tradeoff in VLSI. Since prefix computation also models the carry computation in a carry look-ahead adder, the same behavior is observed in the area requirements of a near-minimum computation time carry look-ahead adder. The authors also present circuits which meet the derived lower bounds for all values of T between log eta and 2 log eta .
A Systolic Array for the Assignment Problem
Authors: U. Schwiegelshohn, L. Thiele
Venue: IEEE Transactions on Computers (1988)

A pure systolic realization of an algorithm for solving the n*n assignment problem is presented. This systolic algorithm can be implemented on an homogeneous hexagonal processor array and requires O(n/sup 2/) area complexity and O(n/sup 2/) time complexity.
Symmetries of the firing squad sychronization problem revealed in a nested array
Authors: A. P. Benkard
Venue: Proceedings of the international conference on APL (1987)

The firing squad problem of automata theory is described and a simple, nonoptimal solution is given. Examination of output traces shows that the solution has at least one obvious symmetry. If the transition matrix is reshaped and partitioned, the resulting nested array not only reveals and explicates more symmetries but suggests ways in which nested arrays can be used to save space.
PC-CUBE, a personal computer based hypercube
Authors: A. Ho, G. C. Fox, D. W. Walker, S. Snyder, D. Chang, S. Chen, M. Breaden, T. Cole
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

PC-CUBE is an ensemble of IBM PCs or close compatibles connected in the hypercube topology with ordinary computer cables. Communication occurs at the rate of 115.2 K-baud via the RS-232 serial links. Available for PC-CUBE is the Crystalline Operating System III (CrOS III), Mercury Operating System, CUBIX and PLOTIX which are parallel I/O and graphics libraries. A CrOS performance monitor was developed to facilitate the measurement of communication and computation time of a program and their effects on performance. Also available are CXLISP, a parallel version of the XLISP interpreter; GRAFIX, some graphics routines for the EGA and CGA; and a general execution profiler for determining execution time spent by program subroutines. PC-CUBE provides a programming environment similar to all hypercube systems running CrOS III, Mercury and Cubix. In addition, every node (personal computer) has its own graphics display monitor and storage devices. These allow data to be displayed or stored at every processor, which has much instructional value and enables easier debugging of applications. Some application programs which are taken from the book Solving Problems on Concurrent Processors [Fox 88] were implemented with graphics enhancement on PC-CUBE. The applications range from solving the Mandelbrot set, Laplace equation, wave equation, long range force interaction, to Wa-Tor, an ecological simulation.
An OCCAM approach to transputer engineering
Authors: P. H. Welch
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

Harnessing the potential processing power of MIMD networks requires the development of a fluency in parallel systems design equal to our traditional skills for sequential logic. Occam (TM) is a simple, small but powerful language which enables such fluency. The model of parallelism provided by occam is a central (not &ldquo;added on&rdquo;) feature and is directly supported by the INMOS transputer (TM). This model reflects major software engineering features such as abstraction, structuring, and information hiding and has important benefits for the life-cycle development costs of large systems (not least through the establishment of libraries of reusable software/hardware components). This paper introduces such engineering with the emphasis upon finely-grained highly-parallel designs. Some examples will be taken from the area of high-performance fault-tolerant real-time embedded systems. Occam is one of those rare languages that obeys (and was designed to obey) a rich set of mathematical laws (concerning sequential, parallel, and non-deterministic logic). This allows clear (and formal) reasoning. The combination of the security and simplicity of occam with the performance and simplicity of the transputer is worthy of proper investigation.
DIME: a programming environment for unstructured triangular meshes on a distributed-memory parallel processor
Authors: R. D. Williams
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

DIME (Distributed Irregular Mesh Environment) is a user environment written in C for manipulation of an unstructured triangular mesh in two dimensions. The mesh is distributed among the separate memories of the processors, and communication between processors is handled by DIME; thus the user writes C-code referring to the elements and nodes of the mesh and need not be unduly concerned with the parallelism. A tool is provided for the user to make an initial coarse triangulation of a region, which may then be adaptively refined and load-balanced. DIME provides many graphics facilities for examining the mesh, including contouring and a Postscript hard-copy interface. DIME also runs on sequential machines.
Garnet: Comprehensive Support for Graphical, Highly Interactive User Interfaces
Authors: Brad A. Myers, Dario A. Giuse, Roger B. Dannenberg, David S. Kosbie, Edward Pervin, Andrew Mickish, Brad Vander Zanden, Philippe Marchal
Venue: Computer (1990)

The Garnet research project, which is creating a set of tools to aid the design and implementation of highly interactive, graphical, direct-manipulation user interfaces, is discussed. Garnet also helps designers rapidly develop prototypes for different interfaces and explore various user-interface metaphors during early product design. It emphasizes easy specification of object behavior, often by demonstration and without programming. Garnet contains a number of different components grouped into two layers. The Garnet Toolkit (the lower layer) supplies the object-oriented graphics system and constraints, a set of techniques for specifying the objects' interactive behavior in response to the input devices, and a collection of interaction techniques. On top of the Garnet Toolkit layer are a number of tools to make creating user interfaces easier. The components of both layers are described.
A fast algorithm for optimal length-limited Huffman codes
Authors: Lawrence L. Larmore, Daniel S. Hirschberg
Venue: Journal of the ACM (JACM) (1990)

An O(nL)-time algorithm is introduced for constructing an optimal Huffman code for a weighted alphabet of size n, where each code string must have length no greater than L. The algorithm uses O(n) space.
Exploiting variable grain parallelism at runtime
Authors: Anoop Gupta, Andrew Tucker
Venue: Proceedings of the ACM/SIGPLAN conference on Parallel programming: experience with applications, languages and systems (1988)

Currently, almost all parallel implementations of programs fix the granularity at which parallelism is exploited at design time. Depending on the application structure and the parallel hardware structure, the programmer decides to exploit parallelism at a fine granularity or coarse granularity or some intermediate granularity, but this granularity is not changed at runtime. In this paper we argue that for many applications fixing the granularity in advance is not a good strategy. Instead it is advantageous to decide the granularity at which parallelism is exploited at runtime, as a function of the available hardware resources and as a function of the overheads associated with going to a finer granularity. We present experimental results from a parallel implementation of a geometric constraint satisfaction system to support our thesis. Our results show a significant advantage in using adaptive parallelism.
g - A compact language for real-time graphics
Authors: W. Furmanski, D. Gates
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

We propose a medium level C-based language for computer graphics applications. The main objective is to provide real-time graphics (interactive video), hence the emphasis in the language design is on optimal speed of the machine code (to minimize system overheads) and on the compactness of the g code (so that no manuals are necessary). The language coexists and fully cooperates with C. The modular structure of the g data sector admits various programming models (sequential/concurrent, local/network extended). Portable design of the g compiler allows for various graphics configurations with adjustable speed/portability ratio. The compiler output is machine-independent &ldquo;machine&rdquo; code, to be explicitly interpreted on a given graphics device. The g programming environment consists of a g compiler (written in C), a portable (but slow) g interpreter (written in C) and a set of optimized interpreters for individual machines/devices (written in assembly).
A Bayesian/Monte Carlo Segmentation Method for Images Dominated by Gaussian Noise
Authors: Z. W. Bell
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

A description is given of a thresholding algorithm that rapidly separates foreground objects from background clutter in images whose dominant feature is zero-mean Gaussian noise. Such images have been found to occur in digital radiography applications in which manufactured parts are imaged by a solid-state camera. The motivation behind the algorithm is discussed in terms of the requirements of an imaging system for nearly-real-time radiography in an industrial environment. The individual steps of the process are described, and the robustness of the technique with respect to signal-to-noise ratio and with respect to object size is discussed.
Language and visualization support for large-scale concurrency
Authors: G.-C. Roman
Venue: Proceedings of the 10th international conference on Software engineering (1988)

SDL (Shared Dataspace Language) is a language for writing and visualizing programs consisting of thousands of processes executing on a highly-parallel multiprocessor. SDL is based on a model in which processes use powerful transactions to manipulate abstract views of a virtual, content-addressable data structure called the dataspace. The process society is dynamic and supports varying degrees of process anonymity. The transactions are executed over abstract views of the dataspace. This facilitates elegant conceptualization of dataspace transformations and compact program representation. Processes and transactions enable SDL to combine elements of both large and fine grained concurrency. The view is a novel abstraction mechanism whose significance is derived from the fact that it allows processes to interrogate the dataspace at a level of abstraction convenient for the task they are pursuing. The view also plays a role in the definition of continuously updated, programmer-defined visual abstractions which enable exploration of the program's functionality and performance.
Hierarchical scheduling in an intelligent environmental control system
Authors: Tag Gon Kim, Bernard P. Zeigler
Venue: Proceedings of the 2nd international conference on Industrial and engineering applications of artificial intelligence and expert systems - Volume 1 (1989)

This paper describes design and implementation of the hierarchical scheduling subsystem and graphical user interface in an intelligent environmental control system. The hierarchical scheduling system is capble of managing all environmental events occuring in widely different time scales as specified by the user. We employ a knowledge representation scheme called system entity structure to specify the environmental schedules in a hierarchical fashion. A system entity structure called TAL (Timed Action Language) is developed. TAL organizes a family of all possible long-/mid-/short-term schedules from which a specific schedule can be pruned by the user through graphical interface.
Parallel Communication in a Large Distributed Environment
Authors: Mahadev Satyanarayanan, Ellen H. Siegel
Venue: IEEE Transactions on Computers (1990)

The evolution of MultiRPC, a parallel remote procedure call mechanism implemented in Unix is described. Parallelism is obtained from the concurrency of processing on servers and from the overlapping of retransmissions and timeouts. Each of the parallel calls retains the semantics and functionality of the standard remote procedure calls. The underlying communication medium need not support multicast or broadcast transmissions. An analytic model of the system is derived and validated. The experimental observations demonstrate the feasibility of using MultiRPC to contact up to 100 servers in parallel.
Structural Stereopsis for 3-D Vision
Authors: K. L. Boyer, A. C. Kak
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1988)

A novel approach to solving the stereo correspondence problem in computer vision is described. Structural descriptions of two two-dimensional views of a scene are extracted by one of possibly several available low-level processes, and a new theory of inexact matching for such structures is derived. An entropy-based figure of merit for attribute selection and ordering is defined. Experimental results applying these techniques to real image pairs are presented. Some manipulation experiments are briefly presented.
TUNEX: A Knowledge-Based System for Performance Tuning of the UNIX Operating System
Authors: B. Samadi
Venue: IEEE Transactions on Software Engineering (1989)

TUNEX, an expert system developed for performance tuning of the UNIX operating system, is described. TUNEX was developed on UNIX system V. It uses the properties, commands and utilities of this version. The tuning activities it is concerned with include: (1) adjusting operating system tunable parameters, such as number of disk buffers; (2) running maintenance routines, i.e. reorganizing file systems; (3) developing operation rules, such as off-peak hour runs of backups; and (4) modifying hardware, buying an additional disk drive. The structure of TUNEX is presented and performance analysis modules which provide quantitative information to this tool are briefly described. The overhead in the resource usage introduced by the performance monitoring and tuning tool itself is discussed; the author points to the areas in which additional resources are required by TUNEX.
Optimizing programs over the constructive reals
Authors: Vernon A. Lee,  Jr., Hans-J. Boehm
Venue: Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation (1990)

The constructive reals provide programmers with a useful mechanism for prototyping numerical programs, and for experimenting with numerical algorithms. Unfortunately, the performance of current implementations is inadequate for some potential applications. In particular, these implementations tend to be space inefficient, in that they essentially require a complete computation history to be maintained. Some numerical analysts (cf. [3]) propose that the programmer instead be provided with variable precision interval arithmetic, and then be required to write code to restart a computation when the intervals become too inaccurate. Though this model is no doubt appropriate at times, it is not an adequate replacement for exact arithmetic. The correct transformation from a program operating on the constructive reals to a reasonable program using iterated interval arithmetic can be nontrivial and error prone. Here we present a technique based on program slicing to both automate this process and reduce the amount of reexecution. Thus the programmer is still free to use the simpler abstraction of exact real arithmetic, but we can provide a more efficient interval arithmetic based implementation. Some preliminary empirical results are presented.
A method for enumerating cosets of a group presented by a canonical system
Authors: N. Kuhn, K. Madlener
Venue: Proceedings of the ACM-SIGSAM 1989 international symposium on Symbolic and algebraic computation (1989)

The application of rewriting techniques to enumerate cosets of subgroups in groups is investigated. Given a class of groups G having canonical string rewriting presentations we consider the GWP for this class which is defined by GWP(w,U) iff w &isin; <U> for w &isin; G, finite U&sube;G, G &isin; G where <U> is the subgroup of G generated by U. We show how to associate to U two rewriting relations @@@@U and @@@@U on strings such that w &isin; <U> iff w @@@@U &lgr; iff w @@@@U &lgr; (&lgr; the empty word), both representing the left congruence generated by <U>. We derive general critical pair criteria for confluence and &lgr;-confluence for these relations. Using these criteria completion procedures can be constructed which enumerate cosets like the Todd-Coxeter algorithm without explicit definition of all cosets. The procedures are shown to be terminating if the index of the subgroup is finite or for groups with finite canonical monadic group presentations. If the completion procedure terminates it returns a prefix rewriting system which is confluent on &Sgr;*, thus deciding the GWP and the index problem for this class of groups. The normal forms of the rewriting relations form a minimal Schreier-representative system of <U> in G.
A fully abstract trace model for dataflow networks
Authors: B. Jonsson
Venue: Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1989)

A dataflow network consists of nodes that communicate over perfect FIFO channels. For dataflow networks containing only deterministic nodes, a simple and elegant semantic model has been presented by Kahn. However, for nondeterministic networks, the straight-forward generalization of Kahn's model is not compositional. We present a compositional model for nondeterministic networks, which is fully abstract, i.e., it has added the least amount of extra information to Kahn's model which is necessary for attaining compositionality. The model is based on traces.
A first course in program verification and the semantics of programming languages
Authors: Raymond D. Gumb
Venue: Proceedings of the twentieth SIGCSE technical symposium on Computer science education (1989)

We describe a first course in program verification and the semantics of programming languages developed for advanced undergraduate and beginning graduate students. The course is intended to support other courses in the curriculum that stress a disciplined approach to programming as well as to prepare students for more advanced courses in semantics and other areas such as software engineering and compiler technology. In order of emphasis, the course covers axiomatic, operational, translational, and denotational semantics. We discuss the development of the course, course prerequisites, the rationale for the selection of the topics covered, and the appropriateness of the course in the curriculum.
Optimul: An optional interconnect for multiprocessor systems
Authors: N. S. Matloff, S. Kowel, C. Eldering
Venue: Proceedings of the 2nd international conference on Supercomputing (1988)

An optical interconnect is proposed for multiprocessor systems, of both the tightly and loosely coupled types. This interconnect solves the problem of contention for memory and interconnect in the tightly coupled case, and the problem of network bottleneck in the loosely coupled case.