ppxscal/embedding_network huggingface dataset:
A simple and efficient implmentation approach for single assignment languages
Authors: Kourosh Gharachorloo, Vivek Sarkar, John L. Hennessy
Venue: Proceedings of the 1988 ACM conference on LISP and functional programming (1988)

Functional and single assignment languages have semantically pure features that do not permit side effects. This lack of side effects makes detection of parallelism in programs much easier. However, the same property poses a challenge in implementing these languages efficiently. A preliminary implementation of a compiler for the single assignment language, SISAL, is described. The compiler uses reference counts for memory management and copy avoidance. Performance results on a wide range of benchmark programs show that SISAL programs compiled by our implementation run 2-3 times slower on average than the same programs written in C, Pascal, and Fortran, and orders of magnitude faster than other implementations of single assignment languages. Extensions of these techniques for multiprocessor implementations are proposed.
Compilation of Haskell array comprehensions for scientific computing
Authors: Steven Anderson, Paul Hudak
Venue: ACM SIGPLAN Notices (1990)

Monolithic approaches to functional language arrays, such as Haskell array comprehensions, define elements all at once, at the time the array is created, instead of incrementally. Although monolithic arrays are elegant, a naive implementation can be very inefficient. For example, if a compiler does not know whether an element has zero or many definitions, it must compile runtime tests. If a compiler does not know inter-element data dependencies, it must resort to pessimistic strategies such as compiling elements as thunks, or making unnecessary copies when updating an array. Subscript analysis, originally developed for imperative language vectorizing and parallelizing compilers, can be adapted to provide a functional language compiler with the information needed for efficient compilation of monolithic arrays. Our contribution is to develop the number-theoretic basis of subscript analysis with assumptions appropriate to functional arrays, detail the kinds of dependence information subscript analysis can uncover, and apply that dependence information to sequential efficient compilation of functional arrays.
High performance communications in processor networks
Authors: C. R. Jesshope, P. R. Miller, J. T. Yantchev
Venue: ACM SIGARCH Computer Architecture News (1989)

In order to provide an arbitrary and fully dynamic connectivity in a network of processors, transport mechanisms must be implemented, which provide the propagation of data from processor to processor, based on addresses contained within a packet of data. Such data transport mechanisms must satisfy a number of requirements - deadlock and livelock freedom, good hot-spot performance, high throughput and low latency. This paper proposes a solution to these problems, which allows deadlock free, adaptive, high throughput packet routing to be implemented on networks of processors. Examples are given which illustrate the technique for 2-D array and toroidal networks. An implementation of this scheme on arrays of transputers is described. The scheme also serves as a basis for a very low latency routing strategy named the mad postman, a detailed implementation of which is described here as well.
Basic narrowing revisited
Authors: Werner Nutt, Pierre Réty, Gert Smolka
Venue: Journal of Symbolic Computation (1989)

In this paper we study basic narrowing as a method for solving equations in theinitial algebra specified by a ground confluent and terminating term rewriting system. Since we are interested in equation solving, we don't study basic narrowing as a reduction relation on terms but consider immediately its reformulation as an equation solving rule. This reformulation leads to a technically simpler presentation and reveals that the essence of basic narrowing can be captured without recourse to term unification. We present an equation solving calculus that features three classes of rules. Resolution rules, whose application is don't know nondeterministic, are the basic rules and suffice for a complete solution procedure. Failure rules detect inconsistent parts of the search space. Simplification rules, whose application is don't care nondeterministic, enhance the power of the failure rules and reduce the number of necessary don't know steps. Three of the presented simplification rules are new. The rewriting ruleallows for don't care nondeterministic rewriting and thus yields a marriage of basic and normalizing narrowing. The safe blocking rule is specific to basic narrowing and is particularly useful in conjunction with the rewriting rule. Finally, the unfolding rule allows for a variety of search strategies that reduce the number of don't know alternatives that need to be explored.
Scribe support in GNU emacs
Authors: J. E. Black
Venue: Proceedings of the 7th annual international conference on Systems documentation (1989)

Think of Scribe1 as a compiler for a document description language; Scribe is NOT an editor. Scribe is a &ldquo;high level&rdquo; document processing system, or a &ldquo;composition engine&rdquo; which permits users to deal with documentation at a higher level of abstraction than is possible with &ldquo;word-processors&rdquo; or &ldquo;page processors.&rdquo; One of the methods used to provide this higher level of abstraction is the separation2 of the &ldquo;form&rdquo; or &ldquo;layout&rdquo; of the document from the &ldquo;content;&rdquo; thus avoiding distraction of the document's author with superfluous details of document format. This frees the writer to concentrate on the content of a document, rather than its format. With the increasing popularity of WYSIWYG3 style editors, which are more properly described as &ldquo;page processing&rdquo; systems; fewer people are willing to insert the type of &ldquo;mark-up&rdquo; commands required to properly use a &ldquo;document processing&rdquo; system such as Scribe. Described herein are a set of support functions, written in a dialect of LISP, which provide assistance to the Scribe user during the preparation and composition of documents. These support functions provide &ldquo;short-cuts&rdquo; for insertion of Scribe mark-up, as well as certain features useful during composition and maintenance of large documents. Collectively, these support functions are called &ldquo;Scribe Mode&rdquo; and are written to be used with the &ldquo;GNU Emacs&rdquo; editor.4 GNU Emacs is known to run under the Unix5 and VAX/VMS6 operating systems, and various versions have been observed to operate on a wide variety of host computers, and other operating systems.
Planning for advising
Authors: J. McKendree, J. Zaback
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems (1988)

Effective advice depends on knowledge of the plans and goals of the person requiring help. Planning advice must be at a cognitively appropriate level for the user. HICCUPS, a dynamic planning system for a direct manipulation statistics program, is based on an ideal user model. Plans are generated from goals inferred from explicit goal statements from the user, knowledge about the statistics program, and the recent interactions with the interface. This exploitation of environmental information and inherent domain structure to restrict the amount of search and inferencing is a vital part of intelligent reasoning which is both fast and effective.
Modelling and performance evaluation of multiprocessor based packet switches
Authors: J. L. Melús, E. Sanvicente, J. Magriñá
Venue: ACM SIGMETRICS Performance Evaluation Review (1988)

This paper presents an approximate analytic model for the performance analysis of a class of multiprocessor based packet switches. For these systems, processors and common memory modules are grouped in clusters, each of them composed of several processor-memory pairs that communicate through a multiple bus interconnection network. Intercluster communication is also achieved using one or more busses. The whole network operates in a circuit-switched mode. After access completion, a processor remains active for an exponentially distributed random time. Access times are also exponential with different means, depending upon the location (local, cluster, external) of the referenced module. The arbitration is done on a priority basis. The performance is predicted by computing the average number of switched packets per time unit. Other related indexes are also given. Numerical results are obtained rather easily by solving a set of two algebraic equations. Simulation is used to validate the accuracy of the approximations used in the model.
Design of a dependency-directed compiler for constraint propagation
Authors: Roy Feldman
Venue: Proceedings of the 1st international conference on Industrial and engineering applications of artificial intelligence and expert systems - Volume 1 (1988)

This paper describes COCO (COnstraint COmpiler), an optimizing compiler for a constraint language embedded within a frame system. The approach to constraint optimization is based on the following observation: when there are multiple inputs to a constraint network the order in which changes are propagated affects overall computational cost. Any uniform algorithm for propagating values through a network that does not take into account data dependencies will produce sub-optimal results. COCO performs a dependency-based partitioning of constraints, allowing it to group constraints to obtain efficiency gains by merging equivalent computations. This helps to produce code that propagates constraints with a minimum of run-time overhead. We will illustrate the design of COCO and its relationship to other work.
Binary Decision Tree Test Functions
Authors: S. Aborhey
Venue: IEEE Transactions on Computers (1988)

A class of multivariable logic functions which are suitable for use as binary decision tree node test functions is considered. These functions can be regarded as a natural extension of the polarity test normally used. The properties of these functions are discussed. A method for obtaining a reduced but not necessarily optimal tree is presented.
Hypertext and software engineering
Authors: R. Balzer, M. Begeman, P. K. Garg, M. Schwartz, B. Shneiderman
Venue: Proceedings of the second annual ACM conference on Hypertext (1989)

The purpose of this panel is to bring together researchers in software engineering and hypertext and help identify the major issues in the application of hypertext technology and concepts to software engineering and vice versa.
Proposed criteria for accreditation of computer information systems programs
Authors: Robert Cannon, John Gorgone, Tom Ho, John D. McGregor
Venue: ACM SIGCSE Bulletin (1988)

A working group, representing ACM, DPMA, and IEEE-CS, was formed to draft a set of guidelines, including criteria, for the accreditation of computer information systems' undergraduate programs. The guidelines and criteria are summarized below. Faculty: Typically a minimum of 4 faculty, with 3 full time, are needed. Normally, 25% of a faculty member's time should be available for scholarly activity and development. Teaching loads should not exceed 12 hours and should not exceed 4 courses with 2 preparations. Curriculum: Curricular assume a 120 semester hour, four year, baccalaureate program. The program should consist of approximately 30% computer information systems, 20% business, at least 40% in general education and up to 10% other. Forty to 60 percent of the CIS portion should cover a broad core that includes a) computer concepts and software systems, b) program, data, and file structures, c) data management, d) data and computer communications, and e) systems analysis and design. Students should be exposed to a variety of programming languages and be proficient in one structured language. The remaining courses should cover breadth and depth. Resources: Appropriate computing facilities must exist for students and faculty. Adequate software and documentation must be available. Students: Established standards and procedures must insure that graduates have the requisite qualifications to function as CIS professionals. Institutional Support: Adequate support must be provided to support the faculty, department office administration, and library. Faculty support includes leave programs, reasonable teaching loads, competitive salaries, and travel support.
A tutorial on SEE WHY and WITNESS
Authors: A. R. Gilman, C. Billingham
Venue: Proceedings of the 21st conference on Winter simulation (1989)

SEE WHY and WITNESS are companion products for visual interactive simulation. SEE WHY is a general purpose discrete event simulation system that offers special integrated features for graphical display and run time interaction. It also provides user programmable extensions to both the display and interaction capabilities. These facilities are highlighted in the discussion of SEE WHY.WITNESS has been developed from SEE WHY. It is a simulation program for manufacturing operations that fully exploits the visual and interactive capabilities of SEE WHY in bringing simulation modeling to the non-specialist. The phases of WITNESS modeling are covered in some detail as well as the characteristics of the user interface. The paper concludes with an overview of the ability to extend the WITNESS program with an interface to SEE WHY.
The Performance of Flow Graph Locking
Authors: M. H. Eich, Sharon M. Garard
Venue: IEEE Transactions on Software Engineering (1990)

The performance of flow graph locking (FGL) is compared with that of two-phase locking (2PL). As the data sharing level increases, FGL has a better response time than 2PL. Regardless of the data sharing or multiprogramming levels, FGL usually facilitates a better throughput rate than 2PL.
An object-oriented methodology for database/knowledgebase coupling: an implementation of the structured entity model in Nexpert system
Authors: Kunihiko Higa, R. L. Sheng
Venue: ACM SIGMIS Database (1989)

Advantages of a coupled database/knowledgebase (DB/KB) have been widely recognized by both researchers and practitioners. The issue addressed in this paper is how to achieve a natural and effective DB/KB coupling. A major weakness of a typical database system is its lack of semantic support. A knowledge-based system can provide semantic support to a database system. On the other hand, development of a large effective knowlgedebase is difficult because of its limited capacity to and maintain factual data. A database system can help a knowledge-based system overcome this weakness. Thus DB/KB coupling enhances functionality of both participating database systems and knowledge-based systems. The Structured Entity Model (SEM) method, an object-oriented methodology which initially was developed as a logical database design, is capable of accommodating a natural and effective DB/KB coupling design. SEM is derived from System Entity Structure, which is a hierarchical knowledge representation for simulation modeling. Because of the hierarchical structure and decomposition constructs of SEM, it can help a designer perform top-down structured analysis and design of databases. SEM also achieves a high level of semantic expressiveness by using a frame representation for entities and three general association categories (aspect, specialization, and multiple decomposition) for relationships. Update and query constraints and other semantics can be stored in each frame. This also enables SEM to have high potential as a knowledge representation scheme for a knowledgebase. Since both database schema and knowledge structure are produced from the same SEM structure, they are naturally coupled through a common SEM structure. In this paper, the use of SEM as a methodology for producing a coupled DB/KB is described. SEM is implemented using Nexpert system This implementation is illustrated through a DB/KB coupling example based on an Integrated Office Information System (IOIS)
Market realities of rule-based software for lawyers: where the rubber meets the road
Authors: R. W. Morrison
Venue: Proceedings of the 2nd international conference on Artificial intelligence and law (1989)

Part One of this paper briefly describes existing rule-based software for lawyers. Part Two turns to the difficulties that have beset lawyers willing to consider use of these programs. Part Three argues that the difficulties will be surmounted gradually because of competition between firms and leads to the final part that considers how the legal market is accepting rule-based software.
EVA: an experimental video annotator for symbolic analysis of video data
Authors: W. E. Mackay
Venue: ACM SIGCHI Bulletin (1989)

There is a joke about the man who has a map of the world ... with a scale of 1 mile to 1 mile. Sometimes video has the same character; it can be difficult to compress in useful ways. Sometimes you have to see all of it to understand any of it. Even so, the use of video as a research tool has been increasing rapidly, due partly to the reduction in equipment costs and partly to increased work in the areas of human factors and user interface design. This paper describes some of the issues surrounding capturing, recording, analyzing and presenting video data and describes a prototype system, called EVA, that is designed to address some of these issues.
Optimizing SQL queries for parallel execution
Authors: G. von Bultzingsloewen
Venue: ACM SIGMOD Record (1989)

The optimization problem discussed in this paper is the translation of an SQL query into an efficient parallel execution plan for a multiprocessor database machine under the performance goal of reduced response times as well as increased throughput in a multiuser environment. We describe and justify the most important research problems which have to be solved to achieve this task, and we explain our approach to solve these problems.
Programming languages should NOT have comment statements
Authors: M. J. Kaelbling
Venue: ACM SIGPLAN Notices (1988)

The purpose of this paper is to open discussion on the adequacy and design of commenting techniques in programming (and, indeed, all computer processing) languages. The argument is made that the common notion of comment statements is too simplistics, and that a powerful alternative exists. A distinction is made between simple comment statements and scoped comments. Two types of scoped comments are mentioned, and their weaknesses are considered. The paper ends with a call for language designers to address this issue.
The simulation process: avoiding the problems and pitfalls
Authors: R. Sadowski
Venue: Proceedings of the 21st conference on Winter simulation (1989)

This tutorial will present an approach to conducting a simulation project that will aid in avoiding many common problems and pitfalls. The presentation will provide recommendations on how to scope the project, develop a functional specification, formulate and construct the model, verify and validate, collect data, document the work and perform the required analysis. The intent is to provide the novice simulation modeler with proven techniques for conducting a successful simulation project. A variety of case studies will be presented during the tutorial to illustrate both the right and wrong ways to conduct a project.
Residual hermite normal form computations
Authors: Paul D. Domich
Venue: ACM Transactions on Mathematical Software (TOMS) (1989)

This paper extends the class of Hermite normal form solution procedures that use modulo determinant arithmetic. Given any relatively prime factorization of the determinant value, integral congruence relations are used to compute the Hermite normal form. A polynomial-time complexity bound that is a function of the length of the input string exists for this class of procedures. Computational results for this new approach are given.
Database programming in Machiavelli&mdash;a polymorphic language with static type inference
Authors: Atsushi Ohori, Peter Buneman, Val Breazu-Tannen
Venue: Proceedings of the 1989 ACM SIGMOD international conference on Management of data (1989)

Machiavelli is a polymorphically typed programming language in the spirit of ML, but supports an extended method of type inferencing that makes its polymorphism more general and appropriate for database applications. In particular, a function that selects a field &fnof; of a records is polymorphic in the sense that it can be applied to any record which contains a field &fnof; with the appropriate type. When combined with a set data type and database operations including join and projection, this provides a natural medium for relational database programming. Moreover, by implementing database objects as reference types and generating the appropriate views &mdash; sets of structures with &ldquo;identity&rdquo; &mdash; we can achieve a degree of static type checking for object-oriented databases.
Complexity of query processing in databases with OR-objects
Authors: T. Imielinski, K. Vadaparty
Venue: Proceedings of the eighth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1989)

If ground disjunctive facts are admitted into a database the data complexity of conjunctive queries grows from PTIME into CoNP with some simple examples of CoNP-Complete conjunctive queries. A natural question which arises in this context is whether it is possible to syntactically characterize those queries which are &ldquo;bad&rdquo; (i.e. CoNP-Complete) from those that are &ldquo;good&rdquo; (i.e. with PTIME data complexity) given a predefined 'pattern&rdquo; of disjunctions in the database. In this paper, we study the data complexity of conjunctive queries. We give a complete syntactic characterization of CoNP-Complete conjunctive queries for a class of disjunctive databases called OR-Databases. Our results can be used in complexity tailored design where design decisions are motivated by complexity of query processing. Also, we establish that a similar complete syntactic characterization for disjunctive queries, with negation allowed only on base predicates, would answer the open problem &ldquo;Does Graph Isomorphism belong to PTIME or is it NP-Complete?&rdquo;.
Navigating integrated facilities: initiating and terminating interaction sequences
Authors: P. Barnard, A. MacLean, M. Wilson
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems (1988)

Human performance data are reported for two dialogue conventions involving menu interactions with integrated facilities. Users prepared material for overhead foils in a six session experiment. An initiation style of dialogue in a flexible menu hierarchy was compared with a strict hierarchy involving explicit termination of dialogue sequences. Although tasks could be performed in the same number of steps with either interface, initiation had greater time and transaction costs than termination. The results are discussed in relation to the trade-offs that need to be considered in designing for navigational flexibility and to requirements for modeling user behavior.