ppxscal/embedding_network huggingface dataset:
Converting from Pascal to Modula-2 in the undergraduate curriculum
Authors: Philippe J. Gabrini, J. Mack Adams, Barry L. Kurtz
Venue: Proceedings of the seventeenth SIGCSE technical symposium on Computer science education (1986)

Modula-2 has been adopted as the primary programming language at New Mexico State University. This paper discusses the reasons which led to this choice of a new primary programming language. It compares some of the features of Pascal, Modula-2 and Ada. It also gives the results of our implementation efforts.
Combinatory code and a parallel packet-based computational model
Authors: A Cheese
Venue: ACM SIGPLAN Notices (1987)

Up until now the widespread use of functional languages has been hindered by the lack of any sort of efficient implementation. The main reason for this has been the need to support an environment, a mapping of variables in scope to their current values. By using combinatory logic it is possible to translate a functional program into a form in which all bound variables have been removed. The transformed program will be string of constants which selectively ship to each expression that part of the environment it references. As a result of this the hardware needed to produce a physical realization of the model should be very much simpler than that of normal Von Neumann computing engines. In order to exploit the implicit parallelism present in a functional program a computational model based upon a parallel packet based graph reduction scheme is proposed which allows code to be treated in exactly the same manner as data. In particular the code graph can be regarded as a lazily constructed data structure.
Matching algorithms to array processors
Authors: S. Y. Kung, S. N. Jean, S. C. Lo
Venue: Proceedings of the 1987 Fall Joint Computer Conference on Exploring technology: today and tomorrow (1987)

This paper first reviews a methodology of mapping regular computations onto VLSI array processors. In this mapping methodology, algorithms are described by dependence graphs (DGs). The objective of the mapping is to design an array to directly support the requirements of an algorithm. Several algorithm matching techniques are then proposed to ensure the efficient execution of algorithms on a given array. Since the communication links of a given array may not meet the requirements of an algorithm or the size of a given array may be too small for some algorithms (from the mapping point of view), algorithm matching can be viewed as constrained mapping. The matching can be achieved through different modifications of the mapping methodology. To reduce I/O lines, the DG is extended such that I/O are handled by boundary processing elements (PEs) only. Time sharing schemes are devised to match algorithms to mesh and hypercube arrays. To meet the array size constraints, partitioning, which decomposes large problems into several smaller subproblems, and multiprojection, which applies the mapping method multiple times, are also addressed.
Remote pipes and procedures for efficient distributed communication
Authors: David K. Gifford, Nathan Glasser
Venue: ACM Transactions on Computer Systems (TOCS) (1988)

We describe a new communication model for distributed systems that combines the advantages of remote procedure call with the efficient transfer of bulk data. Three ideas form the basis of this model. First, remote procedures are first-class values which can be freely exchanged among nodes, thus enabling a greater variety of protocols to be directly implemented in a remote procedure call framework. Second, a new type of abstract object, called a pipe, allows bulk data and incremental results to be efficiently transported in a type-safe manner. Unlike procedure calls, pipe calls do not return values and do not block a caller. Data sent down a pipe is received by the pipe's sink node in the order sent. Third, the relative sequencing of pipes and procedures can be controlled by combining them into channel groups. Calls on the members of a channel group are guaranteed to be processed in order. Application experience with this model, which we call the Channel Model, is reported. Derived performance bounds and experimental measures demonstrate k pipe calls can perform min( 1 + (r/p), k) times faster than k procedure calls, where r is the total roundtrip remote communication time and p is the procedure execution time.
Selective interpretation as a technique for debugging computationally intensive programs
Authors: B. B. Chase, R. T. Hood
Venue: Papers of the Symposium on Interpreters and interpretive techniques (1987)

As part of Rice University's project to build a programming environment for scientific software, we have built a facility for program execution that solves some of the problems inherent in debugging large, computationally intensive programs. By their very nature such programs do not lend themselves to full-scale interpretation. In moderation however, interpretation can be extremely useful during the debugging process. In addition to discussing the particular benefits that we expect from interpretation, this paper addresses how interpretive techniques can be effectively used in conjunction with the execution of compiled code. The same implementation technique that permits interpretation to be incorporated as part of execution will also permit the execution facility to be used for debugging parallel programs running on a remote machine.
Identifying early adopters of large software systems
Authors: Leslie D. Ball Ismael G. Dambolena Hubert D. Hennessey
Venue: ACM SIGMIS Database (1987)

In recent years the software industry has undergone rapid growth, yet little is known about the software acquisition process. This study examines the relationship between the acquisition of large data base management systems (DBMSs) and several characteristics of organizations and their personnel. Seven hypothesis related to the adoption of DBMSs are tested through a survey and the results are reported.
Projective transformations of the parameter of a Bernstein-B&eacute;zier curve
Authors: Richard R. Patterson
Venue: ACM Transactions on Graphics (TOG) (1985)

The definitions of polynomial and rational Bernstein-B&eacute;zier curves are reviewed and extended to include homogeneous parametrizations. Then the effects of a projective transformation of the parameter space are described in terms of a group representation. This representation is used to answer the following questions: (1) If the control points are held fixed, when do two different sets of weights determine the same rational curve? (2) How do we find the control points for a subdivision of the original curve?
Creating highly-interactive and graphical user interfaces by demonstration
Authors: Brad A. Myers, William Buxton
Venue: Proceedings of the 13th annual conference on Computer graphics and interactive techniques (1986)

It is very time-consuming and expensive to create the graphical, highly-interactive styles of user interfaces that are increasingly common. User Interface Management Systems (UIMSs) attempt to make the creation of user interfaces easier, but most existing UIMSs cannot create the low-level interaction techniques (pop-up pull-down and fixed menus, on-screen "light buttons", scroll-bars, elaborate feedback mechanisms and animations, etc.) that are frequently used. This paper describes Peridot, a system that automatically creates the code for these user interfaces while the designer demonstrates to the system how the interface should look and work. Peridot uses rule-based inferencing so no programming by the designer is required, and Direct Manipulation techniques are used to create Direct Manipulation interfaces, which can make full use of a mouse and other input devices. This allows extremely rapid prototyping of user interfaces.
LOGOS: An APL programming environment
Authors: David B. Allen, Leslie H. Goldsmith, Mark R. Dempsey, Kevin L. Harrell
Venue: Proceedings of the international conference on APL (1986)

Programming environments support the creation, maintenance, execution, and deployment of programs. The development of complex application systems written in APL has always been hampered by the lack of a comprehensive programming environment for the language. This paper presents a new approach to software creation and management through the use of LOGOS, an integrated software development environment for APL. LOGOS provides support to the user, developer, and manager of application systems. Its centralized, uniform structure removes much of the drudgery of dealing with software, encourages sharing of ideas and programs among users, and leads to increased programmer productivity and improved software reliability.
A comparison of textual information retention from CRT terminals and paper
Authors: Mitchell F. Wyle
Venue: ACM SIGCHI Bulletin (1987)

An experiment measuring the difference in reading comprehension and retention between paper and CRT displays is described. Results, conclusions, and implications are presented. The results indicate that textual information is retained significantly better when it is presented on paper.
Recursive linear hashing
Authors: K Ramamohanarao, R Sacks-Davis
Venue: ACM Transactions on Database Systems (TODS) (1984)

A modification of linear hashing is proposed for which the conventional use of overflow records is avoided. Furthermore, an implementation of linear hashing is presented for which the amount of physical storage claimed is only fractionally more than the minimum required. This implementation uses a fixed amount of in-core space. Simulation results are given which indicate that even for storage utilizations approaching 95 percent, the average successful search cost for this method is close to one disk access.
Information-flow and data-flow analysis of while-programs
Authors: Jean-Francois Bergeretti, Bernard A. Carré
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1985)

Until recently, information-flow analysis has been used primarily to verify that information transmission between program variables cannot violate security requirements. Here, the notion of information flow is explored as an aid to program development and validation. Information-flow relations are presented for while-programs, which identify those program statements whose execution may cause information to be transmitted from or to particular input, internal, or output values. It is shown with examples how these flow relations can be helpful in writing, testing, and updating programs; they also usefully extend the class of errors which can be detected automatically in the &ldquo;static analysis&rdquo; of a program.
Designing a quality voice: an analysis of listeners' reactions to synthetic voices
Authors: M. B. Rosson, A. J. Cecala
Venue: ACM SIGCHI Bulletin (1986)

Eight subjects listened to a set of synthetic voices reflecting a crossing of four voice qualities: head size, pitch, richness and smoothness. The listeners evaluated the voices on sixteen perceptual scales, and judged each voice's appropriateness for twenty voice-output scenarios. Factor analysis of the perceptual ratings recovered two factors, fullness and clarity. A similar analysis of the appropriateness ratings revealed three situational factors, information, entertainment and feedback. Further analyses indicated that the voice qualities associated with the three situational factors were quite different, and suggest ways to optimize voices used for a particular purpose.
Design principles and configuration of CTRON
Authors: T. Wasano, M. Ohminami, Y. Kobayashi, T. Ohkubo, S. Sakamura
Venue: Proceedings of the 1987 Fall Joint Computer Conference on Exploring technology: today and tomorrow (1987)

Information communication networks are being developed which provide a variety of services integrating information processing and communications. A high realtime processing capability and high reliability are required in switching and other nodes making up such networks. Multi-user processing and large-scale data processing functions are also required, especially in information processing nodes. In addition, as the network develops, in order to realize a diversity of services reliably and efficiently it should be possible to incorporate similar functions in a number of nodes, and to change the distribution of functions among nodes. Software portability across nodes is thus an important factor. This paper will outline the design principles and configuration of CTRON, which is a set of operating system interfaces designed to meet these requirements in information communication networks.
Methodology for Business System Development
Authors: R. N. Mathur
Venue: IEEE Transactions on Software Engineering (1987)

The methodology presented here is currently being used in the design of Standard Automated Financial System (STAFS), which is a large scale business system for use by the 14 Naval Laboratories across the nation. The system will be operational in 1987-1988 time-frame. The methodology presented is suitable for all transaction oriented systems. It enforces documentation of design at all levels of system development process allowing managers and users a high visibility into the design. It highlights the human engineering aspects of system design and utilizes thread definition, data designer, and structured design techniques. The methodology requires the use of system verification diagrams which specify the user requirements. The design produces an integrated database with security mechanisms to restrict unauthorized users from accessing data they are not authorized to use. The threads also serve as a useful tool for system testing.
Experience with a data base of programs
Authors: N Belkatir, J Estublier
Venue: Proceedings of the second ACM SIGSOFT/SIGPLAN software engineering symposium on Practical software development environments (1987)

The Adele system was initially designed as a specialized data base of programs for an experimental Pascal environment, with a focus on configuration management. Later, it was redesigned as a general data base for large scale programs written in any language. The focus here was on side effect control and real problems of large industrial software products [Estublier84]. Then in a third stage Adele evolved into the kernel for programming environments and was developed as an industrial product, with emphasis on portability, flexibility, distribution, control of rights and on the structure of the software products [Belkhatir86]. This paper describes the experience gained in the use of the Adele data base of programs.1
RAPID: Prototyping control panel interfaces
Authors: Karl Freburger
Venue: Conference proceedings on Object-oriented programming systems, languages and applications (1987)

RAPID is a design environment to support human factors specialists in designing user interfaces for small control panels. RAPID permits modeling of both the appearance and behavior of operator interfaces. Its main goal is to allow exploration of a greater number of design alternatives by decreasing the time and effort required to generate and evaluate those alternatives. It is a graphically-based system intended to be used by non-programmers. RAPID is implemented in Smalltalk-80.
Software errors and complexity: an empirical investigation0
Authors: Victor R. Basili, Barry T. Perricone
Venue: Communications of the ACM (1984)

An analysis of the distributions and relationships derived from the change data collected during development of a medium-scale software project produces some surprising insights into the factors influencing software development. Among these are the tradeoffs between modifying an existing module as opposed to creating a new one, and the relationship between module size and error proneness.
Teaching computer networks as a writing intensive course
Authors: James R. F. Quirk
Venue: ACM SIGCSE Bulletin (1988)

A senior level course in Computer Networks was included in Radford University's Writing-Intensive Course program. This implied that writing was used in every facet of the course by the students and by the instructor. The volume and the diversity of the writing significantly enhanced the educational experience from both points of view. Some beneficial effects and some detrimental ones on the amount of subject matter covered were experienced. The fundamental nature of the course, however, was not altered, and the net effects of the writing are seen as very beneficial.
Efficient tests for top-down termination of logical rules
Authors: Jeffrey D. Ullman, Allen Van Gelder
Venue: Journal of the ACM (JACM) (1988)

Considered is the question of whether top-down (Prolog-like) evaluation of a set of logical rules can be guaranteed to terminate. The NAIL! system is designed to process programs consisting of logical rules and to select, for each fragment of the program, the best from among many possible strategies for its evaluation. In the context of such a system, it is essential that termination tests be fast. Thus, the &ldquo;uniqueness&rdquo; property of logical rules is introduced. This property is satisfied by many of the common examples of rules and is easily recognized. For rules with this property, a set of inequalities, whose satisfaction is sufficient for termination of the rules, can be generated in polynomial time. Then a polynomial test for satisfaction of constraints generated by this process is given.
A computational framework for lexical description
Authors: Graeme D. Ritchie, Stephen G. Pulman, Alan W. Black, Graham J. Russell
Venue: Computational Linguistics (1987)

To achieve generality, natural language parsers require dictionaries which handle lexical information in a linguistically motivated but computationally viable manner. Various rule formalisms are presented which process orthographic effects, word structure, and lexicai redundancy in a manner which allows the statement of linguistic generalisations with a clear computational interpretation. A compact description of a medium-sized subset of the English lexicon can be stated using these formalisms. The proposed mechanisms have been implemented and tested, but require to be refined further if they are to be regarded as an interesting linguistic theory.
The ADA/ED system: a large-scale experiment in software prototyping using SETL
Authors: Philippe Kruchten, Edmond Schonberg
Venue: Technology and Science of Informatics (1984)

In my view, the most interesting aspect of this experiment with prototypes is its implications for software engineering: everyone talks about prototypes today, but is anyone really producing any? Or, amongst those who do produce prototypes, how many can resist the temptation, once the prototype is complete, to treat it as the finished product? The experiences described here present a clear cut case: it would have been impossible to write the compiler immediately in its final form&mdash;the cost of perpetual modifications, in response to revisions to ADA, of a compiler written in a `traditional' language would have been intolerably high&mdash;designing a prototype seems to have been the only way out. Finally, once a decision in favor of prototypes has been taken, either as a way of giving concrete expression to a set of specifications or a way of `protecting' a particular design, a choice of language in which to write the prototype has to be made. The advantages of SETL are clearly demonstrated in this article, with particular stress laid on the facilities it provides for using several semantic levels, and therefore refining a prototype in successive stages until the final product emerges, or a program very close to the final product. Translation into a language providing for a higher performance level, or at any rate into a more common language, C in this case, is then a simple task. My guess is that a lot of TSI readers are going to want more information on SETL to enable them to use it in similar circumstances in the future. To sum up, this article is particularly interesting for three reasons: it provides a closer understanding of ADA, demonstrates the value of prototypes in software design, and makes a plea in favor of SETL which does indeed appear wholly satisfactory as a language in which to write such prototypes. &mdash;From the Commentary by E. Girard &mdash;Commentary recommended by E. A. Feustel, Sherborn, MA
Distributed programming in Argus
Authors: Barbara Liskov
Venue: Communications of the ACM (1988)

Argus&mdash;a programming language and system developed to support the implementation and execution of distributed programs&mdash;provides mechanisms that help programmers cope with the special problems that arise in distributed programs, such as network partitions and crashes of remote nodes.
A Synthesis Algorithm for Reconfigurable Interconnection Networks
Authors: Insup Lee, David Smitley
Venue: IEEE Transactions on Computers (1988)

The performance of a parallel algorithm depends in part on the interconnection topology of the target parallel system. An interconnection network is called reconfigurable if its topology can be changed between different algorithm executions. Since communication patterns vary from one parallel algorithm to another, a reconfigurable network can effectively support algorithms with different communication requirements. It is shown how to generate a network topology that is optimized with respect to the communication patterns of a given task. The algorithm presented takes as input a task graph and generates as output a topology that closely matches the given input graph. The topologies generated by the algorithm are analyzed with respect to optimum interconnection topologies for the best, worst, and average cases. Simulation results verify the average-case performance prediction and confirm that, on the average, the optimum topologies are generated.
Using dual approximation algorithms for scheduling problems theoretical and practical results
Authors: Dorit S. Hochbaum, David B. Shmoys
Venue: Journal of the ACM (JACM) (1987)

The problem of scheduling a set of n jobs on m identical machines so as to minimize the makespan time is perhaps the most well-studied problem in the theory of approximation algorithms for NP-hard optimization problems. In this paper the strongest possible type of result for this problem, a polynomial approximation scheme, is presented. More precisely, for each &egr;, an algorithm that runs in time O((n/&egr;)1/&egr;2) and has relative error at most &egr; is given. In addition, more practical algorithms for &egr; = 1/5 + 2-k and &egr; = 1/6 + 2-k, which have running times O(n(k + log n)) and O(n(km4 + log n)) are presented. The techniques of analysis used in proving these results are extremely simple, especially in comparison with the baroque weighting techniques used previously. The scheme is based on a new approach to constructing approximation algorithms, which is called dual approximation algorithms, where the aim is to find superoptimal, but infeasible, solutions, and the performance is measured by the degree of infeasibility allowed. This notion should find wide applicability in its own right and should be considered for any optimization problem where traditional approximation algorithms have been particularly elusive.
PLAY: pattern-based symbolic cell layout: Part I: transistor placement
Authors: W.-J. Lue, L. P. McNamee
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

This paper describes an approach to symbolic transistor placement from a CMOS circuit net-list as part of an automatic custom cell layout system, PLAY. It consists of two parts, extraction and refinement. The extraction process defines a set of patterns using local connection relationships. Refinement procedures assign topological attributes to each transistor through these patterns and relationships along with other heuristic knowledge. This paradigm provides a new way to embed designers' knowledge for circuit layout. Although only CMOS circuit layout placements are demonstrated, this approach can readily be extended to other technologies. Comparison between PLAY and manual design results is also reported.