ppxscal/embedding_network huggingface dataset:
Semantics of a hardware design language for Japanese standardization
Authors: H. Yasuura, N. Ishiura
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

We propose a new approach to define a formal semantics of a hardware design language (HDL) in Japanese LSI design language standardization project. Our approach is to separate the definition of semantics from simulators. Since the semantics includes nondeterminism, we can describe vagueness of circuit behavior such as dispersion of delays without linguistic ambiguity. We introduce a new computation model of hardware behaviour called NES (Nondeterministic Event Sequence) model. NES model is a very simple model of the computation in digital systems and provides an intuitive understanding of concurrent behaviour of HDL description without loss of mathematical strictness.
Iconic shells for multitasking workstations
Authors: Michel Beaudouin-Lafon, Solange Karsenty
Venue: Proceedings of the 1988 ACM SIGSMALL/PC symposium on ACTES (1988)

Today's workstations running a multitasking operating system provide high level graphics toward user friendly interfaces. Microcomputers, on their side, implement graphic interfaces on monotasking operating systems. There are two differences between these machines: the operating system and the user interface to this operating system (the shell). Workstations still use standard shells (textual commands) but through a sophisticated graphic environment as a window manager, while microcomputers have their own graphic shell running on monotasking operating system. In this paper we examine the features of both systems and then we present an iconic shell developed for Unix&trade;@@@@ workstations. This shell differs from existing shells because the interaction language is based on graphic manipulations, and is integrated in a multitasking environment.
Improving the efficiency of the OSI checksum calculation
Authors: K. Sklower
Venue: ACM SIGCOMM Computer Communication Review (1989)

It is known that using larger byte--sizes to access memory usually results in faster computations of checksum algorithms. This paper proposes two different ways to use larger byte--sizes to improve the performance of the OSI checksum. First, an algorithm is presented that computes the 8--bit checksum using 16-bit integers. It is shown that this algorithm yields a 5 to 20 percent performance improvement on many architectures. Second, the benefits of expanding the basic computation unit of the OSI checksum algorithm to 16--bits integers is considered. This change can yield an additional performance improvement of up to 50% and greatly extended error detection properties, although it is incompatible with the current standard. The measurements of these algorithms are compared with some taken of checksums in common use, such as IP and XNS dagger;.
Heuristic evaluation of user interfaces
Authors: Jakob Nielsen, Rolf Molich
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Empowering people (1990)

Heuristic evaluation is an informal method of usability analysis where a number of evaluators are presented with an interface design and asked to comment on it. Four experiments showed that individual evaluators were mostly quite bad at doing such heuristic evaluations and that they only found between 20 and 51% of the usability problems in the interfaces they evaluated. On the other hand, we could aggregate the evaluations from several evaluators to a single evaluation and such aggregates do rather well, even when they consist of only three to five people.
A mechanism for environment integration
Authors: Geoffrey Clemm, Leon Osterweil
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1990)

This paper describes research associated with the development and evaluation of Odin-an environment integration system based on the idea that tools should be integrated around a centralized store of persistent software objects. The paper describes this idea in detail and then presents the Odin architecture, which features such notions as the typing of software objects, composing tools out of modular tool fragments, optimizing the storage and rederivation of software objects, and isolating tool interconnectivity information in a single centralized object. The paper then describes some projects that have used Odin to integrate tools on a large scale. Finally, it discusses the significance of this work and the conclusions that can be drawn about superior software environment architectures.
A model solution for the C3I Domain
Authors: C. Plinta, K. Lee
Venue: Proceedings of the conference on Tri-Ada '89: Ada technology in context: application, development, and deployment (1989)

This paper1 briefly describes a specific portion of recent work performed by the Domain Specific Software Architecture (DSSA) Project at the Software Engineering Institute (SEI) &mdash; the development and use of a model solution for message translation and validation in the C3I domain. Based on this experience and our involvement with programs in the C3I domain, future considerations are described. These considerations involve identifying potential models within a domain and making recommendations for developing and documenting model solutions which will enable the models to be reused.
The coupling effect: fact or fiction
Authors: A. Offutt
Venue: ACM SIGSOFT Software Engineering Notes (1989)

Fault-based testing strategies test software by focusing on specific, common types of errors. The coupling effect states that test data sets that detect simple types of faults are sensitive enough to detect more complex types of faults. This paper describes empirical investigations into the coupling effect over a specific domain of software faults. All the results from this investigation support the validity of the coupling effect. The major conclusion from this investigation is that by explicitly testing for simple faults, we are also implicitly testing for more complicated faults. This gives us confidence that fault-based testing is an effective means of testing software.
On data synchronization for multiprocessors
Authors: H.-M. Su, P.-C. Yew
Venue: ACM SIGARCH Computer Architecture News (1989)

As the grain size becomes smaller, more parallelism can be found in most programs. However, to exploit smaller grain parallelism, more efficient synchronization primitives are needed to reduce the increased synchronization overhead. The granularity of parallelism that can be exploited on a multiprocessor system depends heavily on the type and the efficiency of the synchronization supported by the system. For medium-grain parallelism, ordered dependencies such as data dependencies and control dependencies need to be enforced in order to guarantee the correctness of the parallel execution. Hence, data synchronization is one of the major sources of synchronization overhead in the program execution. In this paper, we classify the synchronization schemes based on how synchronization variables are used. A new scheme, the process-oriented scheme, is proposed. This scheme requires a very small number of synchronization variables and can be supported very efficiently by simple hardware in the system.
Design Recovery for Maintenance and Reuse
Authors: Ted J. Biggerstaff
Venue: Computer (1989)

Software maintenance and harvesting reusable components from software both require that an analyst reconstruct the software's design. Design recovery recreates design abstractions from a combination of code, existing design documentation (if available), personal experience and general knowledge about problem and application domains. The author shows how to extend the automated assistance available to the software engineer for this process. He explains the concept of design recovery, proposes an architecture to implement the concept, illustrates how the architecture operates, describes progress toward implementing it, and compares this work with other similar work such as reverse engineering and program understanding. Much of the discussion is based on a model-based design recovery system called Desire.
An expert system for a retargetable peephole optimizer
Authors: J. W. Warfield, H. R. Bauer,  III
Venue: ACM SIGPLAN Notices (1988)

Peephole optimization is the process of improving object code produced by a compiler. The optimizer replaces one or several computer instructions with an instruction which is faster or shorter. Retargetable peephole optimizers work on different machines with minor changes. Previous work has automated the process of developing retargetable peephole optimizers given descriptions of machine instructions. Techniques presented here use an expert system for the task of learning which instructions may be optimized using the descriptions of the computer instructions. The expert system simplifies the task of combining and searching instructions. This project was successful in demonstrating that an expert system may be used for a retargetable peephole optimizer. The expert system may be retargeted to another computer by changing the descriptions of the instructions and the descriptions of the addressing modes. The expert system can also handle pairs of branch instructions and special addressing modes with side effects. The amount of work required for a programmer to build and maintain a retargetable peephole optimizer is reduced using an expert system.
The role of knowledge management in hierarchical model development
Authors: Y.-M. Huang, J. W. Rozenblit, J. Hu
Venue: Proceedings of the 21st conference on Winter simulation (1989)

The methods for transforming real-world problem into simulation models are being increasingly explored with the availability of inexpensive computing power. In general, traditional model building procedures involve a lengthy problem formulation and interaction between the analyst and the client. Furthermore, after the model definition is arrived at, the simulation model is often programmed manually. Recent developments in simulation modeling have focused on automatic model generation employing artificial intelligence (AI) techniques. Such developments focus on the transfer of the user's knowledge about the system into an executable simulation model. Current techniques still lack effective knowledge acquisition tools and a global database from which model alternatives can be generated. In this paper, a set of knowledge bases (KBs) will be proposed to aid in the hierarchical model construction.
User interface design in large corporations: coordination and communication across disciplines
Authors: J. Grudin, S. E. Poltrock
Venue: ACM SIGCHI Bulletin (1989)

This report describes some of the results of a survey constructed to address the multidisciplinary, collaborative nature of user interface design as it is practiced in large software development organizations today. Survey forms were prepared for Software Engineers, Human Factors Engineers, Industrial Design Engineers, Technical Writers, Training Developers, and Marketing representatives. The survey was filled out by over 200 designers from multiple sites within 7 large companies. Previous interview studies of user interface design have relied on far smaller samples taken primarily from single organizations, and have focused on the individual designer's perspective, primarily that of programmers or software engineers. While surveys have limitations as information-gathering tools, the findings in this report suggest specific places where organizational change or tool development might improve the coordination or communication among the different professionals and managers who contribute to interface design in large company settings.
The head and the heart: using gender analysis to study the social construction of computer systems
Authors: Joan Greenbaum
Venue: ACM SIGCAS Computers and Society (1990)

In recent years there has been a good deal of healthy experimentation with system development methods and work organization, particularly within Scandinavia. This paper attempts to go further into the questions of the development and use of computer systems by using a gender analysis of the issues. Specifically, it examines the organization of labor and patterns of communication used in developing computer systems. It suggests that the use of gender-biased dichotomies strongly influences both the questions system developers ask and the way questions are asked.
A knowledge-based simulator for electronic circuits
Authors: Jurgen Herczeg, Michael Herczeg
Venue: ACM SIGSIM Simulation Digest (1988)

The following paper describes a prototypical knowledge-based simulator for electronic circuits supporting the user during various phases of the task. The system has been built by augmenting an object-oriented modelled simulator by direct manipulation techniques and by representing knowledge about the simulation process and the application domain in an expert component. The direct manipulation interface enables the user to manipulate the familiar objects of an electronics laboratory via a mouse on the screen. The expert component provides adequate simulation parameters, answers questions about the application domain, and gives examples and partial solutions concerning the user's current problem.
Spatial Classification Using Fuzzy Membership Models
Authors: J. T. Kent, K. V. Mardia
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1988)

In the usual statistical approach to spatial classification, it is assumed that each pixel belongs to precisely one of a small number of known groups. This framework is extended to include mixed-pixel data; then, only a proportion of each pixel belongs to each group. Two models based on multivariate Gaussian random fields are proposed to model this fuzzy membership process. The problems of predicting the group membership and estimating the parameters are discussed. Some simulations are presented to study the properties of this approach, and an example is given using Landsat remote-sensing data.
Extensions to the object paradigm for the development of distributed applications
Authors: L. Heuser, A. Schill, M. Mühlhäuser
Venue: Proceedings of the 1988 ACM SIGPLAN workshop on Object-based concurrent programming (1988)

Current distributed object oriented languages and systems hide distribution in general while retaining the ability to control object locations explicitly. These approaches seem adequate but are exclusively focussing on the implementation stage of a distributed application. We present a new foundation for the development of distributed object oriented applications focussing on the design stage. Its main characteristics are: all aspects of linguistic support can be introduced, special issues, especially mobility and cooperation, can be integrated, tight integration of linguistic and CASE (Computer Aided Software Engineering) support can be achieved, only one formalism is used throughout all of the above can be expressed at design level as opposed to source code level. In the paper, we will focus on two important aspects of distributed object oriented systems requiring special design support: mobility and cooperation (see below).
Application of a self tuner using fuzzy control technique
Authors: C. Batur
Venue: Proceedings of the 2nd international conference on Industrial and engineering applications of artificial intelligence and expert systems - Volume 1 (1989)

A self-tuning expert fuzzy controller has been developed and applied in real time to a process control problem. As in other expert systems, the knowledge base consists of rules describing the control law in terms of the process error and the resulting control action. Conditions and conclusions of each rule are fuzzy variables which are described through their membership curves. The inference engine used is the backward chaining process of the Prolog language. To implement the self-tuning property, the membership curve of the controller output has been changed according to an error based performance index. A control supervisor makes this tuning decision as a function of past or predicted future set-point errors of the control system. To verify the viability of this fuzzy controller, it has been applied to control the speed of a DC motor operating under different loading conditions. The paper also discusses the stability problems associated with this control scheme.
Partition semantics for incomplete information in relational databases
Authors: D. Laurent, N. Spyratis
Venue: ACM SIGMOD Record (1988)

We define partition semantics for databases with incomplete information and we present an algorithm for query processing in the presence of incomplete information and functional dependencies. We show that Lipski's model for databases with incomplete information can be seen as a special case of our model.
Binary-decision and RISC-like machines for semicustom design
Authors: C. Piguet
Venue: Microprocessors Microsystems (1990)

The paper shows that some ASICs can be designed successfully as RISC-like machines. Instead of choosing a random logic approach or 4- to 8-bit microprocessors to implement microcontrollers, a RISC-like microcontroller is often a better solution. Some industrial examples realized in silicon demonstrate that RISC-like architectures for ASICs are not only an academic but also a working concept. Another interesting point is the original path followed to obtain RISC microcontrollers: it starts from finite state machines and binary-decision machine theory. The paper demonstrates this method by describing industrial examples of such machines. &mdash;From the Author's Abstract
Derivative estimates from discontinuous realizations: smoothing techniques
Authors: P. Glasserman, W.-B Gong
Venue: Proceedings of the 21st conference on Winter simulation (1989)

We develop two methods for estimating derivatives of expectations from simulation of functions whose realizations are discontinuous in the parameter of differentiation. We take as motivating example the estimation of the sensitivity of expected terminal reward for processes on discrete state spaces. Both our methods use conditional expectations to smooth discontinuites. The first smooths the dependence on the differentiation parameter, while the second smooths dependence on the time parameter. The methods are illustrated through examples, including stochastic networks, networks of queues, and Markov processes.
A neural network design for circuit partitioning
Authors: J.-S. Yih, P. Mazumder
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

This paper proposes a neural network model for circuit bipartitioning. The massive parallelism of neural nets has been successfully exploited to balance the partitions of a circuit and to reduce the external wiring between the partitions. The experimental results obtained by neural nets are found to be comparable with that achieved by Fiduccia and Mattheyses algorithm.
Type substitution for object-oriented programming
Authors: Jens Palsberg, Michael I. Schwartzbach
Venue: ACM SIGPLAN Notices (1990)

Genericity allows the substitution of types in a class. This is usually obtained through parameterized classes, although they are inflexible since any class can be inherited but is not in itself parameterized. We suggest a new genericity mechanism, type substitution, which is a subclassing concept that complements inheritance: any class is generic, can be &ldquo;instantiated&rdquo; gradually without planning, and has all of its generic instances as subclasses.
Transformation approach for consistency in object-oriented knowledge bases
Authors: Hsin-Hsen Yao, Hwa Soo Kim
Venue: Issue 109 (July 1989) (1989)

A knowledge base is consistent if all its data, information, or knowledge (regardless they are stored in database or implied by inference engine) satisfy the predefined constraints which represent a real world rules or restrictions. Maintaining knowledge consistency in an object-oriented knowledge base is difficult since (i) two data items in the knowledge base may have the relationship that is not explicitly represented by the inheritance; and (ii) logic programming trends to manipulate "flat" data. In contrast, it is easier to develp a mechanism for maintaining the consistency in a value-oriented system (e.g., relational database or logic programming) [Ullm87].
Applications experience with Linda
Authors: Nicholas Carriero, David Gelernter
Venue: Proceedings of the ACM/SIGPLAN conference on Parallel programming: experience with applications, languages and systems (1988)

We describe three experiments using C-Linda to write parallel codes. The first involves assessing the similarity of DNA sequences. The results demonstrate Linda's flexibility&mdash;Linda solutions are presented that work well at two quite different levels of granularity. The second uses a prime finder to illustrate a class of algorithms that do not (easily) submit to automatic parallelizers, but can be parallelized in straight-forward fashion using C-Linda. The final experiment describes the process lattice model, an &ldquo;inherently&rdquo; parallel application that is naturally conceived as multiple interacting processes. Taken together, the experience described here bolsters our claim that Linda can bridge the gap between the growing collection of parallel hardware and users eager to exploit parallelism. This work is supported by the NSF under grants DCR-8601920 and DCR-8657615 and by the ONR under grant N00014-86-K-0310. We are grateful to Argonne National Labs for providing access to a Sequent Symmetry.
Dynamic multipaging in even less space
Authors: T. H. Merrett, Louis Hamel
Venue: ACM SIGMOD Record (1988)

We present an improvement to the directory structure of dynamic multipaging which reduces the overall storage requirement from The outstanding advantage of multipaging is that it provides multi-attribute access to a database file using directories of negligible size. The present improvement makes the directory size even more negligible and the addressing algorithm easier.
InterNote: extending a hypermedia framework to support annotative collaboration
Authors: T. Catlin, P. Bush, N. Yankelovich
Venue: Proceedings of the second annual ACM conference on Hypertext (1989)

Based on three years of user feedback, a design team at IRIS embarked on a project to enhance Intermedia to better support small groups of collaborators, particularly those involved with document review and revision. Towards this end, we defined user-level requirements for the new functionality. The result of this process was the design and implementation of InterNote. One aspect of InterNote involves a fundamental extension to Intermedia's navigational linking paradigm. Instead of simply being able to traverse links, users are now also able to transfer data across the links using a technique we call warm linking. In this paper we describe extensions to our hypermedia framework to support annotative collaboration, including the user interface of the new linking functionality and the InterNote extension. Finally, we discuss our plans for future work.