ppxscal/embedding_network huggingface dataset:
A rule-based view of query optimization
Authors: Johann Christoph Freytag
Venue: ACM SIGMOD Record (1987)

The query optimizer is an important system component of a relational database management system (DBMS). It is the responsibility of this component to translate the user-submitted query - usually written in a non-procedural language - into an efficient query evaluation plan (QEP) which is then executed against the database. The research literature describes a wide variety of optimization strategies for different query languages and implementation environments. However, very little is known about how to design and structure the query optimization component to implement these strategies. This paper proposes a first step towards the design of a modular query optimizer. We describe its operations by transformation rules which generate different QEPs from initial query specifications. As we distinguish different aspects of the query optimization process, our hope is that the approach taken in this paper will contribute to the more general goal of a modular query optimizer as part of an extensible database management system.
Virtual instruments: object-oriented program synthesis
Authors: K. S. Bhaskar, J. K. Pecol, J. L. Beug
Venue: ACM SIGPLAN Notices (1986)

Virtual Instruments1 is an experimental programming environment for developing electronic test and measurement (T M) applications. Intended users are test engineers, who are not programmers, but computer literate domain specialists. Unlike traditional programming environments, that provide weak support for a broad range of applications, virtual instruments provides strong support for a specific application. The programming paradigm is bottom-up synthesis of layers of virtual machines &mdash; called virtual instruments &mdash; using human interface models from the application domain, so that software development occurs without writing code. The object-oriented view of the world has proven a natural fit. Implementation was in Berkeley Smalltalk on a SUN workstation.
Measurement and Application of Fault Latency
Authors: Kang G. Shin, Yann-Hang Lee
Venue: IEEE Transactions on Computers (1986)

The time interval between the occurrence of a fault and the detection of the error caused by the fault is divided by the generation of that error into two parts: fault latency and error latency. Since the moment of error generation is not directly observable, all related works in the literature have dealt with only the sum of fault and error latencies, thereby making the analysis of their separate effects impossible. To remedy this deficiency, we 1) present a new methodology for indirectly measuring fault latency, 2) derive the distribution of fault latency from the methodology, and 3) apply the knowledge of fault latency to the analysis of two important examples.
The Use of Software Complexity Metrics in Software Maintenance
Authors: D. Kafura, G. R. Reddy
Venue: IEEE Transactions on Software Engineering (1987)

This paper reports on a modest study which relates seven different software complexity metrics to the experience of maintenance activities performed on a medium size software system. Three different versions of the system that evolved over a period of three years were analyzed in this study. A major revision of the system, while still in its design phase, was also analyzed.
Finding minimal perfect hash functions
Authors: Gary Haggard, Kevin Karplus
Venue: Proceedings of the seventeenth SIGCSE technical symposium on Computer science education (1986)

A heuristic is given for finding minimal perfect hash functions without extensive searching. The procedure is to construct a set of graph (or hypergraph) models for the dictionary, then choose one of the models for use in constructing the minimal perfect hashing function. The construction of this function relies on a backtracking algorithm for numbering the vertices of the graph. Careful selection of the graph model limits the time spent searching. Good results have been obtained for dictionaries of up to 181 words. Using the same techniques, non-minimal perfect has functions have been found for sets of up to 667 words.
Techniques for Computing the Discrete Fourier Transform Using the Quadratic Residue Fermat Number Systems
Authors: T K Truong, J J Chang, I S Hsu, D Y Pei, I S Reed
Venue: IEEE Transactions on Computers (1986)

In this correspondence, the complex integer multiplier and adder over the direct sum of two copies of finite field developed in [1] is specialized to the direct sum of the rings of integers modulo Fermat numbers. Such multiplication over the rings of integers modulo Fermat numbers can be performed by means of two integer multiplications, whereas the complex integer multiplication requires three integer multiplications. Such multiplications and additions can be used in the implementation of a discrete Fourier transform (DFT) of a sequence of complex numbers. The advantage of the present approach is that the number of multiplications needed to compute a systolic array of the DFT can be reduced substantially. The architectural designs using this approach are regular, simple, expandable and, therefore, naturally suitable for VLSI implementation.
APL87
Authors: Kenneth E. Iverson
Venue: Proceedings of the international conference on APL: APL in transition (1987)

I first began developing a formal language for use in teaching in the graduate program in Automatic Data Processing established by Professor Howard Aiken at Harvard in 1955. This language, now known as APL, has since passed through several phases, the main ones being documented in three publications [1-3]; my book A Programming Language in 1962, the APL\360 manual in 1968, and the APLSV manual in 1975. The last two were co-authored with A.D. Falkoff. The specifications of the language provided by these publications were later supplemented by more philosophical studies that discussed the design principles followed, and the major design choices made. These include The Design of APL [4], and the Evolution of APL [5], by me and Falkoff, and The Story of o, by E.E. McDonnell [6]. Because of implementations produced by various manufacturers, and because of attempts to inject aspects of other languages (as in APLGOL), many diverse lines of development have been pursued. These have been largely reported in manuals, in the proceedings of APL conferences, and in journals such as APL Quote-Quad (Association for Computing Machinery), and Vector (British Computing Society). In 1978 I began a line of development which has been reported largely in documents internal to IBM Corp. [7] and to I.P. Sharp Associates [8-10], but also in APL conferences [11-13]. This work has culminated in A Dictionary of APL, scheduled to appear in an early issue of APL Quote-Quad [14]; in what follows it will be referred to as &ldquo;the dictionary&rdquo;. The present paper is a companion study in the manner of [4-6]. A preview of it was presented in November of last year at an internal IBM conference that commemorated the 20th anniversary of the initiation of the APL timesharing service within IBM. The major points to be discussed here include terminology, the APL alphabet, word formation, parsing rules, mixed functions, operators, and localization. In discussing decisions made in the early days by me and colleagues in the APL group in the T.J. Watson Research Center, (notably A.D. Falkoff and L.M. Breed), I will use the term we; this usage is not meant to imply their agreement with the current thinking of myself and present colleagues at I.P. Sharp Associates as presented in the dictionary. Although there is no current implementation of the entire dictionary, several implementations embody significant parts of it, such as the application of operators to derived and user-defined functions, and the production of &ldquo;mixed&rdquo; arrays by expressions such as 3 4 5, 'ABCD'. Two implementations [13, 15] are particularly close to the dictionary; the latter was used in all executed examples in this paper.
Query processing in main memory database management systems
Authors: Tobin J. Lehman, Michael J. Carey
Venue: Proceedings of the 1986 ACM SIGMOD international conference on Management of data (1986)

Most previous work in the area of main memory database systems has focused on the problem of developing query processing techniques that work well with a very large buffer pool. In this paper, we address query processing issues for memory resident relational databases, an environment with a very different set of costs and priorities. We present an architecture for a main memory DBMS, discussing the ways in which a memory resident database differs from a disk-based database. We then address the problem of processing relational queries in this architecture, considering alternative algorithms for selection, projection, and join operations and studying their performance. We show that a new index structure, the T Tree, works well for selection and join processing in memory resident databases. We also show that hashing methods work well for processing projections and joins, and that an old join method, sort-merge, still has a place in main memory.
Fault-Tolerant SoFtware Reliability Modeling
Authors: R. K. Scott, J. W. Gault, D. F. McAllister
Venue: IEEE Transactions on Software Engineering (1987)

In situations in which computers are used to manage life-critical situations, software errors that could arise due to inadequate or incomplete testing cannot be tolerated. This paper examines three methods of creating fault-tolerant software systems, Recovery Block, N-Version Programming, and Consensus Recovery Block, and it presents reliability models for each. The models are used to show that one method, the Consensus Recovery Block, is more reliable than the other two.
Accumulator Compression Testing
Authors: Nirmal R. Saxena, John P. Robinson
Venue: IEEE Transactions on Computers (1986)

A new test data reduction technique called accumulator compression testng (ACT) is proposed. ACT is an extension of syndrome testing. It is shown that the enumeration of errors missed by ACT for a unit under test is equivalent to the number of restricted partitions of a number. Asymptotic results are obtained for independent and dependent error modes. Comparison is made between signature analysis (SA) and ACT. Theoretical results indicate that with ACT a better control over fault coverage can be obtained than with SA. Experimental results are supportive of this indication. Built-in self test for processor environments may be feasible with ACT. However, for general VLSI circuits the complexity of ACT may be a problem as an adder is necessary.
Query optimization using the concept of restricted topologies
Authors: E. A. Unger, Diane Jantz
Venue: ACM SIGSMALL/PC Notes (1988)

Optimizing the time and or cost of processing a query within a distributed network involves consideration of a large number of factors that reside with a complex problem environment. The complexity of this environment has led most research in the field to simplify the problem by assuming many factors to be constant or by ignoring them. After an evaluation of the entire problem environment, a method termed topologies is proposed for simplifying the problem without necessarily ignoring factors. Topologies are environments which describe the problem space either statically or dynamically. These can be used in combination to determine a reasonable problem space to the level of dynamic change that is required. Once a query topology (i.e., a subnetwork which can respond to the query) is formed from the topologies describing the system, the problem space is constrained to accommodate the user request, and an extant optimization procedure can be applied to effect a solution.
Some tests of the numerical procedures of Pascal-SC
Authors: Z. Arone, P. Jansen, P. Weidner
Venue: ACM SIGSMALL/PC Notes (1988)

PASCAL-SC is an extended version of PASCAL, which is intended to be more usable for engineering purposes. It is distributed by Wiley-Teubner (see [1]). PASCAL-SC retains the features of standard PASCAL, and has some additional useful capabilities.
Iterated interpolation using a systolic array
Authors: G. P. McKeown
Venue: ACM Transactions on Mathematical Software (TOMS) (1986)

An implementation using systolic array logic of Aitken's method of iterated interpolation is described. The proposed design has a simple, linear topology, requires no clock, and makes only modest demands on the host computer. By overlapping the computation of successive function values, a processing element utilization of approximately 1/2 is achieved. The paper illustrates how &ldquo;mathematical hardware&rdquo; packages, as well as software library routines, may be part of the mathematical problem solver's tool kit in the future.
Interprocedural constant propagation
Authors: David Callahan, Keith D. Cooper, Ken Kennedy, Linda Torczon
Venue: ACM SIGPLAN Notices (1986)

In a compiling system that attempts to improve code for a whole program by optimizing across procedures, the compiler can generate better code for a specific procedure if it knows which variables will have constant values, and what those values will be, when the procedure is invoked. This paper presents a general algorithm for determining for each procedure in a given program the set of inputs that will have known constant values at run time. The precision of the answers provided by this method are dependent on the precision of the local analysis of individual procedures in the program. Since the algorithm is intended for use in a sophisticated software development environment in which local analysis would be provided by the source editor, the quality of the answers will depend on the amount of work the editor performs. Several reasonable strategies for local analysis with different levels of complexity and precision are suggested and the results of a prototype implementation in a vectorizing Fortran compiler are presented.
Retraining high school teachers to teach computer science&mdash;observations on the first course
Authors: Richard G. Epstein, Robert M. Aiken, Glenn Snelbecker, Jane Potosky
Venue: Proceedings of the eighteenth SIGCSE technical symposium on Computer science education (1987)

This paper discusses the authors' experience in teaching the first of four courses which comprise a sequence of courses especially constructed to retrain junior and senior high school teachers to teach Computer Science. A description of the goals of the project and details about this first course serve as a springboard for discussing how the objectives were met. Also included is a brief analysis of how teachers with various backgrounds fared and some suggestions for others desiring to teach a similar course.
Minimum-Area Wiring for Slicing Structures
Authors: W. K. Luk, P. Sipala, C. K. Wong
Venue: IEEE Transactions on Computers (1987)

In this paper we consider the problem of optimal wiring of VLSI circuits. The topological placement of the circuit elements (macros) on the chip is assumed to have a special hierarchical structure, i.e., to be a slicing floorplan, represented by a binary (slicing) tree. Instead of the usual objective of minimum wire length, we consider the problem of minimizing the overall area of the wired floorplan. For the case of a single multiterminal net connecting n macros, we obtain a wiring algorithm of complexity O(nd), where d is the depth of the slicing tree. The case of several multiterminal nets is still under investigation.
The Reyes image rendering architecture
Authors: Robert L. Cook, Loren Carpenter, Edwin Catmull
Venue: ACM SIGGRAPH Computer Graphics (1987)

An architecture is presented for fast high-quality rendering of complex images. All objects are reduced to common world-space geometric entities called micropolygons, and all of the shading and visibility calculations operate on these micropolygons. Each type of calculation is performed in a coordinate system that is natural for that type of calculation. Micropolygons are created and textured in the local coordinate sysem of the object, with the result that texture filtering is simplified and improved. Visibility is calculated in screen space using stochastic point sampling with a z buffer. There are no clipping or inverse perspective calculations. Geometric and texture locality are exploited to minimize paging and to support models that contain arbitrarily many primitives.
Searching a two key table under a single key
Authors: J. I. Munro
Venue: Proceedings of the nineteenth annual ACM symposium on Theory of computing (1987)

We present a method for arranging an arbitrary 2-key table as an n by 2 array such that a search can be performed under either key in O(lg2n lglg n) time. This is in sharp contrast with an &OHgr;(&radic;n) lower bound for the problem under a model in which all comparisons must involve the value being searched for.
Predicting area-time tradeoffs for pipelined design
Authors: Rajiv Jain, A. Parker, N. Park
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

In this paper we give a model for predicting the shape of cost-speed tradeoff curves for pipelined designs. The model includes prediction of the number of operators, registers and multiplexers from a behavioral specification. It has been verified with the designs generated by an automated pipeline synthesis program, Sehwa. This model was developed as a part of the ADAM Advanced Design Automation System of the University of Southern California.
Designing large real-time systems with Ada
Authors: Kjell Nielsen, Ken Shumate
Venue:  (1988)

The objective of this book is to present a comprehensive methodology for the design and implementation of large real-time systems in Ada. The reader is expected to have a good basic understanding of the Ada programming language&hellip;. The emphasis of this book is on practical step-by-step methodology without &ldquo;handwaving.&rdquo; It uses numerous graphical illustrations and design and coding examples&hellip;. This book can be used as an advanced upper level undergraduate or graduate text in Software Engineering. The emphasis is on design, not on programming&hellip;. Parts 1 through 5 are suitable course material for teaching a semester-long course on Ada real-time design methodology. &mdash;From the Preface
Extra-disciplinary curriculum: analysis of the presentation of legal materials to computer science students
Authors: Joseph W. Rigler
Venue: ACM SIGCSE Bulletin (1987)

An experimental course entitled Computers and the Law was offered to graduating Computer Science seniors at the University of Missouri-Rolla. This paper briefly reviews the purposes, content, and organization of the course; and presents the author's views on the results of the course and his suggestions for subsequent offerings.
Rate 1/2 and 2/3 Majority Logic Decodable Binary Burst Error-Correcting Codes
Authors: W. Zang, J. K. Wolf
Venue: IEEE Transactions on Computers (1987)

A new design procedure is described for constructing rate 1/2 and rate 2/3 majority logical decodable burst error-correcting codes. The rate 1/2 codes are closely related to the codes of Srinivasan [1].
Multicomputers: Message-Passing Concurrent Computers
Authors: William C. Athas, Charles L. Seitz
Venue: Computer (1988)

A status report is provided on the architecture and programming of a family of concurrent computers that are organized as ensembles of small programmable computers called nodes, connected by a message-passing network, each with its own private memory. The architecture of the multicomputer is described and contrasted with that of the shared-memory multiprocessor, and the concept of grain size (which depends on the size of the individual memories) is explained. Medium-grain and fine-grain multicomputers, with nodes containing megabytes and tens of kilobytes of memory, respectively, are examined, and their programming is discussed.
A mean value performance model for locking in databases: the no-waiting case
Authors: Y. C. Tay, Rajan Suri, Nathan Goodman
Venue: Journal of the ACM (JACM) (1985)

A new performance model for dynamic locking is proposed. It is based on a flow diagram and uses only the steady state average values of the variables. It is general enough to handle nonuniform access, shared locks, static locking, multiple transaction classes, and transactions of indeterminate length. The analysis is restricted to the case in which all conflicts are resolved by restarts. It has been shown elsewhere that, under certain conditions, this pure restart policy is as good as, if not better than, a policy that uses both blocking and restarts. The analysis is straightforward, and the computational complexity of the solution, given some nonrestrictive approximations, does not depend on the input parameters. The solution is also well defined and well behaved. The model's predictions agree well with simulation results. The model shows that data contention can cause the throughput to thrash, and gives a limit on the workload that will prevent this. It also shows that systems with a particular kind of nonuniform access and systems in which transactions share locks are equivalent to systems in which there is uniform access and only exclusive locking. Static locking has higher throughput, but longer response time, than dynamic locking. Replacing updates by queries in a multiprogramming mix may degrade performance if the queries are longer than the updates.
Evaluating students in systems development group projects
Authors: Carol Chrisman, Barbara Beccue
Venue: ACM SIGCSE Bulletin (1987)

Evaluating students in group projects is difficult. Both the end products of the group and the individual contributions of each group member must be evaluated in a fair manner. This paper will describe a set of evaluation procedures for a systems development group project. The procedures have three main features. First, the procedures structure the evaluation by partitioning the project grading into small components. Second the procedures incorporate the use of grading sheets for the group documentation at each project milestone. Third, the procedures provide for an interaction between the performance of the group and the performance of individual students in determining each individual's project grade. These procedures provide periodic feedback, allow students to clearly see how the project evaluation will be done, and encourage some objectivity and consistency in the grading process.
Merging text and graphics
Authors: Judi Cleary
Venue: Proceedings of the 4th annual international conference on Systems documentation (1986)

The capability to merge graphics and text into a consolidated document can greatly enhance communication. Even simple graphics such as boxes and arrows can help organize ideas and make information easier to understand. It is still disturbing to see the number of manuals that describe computer graphics systems that do not include even one graphic image! In the phototypesetting world, the capability to merge graphics and text has been available for some time, but only recently have the components for less costly systems become available. This paper will discuss a segmented system in use in a scientific R D environment for including graphics into documents.
Some conjectures on the behavior of acknowledgement-based transmission control of random access communication channels
Authors: Scott Shenker
Venue: ACM SIGMETRICS Performance Evaluation Review (1987)

A class of acknowledgment-based transmission control algorithms is considered. In the finite population case, we claim that algorithms based on backoff functions which increase faster than linearly but slower than exponentially are stable up to full channel capacity, whereas sublinear, exponential, and superexponential algorithms are not. In addition, comments are made about the nature of the quasistationary behavior in the infinite population case, and about how systems interpolate between the finite and infinite number of station cases. The treatment presented here is nonrigorous, consisting of approximate analytic arguments confirmed by detailed numerical simulations.