ppxscal/embedding_network huggingface dataset:
A Software Size Model
Authors: June Verner, Graham Tate
Venue: IEEE Transactions on Software Engineering (1992)

A bottom-up approach to software size estimation is described. It first identifies factors affecting software size, thus obtaining size explanation equations, and then seeks suitable predictors based on those explanation factors which can be used for size estimation. The approach, or model, is bottom-up in that it sizes individual software components or modules first, and then obtains subsystem and system sizes by summing component sizes. Since components may have different purposes and characteristics, the model allows for the partitioning of system components into several different types, each component type having different size explanation and estimation equations. The partitioning is not fixed, but depends on the particular software development technology. The model is applied to several different software systems, including both business applications and systems programs.
A Performance Analysis of Timed Synchronous Communication Primitives
Authors: Insup Lee, Susan B. Davidson
Venue: IEEE Transactions on Computers (1990)

The performance of two algorithms for timed synchronous communication between a single sender and a single receiver is analyzed. Each weakens the definition of correct timed synchronous communication in a different way, and exhibits a different undesirable behavior. Their sensitivity to various parameters is discussed. These parameters include how long the processes are willing to wait for communication to be successful, how well synchronized the processes are, the assumed upper bound on message delay, and the actual end-to-end message delay distribution. The fault tolerance of the algorithms is discussed and a mixed strategy is proposed that avoids some of the performance problems.
The role of term symmetry in E-completion procedures
Authors: Ralph W. Wilkerson, Blayne E. Mayfield
Venue: Proceedings of the 1990 ACM annual conference on Cooperation (1990)

A major portion of the work and time involved in completing an incomplete set of reductions using an E-completion procedure such as the one described by Knuth and Bendix or its extension to associative-commutative equational theories as described by Peterson and Stickel is spent calculating critical pairs and subsequently testing them for confluence and coherence. A pruning technique which removes from consideration those critical pairs that represent redundant or superfluous information can make a marked difference in the run time and efficiency of an E-completion procedure to which it is applied. In this paper, a technique is proposed for removing critical pairs from consideration at various points before, during, or after their formation. This method is based on the property of term symmetry, which will be defined and explored with respect to E-unification and E-completion procedures. Informally, term symmetry exists between two terms when one can be transformed into the other through variable renaming. By identifying and eliminating various forms of term symmetry which arise between syntactic structures such as, reductions, critical pairs, subterms, and unifiers, it is possible to derive an E-completion procedure that produces the same results without processing these symmetric redundancies.
What is scalability?
Authors: Mark D. Hill
Venue: ACM SIGARCH Computer Architecture News (1990)

Scalability is a frequently-claimed attribute of multiprocessor systems. While the basic notion is intuitive, scalability has no generally-accepted definition. For this reason, current use of the term adds more to marketing potential than technical insight.In this paper, I first examine formal definitions of scalability, but I fail to lind a useful, rigorous definition of it. I then question whether scalability is useful and conclude by challenging the technical community to either (1) rigorously define scalability or (2) stop using it to describe systems.
Information Encoding with Two-Dimensional Bar Codes
Authors: Theo Pavlidis, Jerome Swartz, Ynjiun P. Wang
Venue: Computer (1992)

Various schemes proposed for storing more information in the bar code label are reviewed. The concept of information density is introduced. The constraints imposed by the reading technology are addressed, and various recently proposed stacked bar codes are surveyed. Certain non-bar-code solutions are discussed.
Teaching user interface development to software engineering and computer science majors
Authors: Gary Perlman
Venue: ACM SIGCHI Bulletin (1990)

There is a critical need for timely and usable curriculum development materials for teaching user interface development to software engineering and computer science students. An updated version of the Software Engineering Institute's curriculum module on User Interface Development has been released. This paper provides an overview of the module, its history, and how it has been used.At the Software Engineering Institute (SEI) at Carnegie-Mellon University there is a Curriculum Development Project as part of the Education Program (Gibbs, 1989). A major goal of the curriculum development project is to devise model curricula and support-materials for teaching all topics in software engineering. For topics such as unit testing, software design, requirements analysis, and so on, there are curriculum modules to help teachers prepare courses. I have written, and recently revised, a module on User Interface Development (Perlman, 1989b), described in detail below. It has proven to be useful to all people interested in the teaching of user interface development to software engineers. Some of my experiences with the module are summarized in Perlman (1988).The module is not a book nor a course, but contains information to help others prepare short- or full-term courses on user interface development.
Extending structure, type, and expression in APL2
Authors: J. Phillip Benkhard
Venue: Proceedings of the international conference on APL '91 (1991)

The two principal directions of APL today are discussed in the light of recent standards committee meetings. The approach often taken to an extended standard was to place features of both dialects into a work space and force them to work; this might be called a top down approach with hammer. Herein APL2, considered as a representative of nested array systems, is assumed as a base. A growth path is described toward a system which includes features similar to some found in boxed array systems. A parallel discussion beginning with a boxed system and extending toward nested arrays would be welcome. Perhaps working toward a common goal could provide more inspiration than striving to preserve pieces of the past.
Toward integrating imperative and logic programming paradigms: WYSIWYG approach to PROLOG programming
Authors: Claudio Delrieux, Pablo Azero, Fernando Tohme
Venue: ACM SIGPLAN Notices (1991)

This paper presents an integration of imperative and logic programming, implemented on a PROLOG interpreter. The idea is to exploit the interpreter's execution model to support a procedural style of coding, and to imcorporate the notion of state by means of the use of the internal database. Both the coding style and some experimental structured-like programming constructs are discussed. The proposed integration provides hints to achieve an extensible language (i. e. iterative control structures that may be useful when tail recursion optimization is not possible) and also benefits in learning the equivalence between its declarative and operational semantics.
On the expressive power of the bounded iteration construct
Authors: Xiaolei Qian
Venue: Proceedings of the second international workshop on Database programming languages (1989)

The bounded-iteration construct foreach x in R|p(x) do t(x) is very commonly used in database programming, due to the fact that database programs are dominated by data retrieval and manipulation tasks rather than complex computations. Hence in database programming language design, it is important to understand the expressive power of the bounded-iteration construct and its relationship with other language constructs. We study the bounded-iteration construct within the context of a simple database programming language called the iterative transaction language. The language is shown to have NPTIME expressive power, and the deterministic subclass of it has PTIME expressive power. We show that the bounded-iteration construct is essential for achieving polynomial-time expressiveness, by characterizing its relationship with other constructs in the language. We also identify a natural subclass of iterative transactions called first-order transactions with exactly first-order expressive power. The complexity of first-order transactions in terms of iteration depth and intermediate states is connected further to the complexity of first-order updates in terms of quantification depth.
Design and evaluation of a distributed asynchronous VLSI crossbar switch controller for a packet switched supercomputer network
Authors: Andrew J. DuBois, John Rasure
Venue: ACM SIGARCH Computer Architecture News (1991)

A key component in a new high-speed prototype network, called the Multiple Crossbar Network (MCN) being developed at Los Alamos National Laboratory, is a crossbar switching core and its controller. This switching core allows for up to 32 (800 Mbit/second) connections to pass through it simultaneously. The motivation for this network is to allow visualization data to be sent at movie rate speeds to a users workstation from a supercomputer. This paper reviews the key concepts and components of the MCN, and then focuses on the behavioral level design of a distributed asynchronous VLSI controller chip set for the switching core. A unique design methodology is presented and then applied to the controller which uses an externally distributed chip set, and distributed asynchronous finite state machines internally.
A plea for a readable Prolog programming style
Authors: R. McLaughlin
Venue: ACM SIGPLAN Notices (1990)

Prolog is not like most computer languages. In Prolog a particular action can bring forth many results. This means special care must be taken when writing code. Not only must the code meet standards of readability but it must also allow us to understand the process by which the coder intended inferences to take place.Prolog use a set of rules based on pure logic to make inferences from a set of data. In general, there is no telling how many items will satisfy the set of rules we have contrived. It is from this that both the power and danger of Prolog come.I will attempt to discuss ways in which Prolog programs can be written to improve maintenance and debugging. I will also try to discuss limitations of the language.
Dynamic Processor Self-Scheduling for General Parallel Nested Loops
Authors: Zhixi Fang, Peiyi Tang, Pen-Chung Yew, Chuan-Qi Zhu
Venue: IEEE Transactions on Computers (1990)

A processor self-scheduling scheme is proposed for general parallel nested loops in multiprocessor systems. In this scheme, programs are instrumented to allow processors to schedule loop iterations among themselves dynamically at run time without involving the operating system. The scheme has two levels. At the low level, it uses simple fetch-and-op operations to take advantage of the regular structure in the innermost parallel loop nests; at the high level, the irregular structure of the outer loops (parallel or serial) and the IF-THEN-ELSE constructs are handled by using dynamic parallel linked lists. The larger granularity or the processes at the high level easily justifies the added overhead incurred from maintaining such dynamic data structures. The use of guided self-scheduling (GSS) and shortest-delay self-scheduling (SDSS) in this scheme is analyzed.
Miro: Visual Specification of Security
Authors: Allan Heydon, Mark W. Maimone, J. D. Tygar, Jeannette M. Wing, Amy Moormann Zaremski
Venue: IEEE Transactions on Software Engineering (1990)

Miro is a set of languages and tools that support the visual specification of file system security. Two visual languages are presented: the instance language, which allows specification of file system access, and the constraint language, which allows specification of security policies. Miro visual languages and tools are used to specify security configurations. A visual language is one whose entities are graphical, such as boxes and arrows, specifying means stating independently of any implementation the desired properties of a system. Security means file system protection: ensuring that files are protected from unauthorized access and granting privileges to some users, but not others. Tools implemented and examples of how these languages can be applied to real security specification problems are described.
ASIC design with VHDL
Authors: David B. Alford
Venue: ACM SIGDA Newsletter (1991)

In the past several years a new hardware description language has emerged as a standard in the electronic computer aided design world. Named the VHSIC Hardware Design Language (the first CAD language to have a recursive acronym), it is quickly being adopted throughout the electronics industry as the design language of choice. Two factors are driving the swift adoption of this language: many CAE vendors are supporting the language for design and simulation purposes, and hardware synthesis using the HDL has become a working reality. ASIC design in the VHSIC Hardware Description Language is proliferating throughout the electronic design world.
Structured analysis and object-oriented design are compatible
Authors: Ken Shumate
Venue: ACM SIGAda Ada Letters (1991)

Some form or other of object-oriented design has become common, even standard, for the design of Ada programs. Some form or other of structured analysis is and has long been standard for the specification of software requirements. Recent discussions in the software development community advocate object-oriented analysis as being preferable to structured analysis, especially for Ada software development; such discussions further assert that structured analysis and object-oriented design are incompatible. Others have argued for the effectiveness of combined use of the two methods. The topic has become controversial.It is the thesis of this paper that structured analysis is a desirable way to specify software requirements, and that structured analysis and object-oriented design are compatible and work effectively together.
Ada tasking as a tool for ecological modelling
Authors: A. G. Murray
Venue: ACM SIGAda Ada Letters (1990)

Ada [1] has many advantages for writing programs of ecological models. Tasks are the most novel and enable programs to be written in a way that is closer to the structure of such models. As the flows for ecological models are usually unconditional, deadlock of tasks can be detected by simple diagrams. Tasks aid debugging of ecological programs.
FORTRAN subroutines for general Toeplitz systems
Authors: Per Christian Hansen, Tony F. Chan
Venue: ACM Transactions on Mathematical Software (TOMS) (1992)

This paper presents FORTRAN 77 implementations of the lookahead Levinson algorithm of Chan and Hansen [7, 8] for solving symmetric indefinite and general Toeplitz systems. The algorithms are numerically stable for all Toeplitz matrices that do not have many consecutive ill-conditioned leading principal submatrices, and also produce estimates of the algorithm and matrix condition numbers. In contrast, the classical Levinson algorithm is only guaranteed to be numerically stable for symmetric positive definite Toeplitz matrices, and no condition estimate is produced.
A dual knowledge representation for a domain-independent Intelligent Training System
Authors: Raymond W. Kolbe, Ronald W. Broome, Marijke F. Augusteijn
Venue: Proceedings of the 1992 ACM annual conference on Communications (1992)

A dual knowledge representation is discussed which encompasses the instructor's organization of pedagogical knowledge and the domain expert's structuring of conceptual knowledge. This representation forms the basis of the knowledge structures of ITS Challenger, a domain-independent environment in which intelligent training systems (ITS) can be developed. The intelligent features of systems developed through ITS Challenger include adaptation to the student's knowledge level, dynamic problem generation, error analysis and student feedback. The instructional design methodology is based on objectives that are associated with learning types and instructional strategies. An ITS in orbital dynamics has been developed and has demonstrated its effectiveness as an instructional tool.
The Proteus presentation system
Authors: Susan L. Graham, Michael A. Harrison, Ethan V. Munson
Venue: ACM SIGSOFT Software Engineering Notes (1992)

Software development environments can increase user productivity by presenting information in more useful ways. This paper describes Proteus, the presentation system of Ensemble, a software development environment that supports a wide variety of language and document capabilities. Proteus provides a set of services which allow the appearance of software development documents, such as programs or design specifications, to be determined by formal specifications of style. Proteus is based on a generic model of presentation services and is intended for use with a wide variety of media.
A Lingua Franca for Concurrent Logic Programming
Authors: Hamish Taylor
Venue: IEEE Transactions on Software Engineering (1992)

Two of the more important concurrent logic programming languages with nonflat guards are GHC and Parlog. They balance the requirements of having clean semantics and providing good control facilities rather differently, and their respective merits are compared and contrasted. Since concurrent logic programming would benefit from both, but neither language is able to express all the programs expressible in the other language, a lingua franca of these languages is defined and justified. A method is given for translating GHC and Parlog to and from it. The method preserves the arities and execution conditions of each clause. It enables a lingua franca implementation to support both languages transparently, and to provide a simple concurrent logic programming language suitable for programming in its own right.
Adequacy of checksum algorithms for computer virus detection
Authors: Doug Varney
Venue: ACM SIGSMALL/PC Notes (1991)

Checksums, long used for random error detection in communications, is now being employed to detect changes for integrity purposes. For example, checksums are being used for the detection of computer viruses [POZ86]. The checksum algorithms for detecting random errors are not sufficient against an entity that wishes to "fool" the checksum mechanism. This entity wants to be able to insert a forgery in place of the original data such that an unsuspecting user does not realize the forgery has occurred. This paper describes checksum algorithms and features of checksum algorithms to deter this type of forgery.
Refinement methods for geometric bounds in constructive solid geometry
Authors: Stephen Cameron, Chee-Keng Yap
Venue: ACM Transactions on Graphics (TOG) (1992)

In constructive solid geometry, geometric solids are represented as trees whose leaves are labeled by primitive solids and whose internal nodes are labeled by set-theoretic operations. A bounding function in this context is an upper or lower estimate on the extent of the constituent sets; such bounds are commonly used to speed up algorithms based on such trees. We introduce the class of totally consistent bounding functions, which have the desirable properties of allowing surprisingly good bounds to be built quickly. Both outer and inner bounds can be refined using a set of rewrite rules, for which we give some complexity and convergence results. We have implemented the refinement rules for outer bounds within a solid modeling system, where they have proved especially useful for intersection testing in three and four dimensions. Our implementations have used boxes as bounds, but different classes (shapes) of bounds are also explored. The rewrite rules are also applicable to relatively slow, exact operations, which we explore for their theoretical insight, and to general Boolean algebras. Results concerning the relationship between these bounds and active zones are also noted.
A browsing interface for S-expressions
Authors: Kei Yuasa
Venue: ACM SIGPLAN Notices (1991)

This paper presents a new system for Lisp object inspecting. The author has implemented a system called "List Window" which provides Lisp programmers with a method for inspecting S-expressions on a screen. This system was designed in order to help Lisp programming, especially debugging.When developing the List Window system, it was necessary to output, a big list into a given sized terminal with proper indentations. The system sets a focal point in a list and truncates elements which are far from the focus. Main parts of this paper describe this method of truncating branches of a list.
A flexible communication abstraction for nonshared memory parallel computing
Authors: Gail A. Alverson, William G. Griswold, David Notkin, Lawrence Snyder
Venue: Proceedings of the 1990 ACM/IEEE conference on Supercomputing (1990)

Writing parallel numerical programs is difficult. One problem is that the regular code and communication structure of typical parallel algorithms often becomes obfuscated when special cases at the boundaries of the computation are handled. Another problem is that parallel architectures can have vastly different communication structures, which makes it hard to maintain efficiency when a program is ported. This problem arises in practice because communication information either is defined implicitly by the local process codes or else is statically embedded in the compiler for the language. In this paper, we show how a communication abstraction called the port ensemble can simplify the handling of boundary conditions and the efficient porting of programs. A port ensemble provides an explicit interface between computation and communication descriptions, thus separating the communication structure from the details of local computation and from the compiler. Port ensembles structure ports, symbolic names to and from which a process can write and read values. To simplify the expression of boundary conditions, ports can be bound not only to ports on other processors, but also to non-existent neighbors (along the edge of the computation) using special objects that represent and implement constants, variables, and arbitrary functions. Port ensembles also provide direct access to the communication structure, which simplifies changing the structure to one appropriate for a new target architecture.
The complexity of heaps
Authors: Svante Carlsson, Jingsen Chen
Venue: Proceedings of the third annual ACM-SIAM symposium on Discrete algorithms (1992)

In this paper, we investigate the complexity of heaps. In particular, we study the construction problem and the search problem for heaps. We derive an adversary-based lower bound for the heap construction problem. It is shown that 1.5(n + 1)&ndash;log(n + 1)&ndash;2 comparisons are necessary to construct a heap of size n in the worst case. This is the first non-trivial adversary lower bound for this problem, which improves the previous best lower bound based on an information theoretical argument for the heap construction. Furthermore, we prove fairly trivial tight upper and lower bounds on the number of comparisons needed to search for a given element in a heap. An optimal 3/4n-time search algorithm is presented. Our lower bound for searching is also demonstrated by an adversary argument, which improves the information theory bound for the problem as well.