ppxscal/embedding_network huggingface dataset:
APL procedures (user defined operators, functions and token strings)
Authors: Robert Hodgkinson
Venue: ACM SIGAPL APL Quote Quad (1986)

This paper describes some central aspects of an APL implementation on a Hewlett Packard Minicomputer. The development of these ideas led to an elegant, consistent underlying structure for all procedures, where a procedure is defined as a structured sequence of APL expressions, instances of which are niladic functions, ambivalent functions, monadic operators and dyadic operators. Further to this idea, the introduction of two new functions (tokenize and detokenize) and a single hyperoperator (&nabla;) gave rise to the following features; Ability to manipulate functions and operators as APL objects Extended Assignment applied to all APL objects Ability to store preset (or initialized) values into the header of any procedure Make direct use of the (usually restricted) facet of tokenizing and detokenizing in APL to generate token strings, which may be applied by the programmer to form individual variants of &squ;FX, &squ;CR and/or &nabla; editing. These extensions have been superimposed upon a basic imprint of SHARP APL.
Facilitating Mixed Language Programming in Distrbuted Systems
Authors: Roger Hayes, Richard D. Schlichting
Venue: IEEE Transactions on Software Engineering (1987)

An approach for facilitating mixed language programming in distributed systems is presented. It is based on adding a generic remote procedure call facility to each language, and the use of a type system to describe procedural interfaces, as well as data to be transferred between procedures. This type scheme also specifies a machine-independent representation for all data. By defining standard mappings for each programming language, the data conversions required for cross-langauge calls may be performed, automatically in most cases, by active agents that provide the interface between program components written in different languages. When necessary, explicit control of the conversation is possible. A prototype implementation of a system based on this approach has been constructed on a collection of machines running Berkeley UNIX®.
Data descriptors: a compile-time model of data and addressing
Authors: R. C. Holt
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1987)

Data descriptors, which have evolved from Wilcox's value descriptors [16], are a notation for representing run-time data objects at compile time. One of the principal reasons for developing this notation was to aid in the rapid construction of code generators, especially for new microprocessors. Each data descriptor contains a base, a displacement, and a level of indirection. For example, a variable x lying at displacement 28 from base register B3 is represented by this data descriptor: @B3.28. The general form of a data descriptor is @kb.d.i where k gives the number of levels of indirection, b is a base, d is a displacement, and I is an index. Data descriptors are convenient for representing addressing in Fortran (with static allocation and common blocks), in Pascal and Turing (with automatic allocation and stack frames), and in more general languages such as Euclid and PL/I. This generality of data descriptors allows code generation to be largely independent of the source language. Data descriptors are able to encode the addressing modes of typical computer architectures such as the IBM 360 and the PDP-11. This generality of data descriptors allows code generation to be largely machine independent. This paper gives a machine independent method of storage allocation that uses data descriptors. Techniques are given for local optimization of basic arithmetic and addressing code using data descriptors. Target machine dependencies are isolated so that the part of the code generator that handles high-level addressing (such as subscripting) is machine independent. The techniques described in this paper have proven effective in the rapid development of a number of production code generators.
Augmenting a software engineering projects course with oral and written communication
Authors: John G. Meinke
Venue: Proceedings of the eighteenth SIGCSE technical symposium on Computer science education (1987)

The institutional philosophy and educational goals determine the computing needs for any college. The philosophy and goals are also affected by various factors such as size and type of institution, geographic setting, community resources and background of the student body.
CASE: an integrated design environment for algorithm-driven architectures
Authors: D. C. A. Bulterman
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

One use of integrated System-level Design Automation (SLDA) tools is during the development of algorithm-driven architectures. In this paper, we discuss an approach to structuring SLDA tools that provides application-area designers a flexible range of support for migrating algorithms into special-purpose computer networks. Using digital signal processing applications as an example problem domain, we discuss the motivation and current implementation of a set of design migration tools used to develop real-time distributed architectures as part of the Brown Computer-Aided System Engineering (CASE) project.
One, two, three . . . infinity: lower bounds for parallel computation
Authors: F E Fich, F Meyer auf der Heide, P Ragde, A Wigderson
Venue: Proceedings of the seventeenth annual ACM symposium on Theory of computing (1985)

In this paper we compare the power of the two most commonly used concurrent-write models of parallel computation, the COMMON PRAM and the PRIORITY PRAM. These models differ in the way they resolve write conflicts. If several processors want to write into the same shared memory cell at the same time, in the COMMON model they have to write the same value. In the PRIORITY model, they may attempt to write different values; the processor with smallest index succeeds. We consider PRAM's with n processors, each having arbitrary computational power. We provide the first separation results between these two models in two extreme cases: when the size m of the shared memory is small (m &le; n&egr;, &egr; < 1), and when it is infinite. In the case of small memory, the PRIORITY model can be faster than the COMMON model by a factor of &THgr;(log n), and this lower bound holds even if the COMMON model is probabilistic. In the case of infinite memory, the gap between the models can be a factor of &OHgr;(log log log n). We develop new proof techniques to obtain these results. The technique used for the second lower bound is strong enough to establish the first tight time bounds for the PRIORITY model, which is the strongest parallel computation model. We show that finding the maximum of n numbers requires &THgr;(log log n) steps, generalizing a result of Valiant for parallel computation trees.
Binomial random variate generation
Authors: Voratas Kachitvichyanukul, Bruce W. Schmeiser
Venue: Communications of the ACM (1988)

Existing binomial random-variate generators are surveyed, and a new generator designed for moderate and large means is developed. The new algorithm, BTPE, has fixed memory requirements and is faster than other such algorithms, both when single, or when many variates are needed.
Experience with CommonLoops
Authors: James Kempf, Warren Harris, Roy D'Souza, Alan Snyder
Venue: ACM SIGPLAN Notices (1987)

CommonLoops is an object-oriented language embedded in Common Lisp. It is one of two such languages selected as starting points for the Common Lisp Object System (CLOS) which is currently being designed as a standard object-oriented extension to Common Lisp. This paper reports on experiences using the existing Portable CommonLoops (PCL) implementation of CommonLoops. The paper is divided into two parts: a report on the development of a window system application using the CommonLoops programming language, and a description of the implementation of another object-oriented language (CommonObjects) on top of the CommonLoops metaclass kernel, paralleling the two aspects of CommonLoops: the programming language and the metaclass kernel. Usage of the novel features in CommonLoops is measured quantitatively, and performance figures comparing CommonLoops, CommonObjects on CommonLoops, and the native Lisp implementation of CommonObjects are presented. The paper concludes with a discussion about the importance of quantitative assessment for programming language development.
A comparison of three computer algebra systems for the solution of a problem in hydrodynamic lubrication
Authors: R. M. Corless
Venue: ACM SIGSAM Bulletin (1988)

With the plethora of computer algebra languages and systems available today, it is useful to compare some of these languages when a research problem highlights differences between them. The problem that we have been studying arises in the field of hydrodynamic lubrication theory, and provides a moderate-to-severe test of the capabilities of a computer algebra system. The problem was solved in part by Jeffrey amp; Onishi [1984] using CAMAL (Fitch, 1983) on an IBM 3081 at Cambridge University. Further calculations were needed, however, and CAMAL was no longer available, so since muMATH (Stoutemeyer amp; Rich, 1983) running on various IBM PC compatibles and later Maple (Char et al, 1985) running on a VAX 8550 under VMS version 4.5 were available, it was natural to try these out on the problem. The authors are of course aware of the difficulty in comparing languages running on machines with very widely differing speeds and memory, and the reader is asked to keep this firmly in mind when seeing any run times quoted. What follows is a brief description of the problem, here taken out of its original context and used as a test problem. For a discussion of the problem concentrating on the fluid mechanical theory see Corless amp; Jeffrey (1988a). For a brief description of the complete solution obtained with Maple, see Corless amp; Jeffrey (1988b).
Firmware engineering and microprogramming research at Colorado State University
Authors: Bob Mueller
Venue: ACM SIGMICRO Newsletter (1986)

Most of the firmware engineering research currently under investigation at CSU is focused on methods of automated microcode generation and compaction, particularly retargetable methods. We have developed a prototype for a retargetable microcode compiler, which is depicted in Figure 1. Ideally, the system shown is retargeted by supplying a flow graph machine model for the target machine, and the remainder of the system is invariant.
Director strings as combinators
Authors: Richard Kennaway, Ronan Sleep
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1988)

A simple calculus (the Director String Calculus-DSC) for expressing abstractions is introduced, which captures the essence of the &ldquo;long reach&rdquo; combinators introduced by Turner. We present abstraction rules that preserve the applicative structure of the original lambda term, and that cannot increase the number of subterms in the translation. A translated lambda term can be reduced according to the evaluation rules of DSC. If this terminates with a DSC normal form, this can be translated into a lambda term using rules presented below. We call this process of abstracting a lambda term, reducing to normal form in the space of DSC terms, and translating back to a lambda term an implementation. We show that our implementation of the lambda calculus is correct: For lambda terms with a normal form that contains no lambdas (ground terms), the implementation is shown to yield a lambda calculus normal form. For lambda terms whose normal forms represent functions, it is shown that the implementation yields lambda terms that are beta-convertible in zero or more steps to the normal form of the original lambda term. In this sense, our implementation involves weak reduction according to Hindley et al. [9].
Ada compiler selection for embedded targets
Authors: A. Tetewsky, R. Racine
Venue: ACM SIGAda Ada Letters (1987)

Although mainframe Ada compilers have reached execution as well as reliability performance characteristics of languages such as FORTRAN, the same is not true of embedded system compilers. Finding a reliable cross-compiler for widely used and powerful micro-processors such as the Motorola 68000 family is extremely difficult, if not impossible. First quarter '87 cross-compiler users face many tough trade-offs and additional project costs due to time lost developing compiler work-arounds. Although the user community appreciates the technological challenges of building an Ada compiler, it is still faced with trying to use incomplete and somewhat unstable systems while trying to deliver efficient, ultra-reliable code. In order to help both vendors and users alike, this article presents a set of evaluation criteria that may be used in selecting an Ada compiler for embedded system applications. Given the progress made with mainframe compilers, the major focus is on robustness, reliability, run-time system, and cross-compiler tools.
Discrete Beta-splines
Authors: Barry Joe
Venue: ACM SIGGRAPH Computer Graphics (1987)

Goodman (1985) and Joe (1986) have given explicit formulas for (cubic) Beta-splines on uniform knot sequences with varying szlig;1 and szlig;2 values at the knots, and nonuniform knot sequences with varying szlig;2 values at the knots, respectively. The advantage of the latter formula is that it can also be used for knot sequences with multiple knots. Discrete Beta-splines arise when a Beta-spline curve is subdivided, i.e. the knot sequence is refined so that the curve is expressed in terms of a larger number of control vertices and Beta-splines. We prove that discrete Beta-splines satisfy the same properties as discrete B-splines, and present an algorithm for computing discrete Beta-splines and the new control vertices using the explicit formula of Joe (1986).
Version control in the Inscape environment
Authors: D. E. Perry
Venue: Proceedings of the 9th international conference on Software Engineering (1987)

We present the important issues to be considered in version control mechanisms and characterize and compare the kinds of version control systems extant in current programming environments. We then characterize Inscape's version control mechanism. Invariant, and show that it makes several significant advances in the state of the art. Using Instress (Inscape's module interface specification language) specifications, Invariant provides a better understanding of the notion of parallel versions, a more comprehensive notion of version consistency, and a more flexible method of system composition than current mechanisms. In particular, Invariant provides a formalization of the notions of version equivalence and compatibility that correspond closely with our intuitive (and practical) notions of version equivalence and compatibility. These various forms of version compatibility provide the system builder with the concept of plug-compatibility &mdash; an extremely useful facility in composing systems from component parts.
INSIST: Interactive Simulation in Smalltalk
Authors: Pieter S. van der Meulen
Venue: ACM SIGPLAN Notices (1987)

A functional simulator/editor for VLSI design has been implemented in the Smalltalk-801 system. Users can explore their designs in an highly interactive and graphical manner with &ldquo;close-to-reality&rdquo; tools. The traditional sequence of editing, compiling and simulating the circuit is avoided. During editing, functional Modules can immediately respond to new connections. The simulator, called INSIST, strongly supports hierarchical simulation and design up to gate level. Hardware descriptions of the design can be generated for other CAD systems. From these descriptions layout has been generated. A RISC chip was entered and simulated at three hierarchical levels containing more than 50 Modules.
Increasing students security awareness: article II. What C.S. graduates don`t learn about security concepts and ethical standards
Authors: Janet M. Cook
Venue: ACM SIGCSE Bulletin (1986)

Students think that security is crime prevention, someone else's business. In fact, security is error prevention and is everybody's business. At government and industrial conferences employers complain that C.S. and C.I.S. graduates 1) don't see security as a significant factor in getting their jobs done, and 2) don't have a clear conception of what constitutes ethical professional behavior. This article, demonstrates ways to integrate into existing courses activities that promote students' awareness of professional responsibilities to protect the integrity of the systems and data they work with, and of accepted professional ethical standards.
Database partitioning in a cluster of processors
Authors: Domenico Sacca, Gio Wiederhold
Venue: ACM Transactions on Database Systems (TODS) (1985)

In a distributed database system the partitioning and allocation of the database over the processor nodes of the network can be a critical aspect of the database design effort. In this paper we develop and evaluate algorithms that perform this task in a computationally feasible manner. The network we consider is characterized by a relatively high communication bandwidth, considering the processing and input output capacities in its processors. Such a balance is typical if the processors are connected via busses or local networks. The common constraint that transactions have a specific root node no longer exists, so that there are more distribution choices. However, a poor distribution leads to less efficient computation, higher costs, and higher loads in the nodes or in the communication network so that the system may not be able to handle the required set of transactions. Our approach is to first split the database into fragments which constitute appropriate units for allocation. The fragments to be allocated are selected based on maximal benefit criteria using a greedy heuristic. The assignment to processor nodes uses a first-fit algorithm. The complete algorithm, called GFF, is stated in a procedural form. The complexity of the problem and of its candidate solutions are analyzed and several interesting relationships are proven. Alternate benefit metrics are considered, since the execution cost of the allocation procedure varies by orders of magnitude with the alternatives of benefit evaluation. A mixed benefit evaluation strategy is eventually proposed. A model for evaluation is presented. Two of the strategies are experimentally evaluated, and the reported results support the discussion. The approach should be suitable for other cases where resources have to be allocated subject to resource constraints.
Optimum watchman routes
Authors: W Chin, S Ntafos
Venue: Proceedings of the second annual symposium on Computational geometry (1986)

In this paper we consider the problem of finding shortest routes from which every point in a given space is visible (watchman routes). We show that the problem is NP-hard when the space is a polygon with holes even if the polygon and the holes are convex or rectilinear. The problem remains NP-hard for simple polyhedra. We present O(n) and O(nlogn) algorithms to find a shortest route in a simple rectilinear monotone polygon and a simple rectilinear polygon respectively, where n is the number of vertices in the polygon. Finding optimum watchman routes in simple polygons is closely related to the problem of finding shortest routes that visit a set of convex polygons in the plane in the presence of obstacles. We show that finding a shortest route that visits a set of convex polygons is NP-hard even when there are no obstacles. We present an O(logn) algorithm to find the shortest route that visits a point and two convex polygons, where n is the total number of vertices.
Distributed garbage collection
Authors: J. D. Eckart, R. J. LeBlanc
Venue: Papers of the Symposium on Interpreters and interpretive techniques (1987)

There are two basic approachs to the problem of storage reclamation, process- and processor-based, named for the view point used to recognize when a particular piece of storage can be reclaimed. Examples of the processor approach include mark/sweep and copying algorithms and their variants, while reference counting schemes use a process view of the collection. It is argued that the process approach is better suited for distributed computation where links between dynamically allocated objects may cross processor boundaries. In addition, the process approach allows the heap to be more conveniently shared with other processes in those cases when different processes might not have their own virtual address spaces. A new algorithm using the process approach is given. Its space requirement per object is better than that for reference counting. In addition, a restricted form of pointer replacement is supported which allows circular structures so constructed to be properly collected.
Sequoia: A Fault-Tolerant Tightly Coupled Multiprocessor for Transaction Processing
Authors: Philip A. Bernstein
Venue: Computer (1988)

The Sequoia computer is a tightly coupled multiprocessor that avoids most of the fault-tolerance disadvantages of tight coupling by using a fault-tolerant hardware-design approach. An overview is give of how the hardware architecture and operating system (OS) work together to provide a high degree of fault tolerance with good system performance. A description of hardware is followed by a discussion of the multiprocessor synchronization problem. Kernel support for fault recovery and the recovery process itself are examined. It is shown the kernel, through a combination of locking, shadowed memory, and controlled flushing of non-write-through cache, maintains a consistent main memory state recoverable from any single-point failure. The user shared memory is also discussed.
Neural Nets for Adaptive Filtering and Adaptive Pattern Recognition
Authors: Bernard Widrow, Rodney Winter
Venue: Computer (1988)

The adaptive linear combiner (ALC) is described, and practical applications of the ALC in signal processing and pattern recognition are presented. Six signal processing examples are given, which are system modeling, statistical prediction, noise canceling, echo canceling, universe modeling, and channel equalization. Adaptive pattern recognition using neural nets is then discussed. The concept involves the use of an invariance net followed by a trainable classifier. It makes use of a multilayer adaptation algorithm that descrambles output and reproduces original patterns.
Implementation of an optimizing compiler for VHDL
Authors: J. Bhasker
Venue: ACM SIGPLAN Notices (1988)

We present techniques used to implement an optimizing compiler for the VHSIC hardware description language (VHDL). We present details about the LR parser used to parse the input program. An efficient intermediate representation, called a process graph, is constructed as a result of the parsing. This representation is chosen to facilitate the ease of data flow analyses and optimizations. The process graph is a reducible flow graph because of the restricted subset of VHDL that we work with. The various data flow analyses and optimization techniques that have been implemented are described. This optimizing compiler is being used as a front end for a tool that performs behavioral synthesis.
Distributed systems
Authors: Leonard Kleinrock
Venue: Communications of the ACM (1985)

Growth of distributed systems has attained unstoppable momentum. If we better understood how to think about, analyze, and design distributed systems, we could direct their implementation with more confidence.