ppxscal/embedding_network huggingface dataset:
Sherlock&mdash;a system for diagnosing power distribution ring network faults
Authors: Kit Po Wong, Chi Ping Tsang, Wan Yee Chan
Venue: Proceedings of the 1st international conference on Industrial and engineering applications of artificial intelligence and expert systems - Volume 1 (1988)

This paper reports the development of a software system, SHERLOCK, for fault diagnosis in power distribution ring networks. The system consists of a fault diagnosis subsystem implemented using Prolog and a user interface subsystem developed in the SmallTalk environment. This paper first gives an account of faults which may occur in distribution ring networks together with the fault symptoms and hidden defects. It then summarizes the general fault diagnosis rules. The methods of representation of network, faults, symptoms and defects are developed and the search procedure for searching the network busbars in the fault diagnosis process is outlined. This subsystem can be accessed by operation engineers through the user interface subsystem which displays in graphical form the network and the fault solutions generated. The usefulness of SHERLOCK is illustrated by its application to an 11kV 3-leg ring network.
On the computation of syzygies
Authors: B. Wall
Venue: ACM SIGSAM Bulletin (1989)

This paper deals with the computation of syzygies for a set of polynomials simultaneously with the computation of a Gr ouml;bner basis for these polynomials. It is shown that a criterion to avoid unneccessary reductions during the Gr ouml;bner basis algorithm can also be used in this case.
Performance Analysis of Dynamic Locking with the No-Waiting Policy
Authors: In Kyung Ryu, Alexander Thomasian
Venue: IEEE Transactions on Software Engineering (1990)

A transaction processing system with two-phase dynamic locking with the no waiting policy (DLNW) for concurrency control is considered. In this method, transactions making conflicting lock requests are aborted and restarted rather than blocked, thereby eliminating blocking delays (and deadlocks), but making it susceptible to cyclic restarts. Cyclic restarts are dealt with by delaying the restart of a transaction encountering a lock conflict or replacing it with a new transaction. Analytic solution methods for evaluating the performance of the variants of the DLNW method are described. The analytic methods, validated against simulation and shown to be acceptably accurate, are used to study the effect of the following parameters on system performance: transaction size and its distribution, degree of concurrency, the throughput characteristic of the computer system, and the mixture of read-only query and update transactions. A comparison of the DLNW and dynamic locking with waiting (DLW) methods shows that DLW provides higher throughput than DLNW, except when there is no hardware resource contention and conflicted transactions can be replaced by new transactions. The DLNW method outperforms the time-stamp ordering method, as observed from simulation results as well as case by case analyses of possible scenarios.
A New Set of Constraint-Free Character Recognition Grammars
Authors: L. Stringa
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1990)

A general pattern-recognition procedure for application to unconstrained alphanumeric characters is presented. The procedure is designed to allow hierarchical redescription of the input images in terms of significant elements only, and formal developments are given within the framework of elementary phrase-structure grammars. The extraction of the primitives associated with the terminal vocabularies of the grammars is always deterministic, and the productions of the parsers are characterized by a significant degree of topological fidelity. Preliminary experimental results indicate recognition rates comparable to the state of the art, but with a considerable reduction in computing time.
Aspects of OBERON suitable for graphics applications
Authors: V. Milanese
Venue: ACM SIGPLAN Notices (1989)

The requirement of complex data structures and efficient algorithms are strictly connected in graphics. The use of languages suitable for facing such need has led to sophistacated programming techniques (functional, logical, object programming). Also procedural programming, however, can provide idoneous tools to handle complex data models, which are realized according to modern criteria of software development.
The constraint method of attrition
Authors: D. S. Hartley,  III
Venue: Proceedings of the 21st conference on Winter simulation (1989)

Helmbold demonstrated a relationship between a ratio containing initial force sizes and casualties, herein called the Helmbold ratio, and the initial force ratio in a large number of historical battles. This paper examines some of the complexity of the Helmbold ratio using analytical and simulation techniques and demonstrates that a constraint model of attrition captures some aspects of historical data. The effect that the constraint model would have on warfare modeling is uncertain. However, some speculation has been attempted concerning its use in large scale simulations.
Detectors for quantitative voltage contrast on submicron devices
Authors: A. R. Dinnis
Venue: Microelectronic Engineering (1988)

Conventional voltage-contrast electron energy analysers give accurate results on reasonably large clean metal specimens. The high fields and small dimensions of sub-micron devices make it difficult to achieve accurate and reliable results with such conventional lens and detector arrangements. Recent techniques to overcome these problems are explained and a new design of detector is put forward.
On optimal loop parallelization
Authors: F. Gasperoni, U. Schwiegelshohn, K. Ebcioğlu
Venue: Proceedings of the 22nd annual workshop on Microprogramming and microarchitecture (1989)

The problem of automatic loop parallelization has received a lot of attention in the area of parallelizing compilers. Automatic loop parallelization can be achieved by several algorithms. In this paper we address the problem of time optimal parallelization of loops with conditional jumps. We prove that even for machines with unlimited resources there are simple loops for which no semantically and algorithmically equivalent time optimal program exists.
Characterizing the synchronization behavior of parallel programs
Authors: Helen Davis, John Hennessy
Venue: Proceedings of the ACM/SIGPLAN conference on Parallel programming: experience with applications, languages and systems (1988)

Contention for synchronization locks and delays waiting for synchronization events can substantially increase the running time of a parallel program. This makes it important to characterize the synchronization behavior of programs and to provide analysis tools to aid both the hardware and software designer in evaluating design alternatives. This paper describes a tracing facility that is incorporated into a synchronization package. This facility provides a portable means to accurately and efficiently characterize parallel programs. The behavior of several applications has been monitored uncovering program characteristics that make it difficult to achieve linear speedup. Our monitoring facility allows a programmer to determine the performance implications of the synchronization structure he has used, and it allows the architect to evaluate various hardware support mechanisms.
Minimizing register usage penalty at procedure calls
Authors: F. C. Chow
Venue: ACM SIGPLAN Notices (1988)

Inter-procedural register allocation can minimize the register usage penalty at procedure calls by reducing the saving and restoring of registers at procedure boundaries. A one-pass inter-procedural register allocation scheme based on processing the procedures in a depth-first traversal of the call graph is presented. This scheme can be overlaid on top of intra-procedural register allocation via a simple extension to the priority-based coloring algorithm. Using two different usage conventions for the registers, the scheme can distribute register saves/restores throughout the call graph even in the presence of recursion, indirect calls or separate compilation. A natural and efficient way to pass parameters emerges from this scheme. A separate technique uses data flow analysis to optimize the placement of the save/restore code for registers within individual procedures. The techniques described have been implemented in a production compiler suite. Measurements of the effects of these techniques on a set of practical programs are presented and the results analysed.
Totally Self-Checking Checkers with Separate Internal Fault Indication
Authors: N. Gaitanis
Venue: IEEE Transactions on Computers (1988)

The design of a novel class of totally self-checking (TSC) checkers with two separate output indications E/sub N/ and F/sub N/ is described. F/sub N/ is independent of input errors and indicates internal faults only. On the other hand, the output E/sub N/ indicates input errors as well as a small number of internal faults. This design technique, while improving the maintainability of the TSC networks that locate the fault in the functional circuit or in the checker itself, also increases the correct response probability of the error indication output E/sub N/. The TSC checkers presented utilize redundant copies of a given normal TSC checker which are monitored by a TSC reduction circuit operating like a TSC vote taker. The TSC reduction circuits can be easily designed using an algebraic approach based on a two-element Boolean algebra with a more efficient set of self-checking operator blocks.
Customization: optimizing compiler technology for SELF, a dynamically-typed object-oriented programming language
Authors: C. Chambers, D. Ungar
Venue: ACM SIGPLAN Notices (1989)

Dynamically-typed object-oriented languages please programmers, but their lack of static type information penalizes performance. Our new implementation techniques extract static type information from declaration-free programs. Our system compiles several copies of a given procedure, each customized for one receiver type, so that the type of the receiver is bound at compile time. The compiler predicts types that are statically unknown but likely, and inserts run-time type tests to verify its predictions. It splits calls, compiling a copy on each control path, optimized to the specific types on that path. Coupling these new techniques with compile-time message lookup, aggressive procedure inlining, and traditional optimizations has doubled the performance of dynamically-typed object-oriented languages.
A top down unification of minimum cost spanning tree algorithms
Authors: S. M. Merritt
Venue: ACM SIGCOMM Computer Communication Review (1989)

The problem of the design of communications networks has spawned the development of many of the algorithms currently used to solve the minimum cost spanning tree problem. We show that three minimum cost spanning tree algorithms, those by Kruskal, Prim, and Esau and Williams, can be derived from a single problem specification using &ldquo;specification and transformation by parts,&rdquo; a methodology for deriving families of algorithms. This approach is an alternative to the Kershenbaum and Chou unification of spanning tree algorithms. Whereas the Kershenbaum Chou approach might be called bottom up, this is a top down approach which shows the original unity of the algorithms which emerges from the statement of the problem and also the essential differences. Besides pedagogical and aesthetic value, we maintain that an understanding of the algorithms from this perspective may be helpful in network design and modification.
What is to become of programming?
Authors: William Mitchell
Venue: ACM SIGCSE Bulletin (1989)

CS1 and CS2 have been revised and currently ACM is exploring the revision of the CS core. General dissatisfaction has been broadly voiced with Curriculum '78 as not being sufficiently mathematical and theoretical. In the same vein the accreditation criteria have been attacked as being too technical and vocational. A strong voice has been raised for a liberal arts view of computer science. Recent texts are incorporating a higher level of abstraction into the freshman year as well as trying to cater to a demand for a survey of the discipline. Does this portend a decline in programming skill? Who will write code in the future? What will be their knowledge and aesthetics? This paper cannot answer all these questions, but it does develop a near-term approach to presenting programming more efficiently in the undergraduate CS curriculum and it suggests that the discipline needs to give some thought to its technology.
Model management and structured modeling: the role of an information resource dictionary system
Authors: D. R. Dolk
Venue: Communications of the ACM (1988)

Models have historically occupied an ambiguous position within organizations. Management acceptance of management science and operations research models for decision-making has lagged far behind technical advances in these areas. Structured modeling has emerged as a unifying approach to the modeling process with potential to reduce this ambiguity. Structured modeling is primarily oriented to the individual, however. A way of incorporating structured modeling into the organizational framework via existing information resource channels is discussed. A relational model is presented for an information resource dictionary system (IRDS). This IRDS model is then extended to accommodate representation of structured models. This extension of the IRDS can answer queries about structured modeling as well as model instances. The concept of an active IRDS is introduced and an example presented of how an active IRDS can be linked with an optimization algorithm. The conclusion is that the IRDS is a suitable vehicle for incorporating model management and structured modeling as part of an organization's information resource management environment.
A locally modifiable VMS reference guide
Authors: J. E. St. Sauver
Venue: Proceedings of the 17th annual ACM SIGUCCS conference on User Services (1989)

This paper describes the design and production of a comparatively brief, readily modifiable VAX/VMS reference guide use by faculty, student and staff on the University of Oregon's academic VAX Cluster.
A System for Specification and Rapid Prototyping of Application Command Languages
Authors: Jan Stelovsky, Hirotsugu Sugaya
Venue: IEEE Transactions on Software Engineering (1988)

The XS-2 system that integrates specification, rapid prototyping, and the actual use of application dialogs is described. The XS-2 command language grammar, a nonprocedural description language based on regular expressions, is used to specify commands for any application program. The syntax of the command specification is visible to the user: command names and their activation rules are displayed as a command tree. Since a small set of tools is provided for the development of the command specification and its automatic translation into a prototype application module in Modula-2, no programming work is necessary to design and evaluate the commands. Experience shows that an advanced end user can develop his or her own prototype application without a programmer's assistance.
An improved algorithm to find the length of the longest common subsequence of two strings
Authors: S. Kuo, G. R. Cross
Venue: ACM SIGIR Forum (1989)

Let A and B be strings of common length n. Define LLCS(A, B) to be the length of the longest common subsequence of A and B. Hunt and Szymanski presented an algorithm for finding LLCS(A, B) with time complexity O((r + n)logn), where r is the number of elements in the set {(i, j)|A[i] = B[j]}. In the worst case the algorithm has running time of O(n2logn). We present an improvement to this algorithm which changes the time complexity to O(r + n(LLCS(A, B) + logn)). Some experimental results show dramatic improvements for large n.
A high-speed message-driven communication architecture
Authors: J. Peterson, E. Chow, H. Madan
Venue: Proceedings of the 2nd international conference on Supercomputing (1988)

The performance of a message-passing multiple instruction multiple data (MIMD) concurrent computer depends in large part on the communication processing overhead. A high-speed communication architecture is proposed for a hypercube-type supercomputer to attain the specific goals of message-driven processing. These goals include: direct hardware execution of messages, queueing of messages (using various paradigms), adaptive message routing, and special local registers for fast context switching. A hyperswitch network capable of high-speed switching is used to perform message routing. Available communication paths are pruned by the routing algorithm in response to congestion within the network to evaluate the best-first available path between any two nodes. Simulation results show that this architecture reduces message reception latency by two to three orders of magnitude when compared to commercial hypercube systems. This communication architecture extends the application of parallel systems to supercomputer problems that place heavy demand on the communication network for high bandwidth, low latency, and non-local communication. Detailed simulation studies for the proposed communication architecture are presented.
The increasing role of computer theory in undergraduate curricula
Authors: Donald J. Bagert,  Jr., Daniel I. A. Cohen, Gary Ford, Donald K. Friesen, Daniel D. McCracken
Venue: ACM SIGCSE Bulletin (1988)

CSAB states in its guidelines that one of its six undergraduate core curriculum subject areas is computer theory. It appears that the ACM Core Curriculum Committee will also suggest a core course in this area. However, courses in computer theory, under the titles &ldquo;Formal Languages&rdquo; or &ldquo;Theory of Computation&rdquo;, have traditionally been taught on the senior or graduate level. There has been little discussion concerning the development of a computer theory course for use at the sophomore or junior level. Also, computer theory is also becoming a larger part of other computer science courses such as discrete structures and compiler design theory. A clearer understanding is needed of how different aspects of computer theory should be developed throughout the undergraduate computer science curriculum.
The adaptable user interface
Authors: Eliezer Kantorowitz
Venue: Communications of the ACM (1989)

A single adaptable user interface (AUI) which allows the user to switch between any number of different dialogue modes at any time&mdash;even in the middle of a command&mdash;can be useful to a variety of users who are neither beginners nor experts. It can also be used in applications where different dialogue modes are appropriate for the various parameters of a single command. An implemented user interface management system (UIMS) suggests the practicality of AUIs and their automatic generation.
Extended microcode error checking on a pipelined machine
Authors: L. A. Kovacs, S. F. Gilli
Venue: Proceedings of the 22nd annual workshop on Microprogramming and microarchitecture (1989)

In a pipelined computer, there is a possibility of interaction between microwords. These interactions may cause the operation of the computer to slow down, or they may cause errors. An extended error checking tool is used to detect these cases and help the microcode be more correct and more efficient.
Toward a non-atomic era: l-exclusion as a test case
Authors: Danny Dolev, Eli Gafni, Nir Shavit
Venue: Proceedings of the twentieth annual ACM symposium on Theory of computing (1988)

Most of the research in concurrency control has been based on the existence of strong synchronization primitives such as test and set. Following Lamport, recent research promoting the use of weaker primitives, &ldquo;safe&rdquo; rather than &ldquo;atomic,&rdquo; has resulted in construction of atomic registers from safe ones, in the belief that they would be useful tools for process synchronization. We argue that the properties provided by atomic operations may be too powerful, masking core difficulties of problems and leading to inefficiency. We therefore advocate a different approach, to skip the intermediate step of achieving atomicity, and solve problems directly from safe registers. Though it has been shown that &ldquo;test and set&rdquo; cannot be implemented from safe registers, we show how to achieve a fair solution to l-exclusion, a classical concurrency control problem previously solved assuming a very powerful form of atomic &ldquo;test and set&rdquo;. We do so using safe registers alone and without introducing atomicity. The solution is based on the construction of a simple novel non-atomic synchronization primitive.
Graphic design tips for desktop publishers
Authors: Kenneth E. Gadomski
Venue: Proceedings of the 16th annual ACM SIGUCCS Conference on User Services (1988)

Since the introduction of the Macintosh, the LaserWriter, and PageMaker and the subsequent ability to create camera-ready or near-camera-ready documents on our desktops, document writers have found it necessary to become document designers as well. Yet, this entails a number of choices. For example, what style or size of type? How many columns? Where should headings be placed? Should there be illustrations? If so, how should they be arranged? Because most of us haven't been trained to make these choices, too often the result is badly designed and ineffective documents. However, by understanding some of the basic principles of graphic design, even design novices can use a desktop publishing system to improve the way their documents look and, more importantly, make them more readable and more understandable. Research has shown that certain design techniques dramatically expand a reader's capacity for information. In this session I will offer a number of simple design guidelines for creating effective desktop published documents and avoiding the common design pitfalls of overzealous desktop publishers without design training. Using before and after examples, I will discuss the graphic design choices available to desktop publishers and explain the best choices. Topics will include choosing and using type styles and sizes, column width, capitals and italics, alignment, leading, word and letter spacing, white space, and balance to create effective memos, brochures, manuals, flyers, and newsletters. Good graphic design is more than a simple list of do's and don'ts. By explaining the reasons for certain design choices, I hope that those who attend this session will leave with a basic understanding of graphic design that they can use as a resource when designing their own desktop-published documents and as a basis for further study in graphic design if they are interested.
The acquisition, verification, and explanation of design knowledge
Authors: C. Kellogg, R. A. Gargan,  Jr., W. Mark, J. G. McGuire, M. Pontecorvo, J. L. Schlossberg, J. w. Sullivan, M. R. Genesereth, N. Singh
Venue: Issue 108 (April 1989) (1989)

Researchers from Lockheed and Stanford University are currently engaged in a joint project investigating the acquisition of design knowledge to aid in the modification and reuse of designs. In our approach acquisition, verification, and explanation are integral components of the design capture process. We are using the HELIOS digital design system (developed at Stanford) as a framework for experimenting with knowledge acquisition and explanation tools. These tools will be used to capture design rationale directly from the expert as the design evolves. Verification capabilities are also being developed to validate design specifications and explore the consequences of various design alternatives.