ppxscal/embedding_network huggingface dataset:
Type inference and semi-unification
Authors: Fritz Henglein
Venue: Proceedings of the 1988 ACM conference on LISP and functional programming (1988)

The Milner Calculus is the typed &lgr;-calculus underlying the type system for the programming language ML [Har86] and several other strongly typed polymorphic functional languages such as Miranda [Tur86] and SPS [Wan84]. Mycroft [Myc84] extended the problematical typing rule for recursive definitions and proved that the resulting calculus, termed Milner-Mycroft Calculus here, is sound with respect to Milner's [Mil78] semantics and that it preserves the principal typing property [DM82] of the Milner Calculus. The extension is of practical significance in typed logic programming languages [MO84] and, more generally, in any language with (mutually) recursive definitions. Mycroft didn't solve the decidability problem for typings in this calculus, though. This was an open problem independently raised also by Meertens [Mee83]. The decidability question was answered in the affirmative just recently by Kfoury et al. in [KTU88]. We show that the type inference problems in the Milner and the Milner-Mycroft Calculi can be reduced to solving equations and inequations between first-order terms, a problem we have termed semi-unification. We show that semi-unification problems have most general solutions in analogy to unification problems &mdash; which translates into principal typing properties for the underlying calculi. In contrast to the (essentially) nonconstructive methods of [KTU88] we present functional specifications, which we prove partially correct, for computing the most general solution of semi-unification problems, and we devise a concrete nondeterministic algorithm on a graph-theoretic representation for computing these most general solutions. Finally, we point out some erroneous statements about the efficiency of polymorphic type checking that have persisted throughout the literature including an incorrect claim, submitted by ourselves, of polynomial time type checking in the Milner-Mycroft Calculus.
Designers: meet your users (panel)
Authors: S. Joy Mountford
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Empowering people (1990)

Too few interface designers actually use an iterative design process. Too few interface designers actually involve their anticipated users throughout the design of an interface. In order to build better interfaces, we need to build faster and more numerous prototypical interface examples. These prototypes, from early sketches to working systems, should be shown frequently and often to users for their feedback. This panel is a vignette that illustrates an interface design cycle. Our panelists will be given a real world interface design problem, and the audience will follow them through their usual process of design. Users will be involved in the process, to help in interface specification and to provide prototype feedback. We expect that although the panelists involved users throughout their design process, users will still have a good deal more to contribute to the interface design before a product is finalized. On stage we will witness real users, with varied backgrounds, providing comments and feedback on the working prototypes. The issue here is to remind designers that there is never enough user involvement in an interface design. We need to iterate our interface designs, based on users' feedback, more often and continuously if our interfaces are to be effective,
On the effect of join operations on relation sizes
Authors: Danièle Grady, Claude Puech
Venue: ACM Transactions on Database Systems (TODS) (1989)

We propose a generating function approach to the problem of evaluating the sizes of derived relations in a relational database framework. We present a model of relations and show how to use it to deduce probabilistic estimations of derived relation sizes. These are found to asymptotically follow normal distributions under a variety of assumptions.
Concurrent algorithmic debugging
Authors: Yossi Lichtenstein, Ehud Shapiro
Venue: ACM SIGPLAN Notices (1989)

Algorithmic Debugging is a theory of debugging that uses queries on the compositional semantics of a program in order to localize bugs. It uses the following principle: if a computation of a program's component gives an incorrect result, while all the subcomputations it invokes compute correct results, then the code of this component is erroneous. Algorithmic Debugging is applied, in this work, to reactive systems, in particular to programs written in Flat Concurrent Prolog (FCP). Debugging reactive systems is known to be more difficult than the debugging of functional systems. A functional system is fully described by the relation between its initial input and final output; this context-freedom is used in debugging. A reactive system continuously responds to external inputs, thus its debugging cannot make use of context-free input/output relations. Given a compositional semantic model for a concurrent programming language, we demonstrate how one can directly apply the ideas of Algorithmic Debugging to obtain a theory of program debugging for the considered language. The conflict between the context-freedom of input/ output relations and the reactive nature of concurrent systems is resolved by using semantic objects which record the reactive nature of the system's components. In functional algorithmic debugging the queries relate to input/output relations; in concurrent algorithmic debugging the queries refer to semantic objects called processes which capture the reactive nature of FCP computations. A diagnosis algorithm for incorrect FCP programs is proposed. The algorithm gets an erroneous computation and using queries isolates an erroneous clause or an incomplete procedure. An FCP implementation of the diagnosis algorithm demonstrates the usefulness as well as the difficulties of Algorithmic Debugging of FCP programs.
Combining generational and conservative garbage collection: framework and implementations
Authors: Alan Demers, Mark Weiser, Barry Hayes, Hans Boehm, Daniel Bobrow, Scott Shenker
Venue: Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1989)

Two key ideas in garbage collection are generational collection and conservative pointer-finding. Generational collection and conservative pointer-finding are hard to use together, because generational collection is usually expressed in terms of copying objects, while conservative pointer-finding precludes copying. We present a new framework for defining garbage collectors. When applied to generational collection, it generalizes the notion of younger/older to a partial order. It can describe traditional generational and conservative techniques, and lends itself to combining different techniques in novel ways. We study in particular two new garbage collectors inspired by this framework. Both these collectors use conservative pointer-finding. The first one is based on a rewrite of an existing trace-and-sweep collector to use one level of generation. The second one has a single parameter, which controls how objects are partitioned into generations: the value of this parameter can be changed dynamically with no overhead. We have implemented both collectors and present measurements of their performance in practice.
On approximation algorithms for microcode bit minimization
Authors: S. S. Ravi, D. Gu
Venue: Proceedings of the 21st annual workshop on Microprogramming and microarchitecture (1988)

The bit (or width) minimization problem for microprograms is known to be NP-complete. Motivated by its practical importance, we address the question of obtaining near-optimal solutions. Two main results are presented. First, we establish a tight bound on the quality of solutions produced by algorithms which minimize the number of compatibility classes. Second, we show that the bit minimization problem has a polynomial time relative approximation algorithm only if the vertex coloring problem for graphs with n nodes can be approximated to within a factor of &Ogr;(logn) in polynomial time.
Reasoning about continuations with control effects
Authors: P. Jouvelot, D. K. Gifford
Venue: ACM SIGPLAN Notices (1989)

We present a new static analysis method for first-class continuations that uses an effect system to classify the control domain behavior of expressions in a typed polymorphic language. We introduce two new control effects, goto and comefrom, that describe the control flow properties of expressions. An expression that does not have a goto effect is said to be continuation following because it will always call its passed return continuation. An expression that does not have a comefrom effect is said to be continuation discarding because it will never preserve its return continuation for later use. Unobservable control effects can be masked by the effect system. Control effect soundness theorems guarantee that the effects computed statically by the effect system are a conservative approximation of the dynamic behavior of an expression. The effect system that we describe performs certain kinds of control flow analysis that were not previously feasible. We discuss how this analysis can enable a variety of compiler optimizations, including parallel expression scheduling in the presence of complex control structures, and stack allocation of continuations. The effect system we describe has been implemented as an extension to the FX-87 programming language.
Optimum polynomial retrieval functions
Authors: N. Fuhr
Venue: ACM SIGIR Forum (1989)

We show that any approach to develop optimum retrieval functions is based on two kinds of assumptions: first, a certain form of representation for documents and requests, and second, additional simplifying assumptions that predefine the type of the retrieval function. Then we describe an approach for the development of optimum polynomial retrieval functions: request-document pairs (&fnof;l, dm) are mapped onto description vectors @@@@(&fnof;l, dm), and a polynomial function of the form @@@@T &middot; @@@@(@@@@) is developed such that it yields estimates of the probability of relevance P(R|@@@@(&fnof;l, dm)) with minimum square errors. We give experimental results for the application of this approach to documents with weighted indexing as well as to documents with complex representations. In contrast to other probabilistic models, our approach yields estimates of the actual probabilities, it can handle very complex representations of documents and requests, and it can be easily applied to multi-valued relevance scales. On the other hand, this approach is not suited to log-linear probabilistic models, and it needs large samples of relevance feedback data for its application.
CrossCheck: a cell based VLSI testability solution
Authors: T. Ghewala
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

A new testability solution is proposed in which externally accessible test points are pre-designed into cells that comprise the VLSI designs. The test points are accessed through an on-chip grid of orthogonal probe and sense lines. The resultant VLSI design consists of a large number of test points through which test signals on every cell on the IC can be measured or modified to a limited extent. The sizable number of test points improves the testability of the designs by a very large factor. Additionally, analog measurement and signal injection capabilities allow detection of practical CMOS fault modes such as opens, shorts, open or closed FET's and even noise margins. The large observability of CrossCheck based designs reduces the automatic test pattern generation problem to one of providing control only. Several ISCAS benchmark designs are analyzed using CrossCheck cell libraries and fault models. The results show that over 97 percent coverage of a broad range of fault modes, such as opens and shorts, can be obtained on VLSI CMOS designs without the need for large computing resources.
Comparative analyses of parallel simulation protocols
Authors: P. F. Reynolds, C. F. Weight, J. R. Fidler
Venue: Proceedings of the 21st conference on Winter simulation (1989)

Currently there is not a significant body of comparative, experimental performance results for parallel simulation protocols. Nor is there a body of significant analytic studies. The SPECTRUM Testbed [ReDi89] has been designed to support the empirical study of parallel simulation protocols and applications, with the expectation that experience with the testbed will provide insights into the efficacy of various protocols and their interplay with classes of applications. We discuss our experience with the SPECTRUM Testbed, focusing primarily on an observed, unexpected degree of dependency between protocols and applications, and on an unexpected, large set of application design options. The latter gives rise to the definition of a set of application design variables which describes a large design space. We discuss its impact on the testbed design and we discuss a limited set of performance results that we have for selected sets of protocols and applications.
Object-based real-time programming
Authors: Libero Nigro, F. Tisato
Venue: ACM SIGPLAN Notices (1989)

RTO (Real-Time Objects) is an object-based programming paradigm suited for Real-Time and, in particular, Hard-Real-Time applications. A Real-Time (RT) system must provide (with high probability) response times small in comparison with the time constants of the environment. A Hard-Real-Time (HRT) system is a RT system which must also fulfill deterministic constraints on response times. The aim of RTO is to provide a test bed for the experimentation of concepts which are relevant in the RT area. Then it is focused on those dimensions of Object-Based language design [Wegner 87b] which are tightly related to specific requirements of that area. This paper introduces the rationale for the basic choices of RTO.
Information systems planning: incentives for effective action
Authors: Albert L. Lederer, Aubrey L. Mendelow
Venue: ACM SIGMIS Database (1989)

During two research projects to identify the difficulties associated with information systems planning (ISP), it became apparent that IS managers and users often do not apply a number of commonly accepted guidelines for successful ISP. This paper reports some instances in which the guidelines were not applied. It also explains the neglect of the guidelines in terms of the incentives which the ISP participants had for not applying them. The findings suggest further research and also have practical implications for IS managers.
Automated design data capture using relaxation techniques
Authors: H. R. Myler, A. J. Gonzalez
Venue: Issue 108 (April 1989) (1989)

A method that converts a Computer Aided Design (CAD) database description of a process control system into a frame-oriented knowledge base for an automated diagnostic control system is introduced. The system is unique in that relaxation labeling techniques borrowed from research in computer vision are used to resolve the functional composition of the diagnostic frames. The target system for the automated knowledge generation process uses frames to represent structure and function data at the component level and does not use inference rules. Failure detection is performed by constant analysis of the output functions. Diagnosis of failure is performed via functional inversion of the component transfer function represented in the component frame. Capture of the functional knowledge of a component is the most difficult task in the building of this type of knowledge base. A CAD database constructed for a particular process control system contains all the structural information required to describe the system, but little or no functional data. A functional description can be inferred in some cases from the CAD data, however, the complexity of such a system for a domain as large as process control is extensive.
Moded type systems for logic programming
Authors: K. A. Yelick, J. L. Zachary
Venue: Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1989)

Most of the theoretical work on the semantics of logic programs assumes an interpreter that provides a complete resolution procedure. In contrast, for reasons of efficiency, most logic programming languages are built around incomplete procedures. This difference is rooted in Prolog, which evaluates resolvent trees in a depth-first rather than a breadth-first order. The gap is widened by some equational logic languages, which combine the incompleteness of depth-first evaluation with incomplete approximations to equational unification. Because of this gap, it is unsound to reason about logic programs using their declarative semantics. This in turn makes it difficult to develop abstraction mechanisms that can be used to partition a logic program into independently specifiable modules. In this paper we consider the role type systems can play in closing the gap between the operational and declarative semantics of logic programs. We develop the notion of an equational mode system for use in constraining the domains of both predicates and unification procedures. The mode system is used to guide the resolution-based interpreter, and as a result, we can show that two predicate implementations with the same declarative meaning will be operationally equivalent.
Parallel programming in comfort
Authors: J. Flower, R. Williams
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

We describe a set of software utilities designed to facilitate the writing of parallel codes and porting sequential ones. Emphasis is placed on portability so that code can be developed simultaneously on a sequential and a parallel machine, and so that the completed code can be run and maintained on a wide variety of machine architectures. We describe the CrOS communication package for parallel machines, the CUBIX system to allow a code to run in parallel or sequentially, the PLOTIX parallel graphics foundation, and the parallel debugger NDB. While the system described has been implemented on qualitatively different machines the particular version described here is most efficient for the hypercube architecture, and was developed on NCUBE hypercubes under both the AXIS or XENIX operating systems.
Computation of exponential integrals of a complex argument
Authors: Donald E. Amos
Venue: ACM Transactions on Mathematical Software (TOMS) (1990)

Previous work on exponential integrals of a real argument has produced a computational algorithm which implements backward recurrence on a three-term recurrence relation (Miller algorithm). The process on which the algorithm is based involves the truncation of an infinite sequence with a corresponding analysis of the truncation error. This error is estimated by means of (asymptotic) formulas, which are not only applicable to the real line, but also extendible to the complex plane. This fact makes the algorithm extendible to the complex plane also. However, the rate of convergence decreases sharply when the complex argument is close to the negative real axis. In order to make the algorithm more efficient, analytic continuation into a strip about the negative real axis is carried out by limited use of power series. The analytic details needed for a portable computational algorithm are presented.
Inheritance is not subtyping
Authors: William R. Cook, Walter Hill, Peter S. Canning
Venue: Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1989)

In typed object-oriented languages the subtype relation is typically based on the inheritance hierarchy. This approach, however, leads either to insecure type-systems or to restrictions on inheritance that make it less flexible than untyped Smalltalk inheritance. We present a new typed model of inheritance that allows more of the flexibility of Smalltalk inheritance within a statically-typed system. Significant features of our analysis are the introduction of polymorphism into the typing of inheritance and the uniform application of inheritance to objects, classes and types. The resulting notion of type inheritance allows us to show that the type of an inherited object is an inherited type but not always a subtype.
Software configuration&mdash;an NP-complete problem
Authors: Jerry Calabaugh
Venue: ACM SIGMIS Database (1988)

Configuration Control File (CCF) production is very complex, thousands of code packages, data blocks and parameter values must be linked under many constraints including:*Common data and code less than 8192 bytes*Maximum of 5 registers per task*All systems data must have common capabilitiesNP-complete problems are commonly known as knapsack or bin packing problems. They have no known algorithm which solves them in a time period bounded by a polynominal function of the number of inputs. Rules-of-thumb, or heuristics are the only practical approach to their solution. CCF segmentation to meet constraints discussed above is an example of Expert System technology applied to a classic NP-complete problem.Heuristics developed with traditional data processing techniques initially performed satisfactorily. However, as program development proceeded, Central Processor Unit (CPU) time for (CCF) production became a concern, both from a commitment of CPU resources and lost productivity. Traditional techniques failed to improve the heuristics and the project began to slip. Projected time to produce the CCF for a fully developed program was totally unacceptable, and jeopardized the project.Clearly another approach was required. Because existing hueristics were based on a concept of rules, research indicated an expert system using rules and a knowledge based approach had the highest probability of success.The paper emphasizes the development process of a knowledge based system from the perspective of the responsible project manager. The methodology is also applicable to common business problems.
User defined data types in APL2
Authors: J. P. Benkard, J. A. Brown
Venue: ACM SIGAPL APL Quote Quad (1989)

This paper is an investigation of possible definitions of new enclose-like functions, their impact on the APL2 language, and their usefulness in applications. Several variants of enclose have been proposed over the years that range from data structure primitives to data type producing primitives. Operator analogues of enclose can be used to create functions that pervade structures and types in different ways. Defined operators can implement type hierarchy and respond to fill items in prototype execution by referring to tables of type characteristics.
Path-delay constrained floorplanning: a mathematical programming approach for initial placement
Authors: S. Prasitjutrakul, W. J. Kubitz
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

A procedure for path-delay constrained initial placement during chip floorplanning is presented which directly incorporates timing and geometrical constraints into the process. The problem is modeled and mathematically formulated as a constrained non-linear programming problem which is systematically divided and solved in three steps: timing minimization with module overlap, module separation and timing minimization without module overlap. To save computation time, two techniques for eliminating non-logical and noncritical paths are used to reduce the number of paths considered during the optimization. Experimental results show that the placement results satisfy all given timing and geometrical constraints, and have good total normalized wire delays.