ppxscal/embedding_network huggingface dataset:
A semantic and logical front-end to a database system
Authors: M Rajinikanth, P K Bose
Venue: Proceedings of the ACM SIGART international symposium on Methodologies for intelligent systems (1986)

This paper presents an approach to extending the relational system RTMS into one supporting a frame-based knowledge-representation system. A deductive front-end is used for extraction of implicit information from the explicit data stored in RTMS. The proposed extensions to the relational model include the relationships of aggregation and generalization, set-valued attributes, and virtual relations defined using axioms. We will present a query language that takes advantage of these extensions. A user can make a query against virtual relations as well as base relations. The queries can consist of new constructs introduced by the semantic front-end. The system is implemented on TI's Explorer Lisp Machine.
Distributed match-making for processes in computer networks
Authors: Sape J Mullender, Paul M B Vitanyi
Venue: ACM SIGOPS Operating Systems Review (1986)

In the very large multiprocessor systems and, on a grander scale, computer networks now emerging, processes are not tied to fixed processors but run on processors taken from a pool of processors. Processors are released when a process dies, migrates or when the process crashes. In distributed operating systems using the service concept, processes can be clients asking for a service, servers giving a service or both. Establishing communication between a process asking for a service and a process giving that service, without centralized control in a distributed environment with mobile processes, constitutes the problem of distributed match-making. Logically, such a match-making phase precedes routing in store-and-forward computer networks of this type. Algorithms for distributed match-making are developed and their complexity is investigated in terms of message passes and in terms of storage needed. The theoretical limitations of distributed match-making are established, and the techniques are applied to several network topologies.
A course in computer systems planning
Authors: Karl Rehmer
Venue: Proceedings of the eighteenth SIGCSE technical symposium on Computer science education (1987)

Those aspects of computer science dealing with the selection of computer hardware, the selection of computer software, the tradeoffs between in-house development and purchase, the transition to a new system, computer performance evaluation, and computer center management are not covered or are covered very lightly in an undergraduate curriculum. This paper presents the evolution and content of a senior-level course on these subjects taught at Indiana-Purdue at Fort Wayne.
Perspectives in deductive databases (Abstract only)
Authors: J. Minker
Venue: Proceedings of the sixth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1987)

I will discuss my experiences, some of the work that I have done and related work that influenced me, concerning deductive databases over the last 30 years. It will be convenient to divide this time period into roughly three equal parts, 1957 - 1968, 1969 - 1978, 1979 - present. For the first portion I will describe how my interest started in deductive databases in 1957, at a time when not even the field of databases existed I will describe work in the beginning years, leading to the start of deductive databases in about 1968 with the work of Cordell Green and Bertram Raphael. The second period saw a great deal of work in theorem proving as well as the introduction of logic programming. The existence and importance of deductive databases as a formal and viable discipline received its impetus at a workshop held in Toulouse, France, in 1977, which culminated in the book, Logic and Data Bases. The relationship of deductive databases and logic programming was recognized at that time. During the third and most recent period we have seen formal theories of databases come about as an outgrowth of that work, and the recognition that artificial intelligence and deductive databases are closely related, at least through the so-called expert database systems. I expect that the relationships between techniques from formal logic, databases, logic programming, and artificial intelligence will continue to be explored and the field of deductive databases will become a more prominent area of computer science in coming years.
CLAM- an open system for graphical user interfaces
Authors: Lisa A. Call, David L. Cohrs, Barton P. Miller
Venue: ACM SIGPLAN Notices (1987)

CLAM is an object-oriented system designed to support the building of extensible graphical user interfaces. CLAM provides a basic windowing environment with the ability to extend its functions using dynamically loaded C++ classes. The dynamically loaded classes allow for performance tuning (by transparently loading the class in either the client or the CLAM server) and for sharing of new functions. In addition to the traditionally layering of output abstractions, CLAM allows the programmer to easily layer input abstractions. The input functions include providing distributed upward calls through the layers, an light weight processes to support asynchronous input. CLAM is currently running under 4.3BSD UNIX on a MicroVax-II workstation.
Experimenting and theorizing in theory formation
Authors: B W Koehn, J M Zytkow
Venue: Proceedings of the ACM SIGART international symposium on Methodologies for intelligent systems (1986)

The BACON system, developed by Langley, Simon and Bradshaw, has shown the utility of a data driven discovery system. A new system, called FAHRENHEIT, has been built which extends BACON, making it more robust and allowing it perform a wider range of discovery activity. The new system extends BACON in several ways: 1) It determines the scope of a law by making simulated experiments, and by searching for regularities that describe the scope boundaries. 2) The world model in which the experiments are performed is more sophisticated. 3) The order in which the data are considered is placed under the control of FAHRENHEIT so that the system continues the discovery process even if no regularity is found for a particular variable.
A statistical technique for comparing heuristics: an example from capacity assignment strategies in computer network design
Authors: Richard Nance, Robert Moose, Robert Foutz
Venue: Communications of the ACM (1987)

An analysis of variance (ANOVA) model is developed for determining the existence of significant differences among strategies employing heuristics. Use of the model is illustrated in an application involving capacity assignment for networks utilizing the dynamic hierarchy architecture, in which the apex node is reassigned in response to changing environments. The importance of the model lies in the structure provided to the evaluation of heuristics, a major need in the assessment of benefits of artificial-intelligence applications. A nested three-factor design with fixed and random effects provides a numerical example of the model.
Computer system reliability and nuclear war
Authors: Alan Borning
Venue: Communications of the ACM (1987)

Given the devastating consequences of nuclear war, it is appropriate to look at current and planned uses of computers in nuclear weapons command and control systems, and to examine whether these systems can fulfill their intended roles.
Three reasons to avoid the use clause
Authors: G. Mendal
Venue: ACM SIGAda Ada Letters (1988)

Ada's use clause is regarded by some as the nemesis of the language, and by others as the only reasonable mechanism of importing visibility from other program units. Many organizations have struggled with the problem of whether to allow their programmers to use the use clause. Often their decisions are based on erroneous, slanted, emotional, or political rationale. This paper shows by means of example why th e use clause should be avoided completely. It focuses solely on the technical aspects of systems which rely on the use clause.
Shading bicubic patches
Authors: Michael Shantz, Sheue-Ling Lien
Venue: Proceedings of the 14th annual conference on Computer graphics and interactive techniques (1987)

We present several techniques for implementing Phong shading in hardware for bicubic patches. Patches are shaded, not by subdividing into polygons, but by drawing many curves close together leaving no pixel gaps. Each curve is drawn using an adaptive forward difference algorithm which generates the coordinates as well as the shading parameters as cubic functions incrementally evaluated along the curve. The forward difference step size is adaptively adjusted so that it generates approximately one pixel along the curve per forward difference step. The hardware implements Phong shading directly with a surprisingly simple configuration built from general purpose compute units and look-up tables. Two new methods are presented for deriving bicubic approximations to the shading parameters over a bicubic patch. One method uses two Coons patches to approximate the unnormalized N middot;L, and N middot;H, and a third Coons patch for N middot;N, where N is the surface normal, L is the light direction, and H is the direction of maximum highlight. In this case the hardware performs the normalization per pixel. The second method uses two Coons patches to approximate the normalized dot products N middot;L, and N middot;H. The method is suitable for both hardware and software implementations.
Verification of Concurrent Control Flow in Distributed Computer Systems
Authors: Stepehn S. Yau, Wonmo Hong
Venue: IEEE Transactions on Software Engineering (1988)

An approach to verifying control flow in distributed computer systems (DCS) is presented.The approach is based on control flow checking among software components distributed over processors and cooperating among them.In this approach, control flow behavior of DCS software is modeled and contained in special software components called verifiers.The verifiers are distributed over the processors and consulted to check the correctness of the control flow in DCS software during its execution.Algorithms for deriving the verifiers are presented.This technique can detect global errors including synchronization errors as well as local errors.It can be used for sequential or concurrent software at various levels of details.Experiments show that using this technique requires no significant overhead.
Customizing cooperative office procedures by planning
Authors: Rainer Lutze
Venue: Proceedings of the ACM SIGOIS and IEEECS TC-OA 1988 conference on Office information systems (1988)

Cooperative office procedures coordinate the flow of information in complex distributed work, in which several office workers are involved. An approach for planning cooperative office procedures is presented, focussing on the requirements, possibilities and limitations of planning activities. Special attention is given to the elaboration of a suitable office knowledge representation and a maintainable structure of the knowledge base, the electronic organization handbook (ELO).
A multiply-and-accumulate selection algorithm for dynamic entropy coding
Authors: D Irwin
Venue: ACM SIGCOMM Computer Communication Review (1986)

Entropy coding is a well-known tool for reducing the redundancy present in communication signals. As a signal's redundancy is reduced, the bandwidth required for its transmission over a low-noise channel also decreases. Memory requirements may likewise be reduced for coded information stored in low-error media. A method is presented for determining entropy codes by means of a sequence of multiply-and-accumulate and look-up operations. Structuring the process in such a fashion allows the effective use of a digital signal processor for dynamically generating adaptive codes in response to changing source statistics.
Managing prototype knowledge/expert system projects
Authors: James M. Cupello, David J. Mishelevich
Venue: Communications of the ACM (1988)

Computer science technology in the 1990s will involve knowledge/expert systems. Fundamental issues of technology transfer, training, problem selection, staffing, corporate politics, and more, are explored.
Strongly Code Disjoint Checkers
Authors: M. Nicolaidis, B. Courtois
Venue: IEEE Transactions on Computers (1988)

Strongly code-disjoint (SCD) checkers are defined and shown to include totally self-checking (TSC) code-disjoint checkers. This type of checker is the natural companion of strongly fault-secure (SFS) networks. SCD checkers are the largest class of checkers with which a combinational system may achieve the TSC goal. Some examples are given to illustrate the design of SCD checkers.
Experiments in SR with different upcall program structures
Authors: M. Stella Atkins
Venue: ACM Transactions on Computer Systems (TOCS) (1988)

This paper explores program designs for layered systems such as communication protocols and server/client systems that do not exhibit a strict hierarchy in their control flow. Clark has proposed structuring such systems, where both upward and downward control flow are required, to use efficient synchronous procedure calls between the layers whenever possible. The term upcall is used by Clark to describe this synchronous upward communication from server to client. Several techniques are possible for structuring such programs using upcalls. Comparisons are made by implementing a communication protocol described by Clark in three different ways. The first method implements all the protocol routines in a single large module. The second method structures the routines into modules occupying vertical slices of the protocol layers, and the third method structures the routines into modules corresponding to the protocol layers. Comparisons are made on two fronts: Preservation of modularity, in order to determine which method shows fault-tolerance and ease of programming, and program performance, which is a key motivation for the upcalls programming style. We conclude that the vertically layered protocol design is to be preferred unless there are many shared variables between the send-side and receive-side, as it is very efficient and provides the best protection of clients from each other. The horizontally layered design is the least efficient, but it is the easiest to program.
The design of Operating System/2
Authors: Michael S. Kogan, Freeman L. Rawson
Venue: IBM Systems Journal (1988)

The design of Operating System/2 (OS/2) is a result of matching the requirements of IBM and its customers for a new operating system for various models of the Personal System/2 with the need for continuity with a very large body of established DOS applications. The design of OS/2 represented a significant challenge both in meeting these requirements and in making efficient use of the hardware. In this paper, the design characteristics of OS/2 are discussed. &mdash;Authors' Abstract
Local distributed deadlock detection by knot detection
Authors: I Cidon, J M Jaffe
Venue: ACM SIGCOMM Computer Communication Review (1986)

A distributed algorithm for the detection of deadlocks in store-and-forward communication networks is presented. At first, we focus on a static environment and develop an efficient knot detection algorithm for general graphs. The knot detection algorithm uses at most &Ogr;(n2 + m) messages and &Ogr;(log(n)) bits of memory to detect all deadlocked nodes in the static network. Using the knot detection algorithm as a building block, a deadlock detection algorithm in a dynamic environment is developed. This algorithm has the following properties: It detects all the nodes which cause the deadlock. The algorithm is triggered only when there is a potential for deadlock and only those nodes which are potentially deadlocked perform the algorithm. The algorithm does not affect other processes at the nodes.
Query Processing in a Fragmented Relational Distributed System: Mermaid
Authors: Clement T. Yu, C. C. Chang, Marjorie Templeton, David Brill, Eric Lund
Venue: IEEE Transactions on Software Engineering (1985)

This paper describes the query optimizer of the Mermaid system which provides a user with a unified view of multiple preexisting databases which may be stored under different DBMS's. The algorithm is designed for databases which may contain replicated or fragmented relations and for users who are primarily making interactive, ad hoc queries. Although the implementation of the algorithm is a front-end system, not an integrated distributed DBMS, it should be applicable to a distributed DBMS also.
Modeling and rendering waves: wave-tracing using beta-splines and reflective and refractive texture mapping.
Authors: Pauline Y. Ts'o, Brian A. Barsky
Venue: ACM Transactions on Graphics (TOG) (1987)

The graphical simulation of a certain subset of hydrodynamics phenomena is examined. New algorithms for both modeling and rendering these complex phenomena are presented. The modeling algorithms deal with wave refraction in an ocean. Waves refract in much the same way as light. In both cases, the equation that controls the change in direction is Snell's law. Ocean waves are continuous but can be discretely decomposed into wave rays or wave orthogonals. These wave orthogonals are wave-traced in a manner similar to the rendering algorithm of ray-tracing. The refracted wave orthogonals are later traversed and their height contributions to the final surface are calculated using a sinusoidal shape approximation and the principle of wave superposition. The surface is then represented by Beta-splines, using the tension (or &bgr;2) shape parameter to easily add more complexity to the surface. The rendering algorithms are based on the use of texture maps and Fresnel's law of reflection. In each algorithm, two texture maps are used to simulate reflection and refraction. Based on surface normal orientation and Fresnel's law, a weighting is calculated that determines what fractions of reflected color and refracted color are assigned to a point. These algorithms are more efficient, though less accurate, alternatives to standard ray-tracing techniques.
Tiling and recursion
Authors: I-Ping Chu, Richard Johnsonbaugh
Venue: ACM SIGCSE Bulletin (1987)

A tiling problem is presented that demonstrates the power of recursion in the design of algorithms. When implemented as a program, the solution can be shown using a computer graphics display.
Providing intelligent assistance in distributed office environments
Authors: Sergei Nirenburg, Victor Lesser
Venue: ACM SIGOIS Bulletin (1986)

We argue that a task-centered, an agent-centered and a cognition-oriented perspective are all needed for providing intelligent assistance in distributed office environments. We present the architecture for a system called OFFICE that combines these three perspectives. We illustrate this architecture through an example.
Concurrent Broadcast for Information Dissemination
Authors: Donald M. Topkis
Venue: IEEE Transactions on Software Engineering (1985)

Concurrent broadcast involves the dissemination of a database, consisting of messages initially distributed among the nodes of a network, so that a copy of the entire database eventually resides at each node. One application is the dissemination of network status information for adaptive routing in a communications network. This paper examines the time complexity and communication complexity of several distributed procedures for concurrent broadcast. The procedures do not use information depending on the network topology. The worst-case time complexity of a flooding procedure for concurrent broadcast is shown to be linear in the number of nodes plus the number of messages, and no other procedure for concurrent broadcast has a better worst-case time complexity. A variant of flooding is proposed to eliminate redundant message receipts from the flooding process by real-time signaling between neighbors concerning messages residing at each. This variant can reduce communication complexity, while having a worst-case time complexity similar in form to that of the flooding procedure. Special properties of concurrent broadcast in a tree are also given. The present time complexity results can be used to bound the time during which inconsistent databases may reside at different nodes, to evaluate and compare procedures for (or including) concurrent broadcast, and to schedule a sequence of instances of concurrent broadcast so that the instances do not overlap and there is no need for sequence numbers.
Issuing each undergraduate student a personal computer: living with it for three years
Authors: Bill Mein
Venue: Proceedings of the eighteenth SIGCSE technical symposium on Computer science education (1987)

Clarkson University was the first university to issue incoming freshmen a desktop computer system. The program has been in place for three years; now all incoming undergraduates receive a desktop system. Last year, the university did a study to determine its computing needs for the next five years. Students were surveyed for their remarks regarding the computing facilities &mdash; including the desktop program. This paper notes some of those findings as well as some comments made by the faculty who were surveyed.
Data base directions information resource management-making it work, executive summary
Authors: Elizabeth N. Fong, Alan H. Goldfine
Venue: ACM SIGMOD Record (1986)

On October 21-23, 1985, the Institute for Computer Sciences and Technology of the National Bureau of Standards (NBS), in cooperation with the Association for Computing Machinery Special Interest Group on Management of Data (ACM SIGMOD), the IEEE Computer Society Technical Committee on Database Engineering, and the Federal Data Management Users Group (FEDMUG), held the fourth in their series of Data Base Directions workshops. The purpose of this workshop was to assess the nature of current information resource management (IRM) practice and problems, and to explore solutions which have proven workable.
An O(20.304n) Algorithm for Solving Maximum Independent Set Problem
Authors: T Jian
Venue: IEEE Transactions on Computers (1986)

A faster algorithm for finding a maximum independent set in a graph is presented. The algorithm is an improved version of the one by Tarjan and Trojanowski [7]. A technique to further accelerate this algorithm is also described.
An Image Processing Language with Icon-Assisted Navigation
Authors: Shi-Kuo Chang, Erland Jungert, S. Levialdi, G. Tortora, Tadao Ichikawa
Venue: IEEE Transactions on Software Engineering (1985)

This paper describes a generic image processing language IPL, and a programming environment supporting the language primitives for an image information system. The central notion of IPL is that it allows the user to navigate through the image database and manipulate images using generalized icons. The image processing language IPL consists of three subsets: the logical image processing language LIPL, the interactive image processing language IIPL, and the physical image processing language PIPL. This paper presents the main concepts of this generic language, some examples, and a scenario.
A workstation model for an interactive graphics system
Authors: Mike Heck, Martin Plaehn
Venue: Communications of the ACM (1986)

By introducing the concept of an abstract graphics device called the workstation, an existing graphics system is generalized to support multiple devices in applications software.