ppxscal/embedding_network huggingface dataset:
The influence of color on program readability and comprehensibility
Authors: Gerard K. Rambally
Venue: ACM SIGCSE Bulletin (1986)

Readability and comprehensibility are among the most important attributes of a program. A program that is easy to read and understand is easier to test, maintain, and modify. Many factors affect program readability and comprehensibility, including variable names, internal documentation, modularity, and so on. This paper investigates the influence of color on program readability and comprehension. Three color schemes were used: Color-scheme-A used different colors to indicate the different blocks in a program; Color-scheme-B used different colors to identify the various statements function in the program; and the third color scheme was the usual black-and-white programs. This study showed that subjects who used programs with Color-scheme-B had the highest mean score for program comprehension, followed by those who used Color-scheme-A. Subjects who used black-and-white programs scored the lowest on the comprehension quiz.
Parallel Discrete Event Simulation Using Shared Memory
Authors: Daniel A. Reed, Allen D. Malony, Bradley McCredie
Venue: IEEE Transactions on Software Engineering (1988)

With traditional event list techniques, evaluating a detailed discrete event simulation model can often require hours or even days of computation time. By eliminating the event list and maintaining only sufficient synchronization to ensure causality, parallel simulation can potentially provide speedups that are linear in the number of processors. We present a set of shared memory experiments using the Chandy-Misra distributed simulation algorithm to simulate networks of queues. Parameters of the study include queueing network topology and routing probabilities, number of processors, and assignment of network nodes to processors.
Reconfiguring a hypercube in the presence of faults
Authors: J. Hastad, T. Leighton, M. Newman
Venue: Proceedings of the nineteenth annual ACM symposium on Theory of computing (1987)

We consider the computational power of a hypercube containing a potentially large number of randomly located faulty components. In particular, we describe algorithms for embedding an N/2-node hypercube in an N-node hypercube with faulty processors. Provided that the processors of the N-node hypercube are faulty with probability p < 1/2, and that the faults are independently distributed, we show that with high probability, adjacent cells in the N/2-node hypercube are mapped to functioning cells at distance 3 or less apart in the N-node hypercube. The algorithm is deterministic, easy to implement and runs in &Ogr;(log N) steps using only local control. We also describe ways to produce embeddings which allow for low delay simulations, as well as ways to use a faulty hypercube to efficiently simulate a completely functioning hypercube of the same size.
A 15 Year Perspective on Automatic Programming
Authors: Robert Balzer
Venue: IEEE Transactions on Software Engineering (1985)

Automatic programming consists not only of an automatic compiler, but also some means of acquiring the high-level specification to be compiled, some means of determining that it is the intended specification, and some (interactive) means of translating this high-level specification into a lower-level one which can be automatically compiled.
Design of a simplified pipeline processor for floating point addition (SFPA)
Authors: Satyendra Bhama
Venue: ACM SIGSMALL/PC Notes (1988)

The SPFA processor is a pipeline processor for floating point addition. The arithmatic unit, as well as the memory unit, have been pipelined, and thus, constitute four basic modules on which four sets of data are operated upon simultaneously. Apart from these, there is a control unit which performs the sequencing of operations, a latch enable unit and an input unit with a keyboard which allows human interface.
Protocol conversion&mdash;correctness problems
Authors: Simon S Lam
Venue: Proceedings of the ACM SIGCOMM conference on Communications architectures protocols (1986)

Consider the problem of providing a logical channel for message exchange between two user processes in a network environment. When is protocol conversion needed? To answer this question, we first define a model of layered architectures. Specifically, three stepwise refinement rules are given. Any architecture that can be obtained by a sequence of applications of the stepwise refinement rules is said to be well-structured. We show that this class of well-structured architectures has several correctness properties. It is also very general and includes many well-known networking and internetworking architectures in the literature. Logical connectivity in such an architecture is defined recursively. As a result, to determine if a logical channel can be provided between two user processes, it is sufficient to examine peer protocols specified for each level of the architecture's hierarchy of processes one at a time. Thus the original problem reduces to the problem of determining if a set of processes will interoperate. When protocol conversion is needed to achieve interoperability between processes that implement different protocols, how should it be done? How does one prove that a conversion is correct? What is meant by a correct conversion? We propose the use of projections and image protocols (previously developed by Lam and Shankar for protocol verification [10]) for specifying conversions and for reasoning about the correctness of conversions. Given two processes implementing different protocols P and Q, our objective is to find the largest protocol that is an image protocol of P as well as Q. The correctness of the conversion is a consequence of the correctness properties of image protocols. There are several open problems. Most importantly, heuristics are used for finding the necessary image protocol for conversion. Although, an image protocol common to both P and Q can always be found, it may not be easy to find one with useful functionality. There are also some implementation and design issues to be addressed, such as: the construction of converters that are transparent and converters that add functionality to an image protocol common to P and Q.
The stiff integrators in the NAG library
Authors: M. Berzins, R. W. Brankin, I. Gladwell
Venue: ACM SIGNUM Newsletter (1988)

We have designed a new generation of stiff ordinary differential equation (ODE) solvers for the NAG LIbrary. They replace existing routines which are functionally inferior and have much less user-friendly interfaces. The redesign provides:(i) continuity and stability for users of NAG stiff solvers;(ii) general simplification of interfaces;(iii) new functionality - solving implicit and differential/algebraic systems;(iv) flexibly structured open ended software (based on implicit ODE methods) so that adding new integration methods is a simple matter;(v) a design which facilitates using the solvers from other packages;(vi) an interface which permits the solvers to be used at the "assembly language" level in packages written in more "robust" languages than Fortran77 (for example ADA).
A survey of current methods for the elimination of initialization bias in digital simulation
Authors: Delbert L. Kimbler, Barry D. Knight
Venue: Proceedings of the 20th annual symposium on Simulation (1987)

Initialization bias in digital simulation typically arises in estimating a steady-state statistic from replicated data. While methods have been developed to avoid this bias, such as batch means, the problem remains in some simulation contexts. This report surveys current methods for dealing with this bias and assesses their effectiveness and usefulness.
The Qualified Function Approach to Analysis of Program Behavior and Performance
Authors: Armen Gabrielian, Lawrence P. McNamee, David J. Trawick
Venue: IEEE Transactions on Software Engineering (1985)

The notion of a qualified function is introduced as a general means of representing the parameters of dynamic systems. Two specific types of qualified functions are defined for the analysis of the behavior and performance of structured programs. Transformation functions represent the values of variables during execution and timing algorithms express the execution times of programs symbolically. Complete rules of derivation for transformation functions and timing algorithms are given for the control mechanisms of sequence, selection, fixed loop, and while statement. Deterministic and stochastic simplification of transformation functions and timing algorithms are investigated and methods of eliminating recursion for expressions corresponding to while statements are studied.
Fixed-point conversion, multiplication, and division in Ada
Authors: T Froggatt
Venue: ACM SIGAda Ada Letters (1987)

This paper briefly describes classical fixed-point working, then turns to the facilities offered by the Ada language. It argues that the default-power-of-two scaling coupled with the optionalness of 'small representation specifications have effectively rendered Ada's fixed-point facilities impotent; but that a full implementation would provide an appropriate level of functionality.Ada's accuracy requirements lead to a high run-time cost for certain fixed-point operations; but it is shown that the existence of "perfect" scaling factors, calculated by the ancient method of continued fractions, ensures that this cost it at least bounded. Proposals are made to reduce this cost without impact upon existing Ada users.
XC- A language for embedded rule based systems
Authors: E. Nuutila, J. Kuusela, M. Tamminen, J. Veilhti, J. Arkko
Venue: ACM SIGPLAN Notices (1987)

We report on experiences in the design of the programming language XC. It is an extension of C++ and combines abstract data types with rule based programming. Our design decisions are validated by three application prototypes and by benchmarking XC and OPS83. The experiences raise some critique on the RETE algorithm and on C++ as a host language. However, most of the results are also applicable to other host languages that support data abstraction. XC has been designed specifically to be used in embedded real-time expert systems.
Design and implementation of a programming contest for high school students
Authors: Doug Myers, Linda Null
Venue: Proceedings of the seventeenth SIGCSE technical symposium on Computer science education (1986)

The Computer Science Department at Northwest Missouri State University sponsors a computer programming contest each spring for area high school students. The contest draws about 250 people each year. The Olympiad has provided valuable student contact for the Computer Science faculty. The Computer Science Department views the Olympiad as a very powerful recruiting tool for the university. This paper will address the development of the Computer Science Olympiad at Northwest Missouri State University.
Cursor movement during text editing
Authors: John D. Gould, Clayton Lewis, Vincent Barnes
Venue: ACM Transactions on Information Systems (TOIS) (1985)

Nine participants used a full-screen computer text editor (XEDIT) with an IBM 3277 terminal to edit marked-up documents at each of three cursor speeds (3.3, 4.7, and 11.0 cm/s). These speeds occur when a user continuously holds down an arrow key to move the cursor more than one character position (i.e., in repeat or typamatic mode). Results show that cursor speed did not seem to act as a pacing device for the entire editing task. Since cursor speed is a form of system response, this finding is in contrast with the generally found positive relation between system-response time and user-response time. Participants preferred the Fast cursor speed, however. Overall, more than one-third of all keystrokes were used to move the cursor. We estimate that 9-14 percent of editing time was spent controlling and moving the cursor, regardless of cursor speed.
Modula-2 projects for an operation-systems course: racing sorts and multiple windows
Authors: Michael B. Feldman
Venue: ACM SIGCSE Bulletin (1986)

A Modula-2-based project series is presented. This three-project sequence is suitable for an undergraduate course in operating systems or systems programming, and embodies the three important principles of concurrent programming, algorithm animation, and code modification. Heavy use is made of the Modula-2 module; much of the code in the projects is given away to the students, who must then adapt it for the purpose. The project series requires the animation of several sort algorithms, which are invoked as independent tasks under Modula-2 and display their state in different screen windows. These projects do not require special hardware and can be run using a &ldquo;dumb terminal&rdquo; 24 x 80 screen.
The standards factor
Authors: Jon Meads
Venue: ACM SIGCHI Bulletin (1988)

Little News has come my way since the last issue of the Bulletin. There was supposed to be a meeting of the Human Factors Society Human-Computer Interaction Standards Committee in Palo Alto this January. I was expecting to receive word on it, but have not.
An architectural perspective on a memory access controller
Authors: M. Freeman
Venue: Proceedings of the 14th annual international symposium on Computer architecture (1987)

In this paper a CMOS memory access controller chip is described that provides the basis for achieving high-performance 68020-based (68030-based) systems. This controller matches the speed of the memory system to that of the microprocessor by providing a virtual cache mechanism where address translations are only required when there is a cache miss. This mechanism also facilitates the construction of shared-memory multiprocessor system where the controller manages a memory hierarchy consisting of cache memory, local memory, and shared global memory.
TRC: An expert system compiler
Authors: D D Kary, P L Juell
Venue: ACM SIGPLAN Notices (1986)

TRC is a compiler that is useful in building expert systems. The input is a rule based language. The output is a set of C language procedures. The principal advantages of TRC over existing expert system construction tools are speed of execution and portability of the code generated by TRC. The name TRC is an acronym for Translate Rules to C.
Software reuse myths
Authors: Will Tracz
Venue: ACM SIGSOFT Software Engineering Notes (1988)

Reusing software is a simple, straightforward concept that has appealed to programmers since the first stored-program computer was created. Unfortunately, software reuse has not evolved beyond its most primitive forms of subroutine libraries and brute force program modification. This paper analyzes nine commonly believed software reuse myths. These myths reveal certain technical, organizational, and psychological software engineering research issues and trends.
GDSS: a brief look at a new concept in decision support
Authors: Gerardine DeSanctis, Brent Gallupe
Venue: Proceedings of the twenty-first annual conference on Computer personnel research (1985)

An exciting new concept is emerging in the area of decision support. This involves the development of computer-based systems for use by groups of people who are jointly responsible for making decisions. Known as &ldquo;Group Decision Support Systems&rdquo; (GDSS) they can be useful to committees, review panels, executive board meetings, task forces, and groups of managers who work together on either a regular or one-time basis. The precise design of a GDSS will vary depending on the proximity of group members to one another and the duration of the decision-making session. This paper presents an overview of the GDSS concept.
Local Distributed Deadlock Detection by Cycle Detection and Clusterng
Authors: Israel Cidon, Feffrey M. Jaffe, Moshe Sidi
Venue: IEEE Transactions on Software Engineering (1987)

A distributed algorithm for the detection of deadlocks in store-and-forward communication networks is presented. At first, we focus on a static environment and develop an efficient knot detection algorithm for general graphs. The knot detection algorithm uses at most O(n2+ m) messages and O(log (n)) bits of memory to detect all deadlocked nodes in the static network. Using the knot detection algorithm as a building block, a deadlock detection algorithm in a dynamic environment is developed. This algorithm has the following properties: It detects all the nodes which cause the deadlock. The algorithm is triggered only when there is a potential for deadlock and only those nodes which are potentially deadlocked perform the algorithm. The algorithm does not affect other processes at the nodes.
New developments in Pascal-SC
Authors: G. Bohlender, Ch. Ullrich
Venue: ACM SIGPLAN Notices (1988)

PASCAL-SC is an efficient programming language for scientific computation which was developed at the beginning of the eighties as an extension of standard PASCAL. It provides arithmetical operations with controlled rounding and an optimal scalar product. Functions with arbitrary result type and an operator concept permit the realization of higher arithmetical operations, such as matrix-vector operations. The application of PASCAL-SC for the development of reliable numerical software raised several wishes for further extension. These extensions have been incorporated in the language.A new data type dotprecision together with arithmetic operations is introduced permitting scalar product expressions to be evaluated with maximum accuracy in a convenient manner. Dynamic arrays and a module concept support the definition of numeric libraries. Over loading of functions and procedures improve the readability of scientific programs. A program for the verified solution of linear systems illustrates the strength of the new language.
Oaklisp: an object-oriented scheme with first class types
Authors: Kevin J. Lang, Barak A. Pearlmutter
Venue: Conference proceedings on Object-oriented programming systems, languages and applications (1986)

The Scheme papers demonstrated that lisp could be made simpler and more expressive by elevating functions to the level of first class objects. Oaklisp shows that a message based language can derive similar benefits from having first class types.
A minimal CISC
Authors: Douglas W. Jones
Venue: ACM SIGARCH Computer Architecture News (1988)

The minimal CISC architecture presented here is an extremely simple zero-address architecture suitable for microprogrammed implementation. It is sufficiently simple to be introduced in one lecture, with time left over for discussion of implementation or enhancement options.
Unifying view of recent LALR(1) lookahead set algorithms
Authors: Fred Ives
Venue: ACM SIGPLAN Notices (1986)

Since the introduction of LALR parsing, several algorithms have been presented for the computation of the lookahead sets needed to produce an LALR parser. The algorithm in Aho and Ullman[1] has perhaps received the widest exposure. The recent algorithms by DeRemer and Pennello[2] and Park, Choe, and Chang[4] are the most efficient.A new algorithm has been developed from an algorithm originally based on the Aho and Ullman algorithm and subsequently modified to take advantage of the efficiencies introduced by the DeRemer and Pennello algorithm. The new algorithm performs better than the Park, Choe, and Chang algorithm, and both perform better than the DeRemer and Pennello algorithm. The reasons for the relative performances are easily understood when the algorithms are presented in a common light.
Benchmarking simple database operations
Authors: W. B. Rubenstein, M. S. Kubicar, R. G. G. Cattell
Venue: ACM SIGMOD Record (1987)

There are two widely-known benchmarks for database management systems the TP1 benchmarks (Anon et al [1985]), designed to measure transaction throughout, and the Wisconsin benchmarks (Bitton, Dewitt, Turbyfil [1984]), designed to measure the performance of a relational query processor. In our work with databases on engineering workstations, we found neither of these benchmarks a suitable measure for our applications' needs. Instead, our requirements are for response time for simple queries. We propose benchmark measurements to measure response time, specifically designed for the simple, object-oriented queries that engineering database applications perform. We report results from running this benchmark against some database systems we use ourselves, and provide enough detail for others to reproduce the benchmark measurements on other relational, object-oriented, or specialized database systems. We discuss a number of factors that make an order of magnitude improvement in benchmark performance caching the entire database in main memory, avoiding query optimization overhead, using physical links for prejoins, and using an alternative to the generally-accepted database &ldquo;server&rdquo; architecture on distributed networks.
Another alternative for bordered systems
Authors: William Knight
Venue: ACM SIGNUM Newsletter (1987)

This partitioned system, [EQUATION] is to be solved many times with the same n by n matrix, A, but differing n-vectors, b, c, and f, and differing scalars d and g. By using a bordering algorithm, A need be inverted once only. The remaining computation, done often, uses 2n2+3n+constant long operations (multiplications + divisions). Govaerts and Pryce (1987) consider the situation when A is nearly singular although (1) itself is well conditioned, reporting that using a bordering computation followed by iterative refinement of the initial poor solution works well, being both simple and practical.
Development and implementation of the Magnavox generic Ada basic mathematics package
Authors: K Rehmer
Venue: ACM SIGAda Ada Letters (1987)

This paper explains development work on a mathematics library at Magnavox during the summer of 1985 and some revisions which were made in the early summer of 1986. Briefly, sources for a basic mathematics library will be explored, reasons behind some of the design decisions made will be discussed. Finally, a brief presentation of the method of testing will be given.
SoftDA&mdash;a computer-aided software engineering system
Authors: S. Isoda
Venue: Proceedings of the 1987 Fall Joint Computer Conference on Exploring technology: today and tomorrow (1987)

This paper outlines &ldquo;SoftDA&rdquo; (Software Design Automation) which is a computer-aided software engineering system based on workstations now under development at Nippon Telegraph and Telephone (NTT). In the course of developing a program, the SoftDA system acquires all the relevant information which consists not only of requirements specifications, design specifications and program code, but also of the relationship information between their elements. The system utilizes this software information to support the entire software life cycle, i.e., requirements, design, coding, debugging and maintenance. Some of its characteristic features are stepwise refinement of design written in a design language which allows mixed usage of Japanese and the Ada language, module design based on the object-oriented design methodology, software reuse support including revision of existing programs, and visual representation of program execution.