ppxscal/embedding_network huggingface dataset:
Components of Typical Undergraduate Software Engineering Courses: Results from a Survey
Authors: Laura M. Leventhal, Barbee T. Mynatt
Venue: IEEE Transactions on Software Engineering (1987)

A survey of undergraduate software engineering courses was conducted. The survey covered the issues of course level, course content, course organization, project characteristics, and department demographics. The descriptive statistics show that the typical course focuses on the software development life cycle and includes a project intended for actual use. The project is carried out by teams of students, with student leaders. A factor analysis disclosed that three different sorts of courses are currently being offered. The most predominant course is the Later-Life Cycle course, which focuses on the later stages of the software life cycle. Detailed design, coding, testing, and maintenance receive in-depth coverage in this style of course, and the student's grades are heavily dependent upon the project. The Early-Life-Cycle course emphasizes requirements analysis, specification, and system design. Written reports are an important component of this course, and the project is again a large portion of the students' grades. The third style of course is the Theoretical-Issues course. Software metrics, project management, and legal and ethical issues are covered. The students are upper level, and they use journal articles as a source of materials. The issues of suitable textbooks and sources of materials and training for teaching user-interface design surfaced as problem areas.
Automatic generation of fixed-point-finding evaluators for circular, but well-defined, attribute grammars
Authors: Rodney Farrow
Venue: Proceedings of the 1986 SIGPLAN symposium on Compiler construction (1986)

In the traditional formulation of attribute grammars (AGs) circularities are not allowed, that is, no attribute-instance in any derivation tree may be defined in terms of itself. Elsewhere in mathematics and computing, though, circular (or recursive) definitions are commonplace, and even essential. Given appropriate constraints, recursive definitions are well-founded, and the least fixed-points they denote are computable. This is also the case for circular AGs.This paper presents constraints on individual attributes and semantic functions of an AG that are sufficient to guarantee that a circular AG specifies a well-defined translation and that circularly-defined attribute-instances can be computed via successive approximation. AGs that satisfy these constraints are called finitely recursive.An attribute evaluation paradigm is presented that incorporates successive approximation to evaluate circular attribute-instances, along with an algorithm to automatically construct such an evaluator. The attribute evaluators so produced are static in the sense that the order of evaluation at each production-instance in the derivation-tree is determined at the time that each translator is generated.A final algorithm is presented that tells which individual attributes and functions must satisfy the constraints.
An interactive environment for dialogue development: its design, use and evaluation; or, is aide useful?
Authors: D. H. Hix, H. R. Hartson
Venue: ACM SIGCHI Bulletin (1986)

The Author's Interactive Dialogue Environment (AIDE) of the Dialogue Management System is an integrated set of direct manipulation tools used by a dialogue author to design and implement human-computer interfaces without writing source code. This paper presents the conceptual dialogue transaction model upon which AIDE is based, describes AIDE, and illustrates how a dialogue author develops an interface using AIDE. A preliminary empirical evaluation of the use of AIDE versus the use of a programming language to implement an interface shows very encouraging results.
The evaluation of text editors: methodology and empirical results.
Authors: Teresa L. Roberts, Thomas P. Moran
Venue: Communications of the ACM (1983)

This paper presents a methodology for evaluating text editors on several dimensions: the time it takes experts to perform basic editing tasks, the time experts spend making and correcting errors, the rate at which novices learn to perform basic editing tasks, and the functionality of editors over more complex tasks. Time, errors, and learning are measured experimentally; functionality is measured analytically; time is also calculated analytically. The methodology has thus far been used to evaluate nine diverse text editors, producing an initial database of performance results. The database is used to tell us not only about the editors but also about the users&mdash;the magnitude of individual differences and the factors affecting novice learning.
Automatic Programming: Myths and Prospects
Authors: Charles Rich, Richard C. Waters
Venue: Computer (1988)

The authors consider five common myths about automatic programming and expose the fallacies on which they rest. They attempt to provide an accurate picture of these systems in terms of what the user sees, how the system works, and what the system knows. They describe commercially available systems and discuss what is on the horizon.
EASE: a design support environment for the HDDL ELLA
Authors: J. D. Morison, N. E. Peeling, T. L. Thorp, E. jV. Whiting
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

This paper describes the ELLA applications support environment - EASE. The support environment allows separate modular compilation and multi-level simulation with almost no semantic or syntatic constructs in the ELLA language. The paper describes the form that the EASE takes and the advantages this gives over other programming support environments. The weaknesses of the current EASE and future work are also discussed.
Disk cache&mdash;miss ratio analysis and design considerations
Authors: Alan J. Smith
Venue: ACM Transactions on Computer Systems (TOCS) (1985)

The current trend of computer system technology is toward CPUs with rapidly increasing processing power and toward disk drives of rapidly increasing density, but with disk performance increasing very slowly if at all. The implication of these trends is that at some point the processing power of computer systems will be limited by the throughput of the input/output (I/O) system. A solution to this problem, which is described and evaluated in this paper, is disk cache. The idea is to buffer recently used portions of the disk address space in electronic storage. Empirically, it is shown that a large (e.g., 80-90 percent) fraction of all I/O requests are captured by a cache of an 8-Mbyte order-of-magnitude size for our workload sample. This paper considers a number of design parameters for such a cache (called cache disk or disk cache), including those that can be examined experimentally (cache location, cache size, migration algorithms, block sizes, etc.) and others (access time, bandwidth, multipathing, technology, consistency, error recovery, etc.) for which we have no relevant data or experiments. Consideration is given to both caches located in the I/O system, as with the storage controller, and those located in the CPU main memory. Experimental results are based on extensive trace-driven simulations using traces taken from three large IBM or IBM-compatible mainframe data processing installations. We find that disk cache is a powerful means of extending the performance limits of high-end computer systems.
Up-down parsing with prefix grammars
Authors: P K Turner
Venue: ACM SIGPLAN Notices (1986)

A powerful method of parsing is presented, that suits particularly well the Graham-Glanville code generation methodology. This parsing method can be applied to any prefix grammar. It is shown how a table is generated and used to achieve parsing efficiency.
A distributed alternative to finite-state-machine specifications
Authors: Pamela Zave
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1985)

A specification technique, formally equivalent to finite-state machines, is offered as an alternative because it is inherently distributed and more comprehensible. When applied to modules whose complexity is dominated by control, the technique guides the analyst to an effective decomposition of complexity, encourages well-structured error handling, and offers an opportunity for parallel computation. When applied to distributed protocols, the technique provides a unique perspective and facilitates automatic detection of some classes of error. These applications are illustrated by a controller for a distributed telephone system and the full-duplex alternating-bit protocol for data communication. Several schemes are presented for executing the resulting specifications.
Programming pascal with physical units
Authors: A Dreiheller, B Mohr, M Moerschbacher
Venue: ACM SIGPLAN Notices (1986)

In /M auml;86/ (SIGPLAN Notices 3/1986) M auml;nner proposes an extension of Pascal permitting the use of physical units in programs. We discuss his issues in this paper and describe our own somewhat different approach. Our language extension PHYSCAL of Pascal not merely satisfies the requirements suggested by /M auml;86/, but also supports predefined units (International Standard), thorough realisation of the concept of scale factors, input/output facilities for numbers with units. The new concepts are motivated, and the language description is given formally and by examples. Finally we discuss some details of the realised language implementation by a PHYSCAL-to-Pascal preprocessor in an UNIX environment.
Extending relational algebra and relational calculus with set-valued attributes and aggregate functions
Authors: G. Özsoyoğlu, Z. M. Özsoyoğlu, V. Matos
Venue: ACM Transactions on Database Systems (TODS) (1987)

In commercial network database management systems, set-valued fields and aggregate functions are commonly supported. However, the relational database model, as defined by Codd, does not include set-valued attributes or aggregate functions. Recently, Klug extended the relational model by incorporating aggregate functions and by defining relational algebra and calculus languages. In this paper, relational algebra and relational calculus database query languages (as defined by Klug) are extended to manipulate set-valued attributes and to utilize aggregate functions. The expressive power of the extended languages is shown to be equivalent. We extend the relational algebra with three new operators, namely, pack, unpack, and aggregation-by-template. The extended languages form a theoretical framework for statistical database query languages.
FRAMES: Software tools for modeling, rendering and animation of 3D scenes
Authors: Michael Potmesil, Eric M. Hoffert
Venue: Proceedings of the 14th annual conference on Computer graphics and interactive techniques (1987)

FRAMES is a set of flexible software tools, developed for the UNIX programming environment, that can be used to generate images and animation of 3D scenes. In FRAMES, each stage of the image-rendering pipeline is assigned to a UNIX System filter. The following is a typical FRAMES pipe sequence where each filter performs a task implied by its name:cat scene.frm|euclid|mover|shade|camera|abufFRAMES was designed to be easy to use, to permit flexible experimentation with new ideas in image rendering and geometric modeling, to allow distribution of different parts of the rendering pipeline to different processors, and to specify images in a common format for display on a variety of devices.The user communicates with FRAMES via a command language. This language is extended whenever a software developer needs to incorporate a new idea into the system by adding new commands. Data flowing through the pipeline is modified by a collection of filter programs and passed through the pipe in text or binary format.The modular and pipe-based nature of FRAMES allows for multi/parallel processor implementations and device independence. FRAMES has generated images on a local-area network of minicomputers (each filter runs on a different processor) and on a 64-processor hypercube machine (one filter runs on 64 processors). Applications of FRAMES have ranged from reconstruction of neurons from serial sections to rendering of antialiased octree objects with subpixel detail.
The Escrow transactional method
Authors: Patrick E. O'Neil
Venue: ACM Transactions on Database Systems (TODS) (1986)

A method is presented for permitting record updates by long-lived transactions without forbidding simultaneous access by other users to records modified. Earlier methods presented separately by Gawlick and Reuter are comparable but concentrate on &ldquo;hot-spot&rdquo; situations, where even short transactions cannot lock frequently accessed fields without causing bottlenecks. The Escrow Method offered here is designed to support nonblocking record updates by transactions that are &ldquo;long lived&rdquo; and thus require long periods to complete. Recoverability of intermediate results prior to commit thus becomes a design goal, so that updates as of a given time can be guaranteed against memory or media failure while still retaining the prerogative to abort. This guarantee basically completes phase one of a two-phase commit, and several advantages result: (1) As with Gawlick's and Reuter's methods, high-concurrency items in the database will not act as a bottleneck; (2) transaction commit of different updates can be performed asynchronously, allowing natural distributed transactions; indeed, distributed transactions in the presence of delayed messages or occasional line disconnection become feasible in a way that we argue will tie up minimal resources for the purpose intended; and (3) it becomes natural to allow for human interaction in the middle of a transaction without loss of concurrent access or any special difficulty for the application programmer. The Escrow Method, like Gawlick's Fast Path and Reuter's Method, requires the database system to be an &ldquo;expert&rdquo; about the type of transactional updates performed, most commonly updates involving incremental changes to aggregate quantities. However, the Escrow Method is extendable to other types of updates.
Axioms for memory access in asynchronous hardware systems
Authors: J. Misra
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1986)

The problem of concurrent accesses to registers by asynchronous components is considered. A set of axioms about the values in a register during concurrent accesses is proposed. It is shown that if these axioms are met by a register, then concurrent accesses to it may be viewed as nonconcurrent, thus making it possible to analyze asynchronous algorithms without elaborate timing analysis of operations. These axioms are shown, in a certain sense, to be the weakest. Motivation for this work came from analyzing low-level hardware components in a VLSI chip which concurrently accesses a flip-flop.
Self-assessment procedure XV: a self-assessment procedure dealing with file processing
Authors: Martin K. Solomon, Riva Wenig Bickel
Venue: Communications of the ACM (1986)

A self-assessment procedure dealing with file processing
Constraint logic programming
Authors: J. Jaffar, J.-L. Lassez
Venue: Proceedings of the 14th ACM SIGACT-SIGPLAN symposium on Principles of programming languages (1987)

We address the problem of designing programming systems to reason with and about constraints. Taking a logic programming approach, we define a class of programming languages, the CLP languages, all of which share the same essential semantic properties. From a conceptual point of view, CLP programs are highly declarative and are soundly based within a unified framework of formal semantics. This framework not only subsumes that of logic programming, but satisfies the core properties of logic programs more naturally. From a user's point of view, CLP programs have great expressive power due to the constraints which they naturally manipulate. Intuition in the reasoning about programs is enhanced as a result of working directly in the intended domain of discourse. This contrasts with working in the Herbrand Universe wherein every semantic object has to be explicitly coded into a Herbrand term; this enforces reasoning at a primitive level. Finally, from an implementor's point of view, CLP systems can be efficient because of the exploitation of constraint solving techniques over specific domains.
Bayesian Clustering for Unsupervised Estimation of Surface and Texture Models
Authors: Judith F. Silverman, David B. Cooper
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1988)

A method of calculating the maximum-likelihood clustering for the unsupervised estimation of polynomial models for the data in images of smooth surfaces or for range data for such surfaces is presented. An image or a depth map of a region of smooth 3-D surface is modeled as a polynomial plus white noise. A region of physically meaningful textured-image such as the image of foliage, grass, or road in outdoor scenes or conductor or lintburn on a thick-film substrate is modeled as a colored Gaussian-Markov random field (MRF) with a polynomial mean-value function. Unsupervised-model parameter-estimation is accomplished by determining the segmentation and model parameter values that maximize the likelihood of the data or a more general Bayesian performance functional. Agglomerative clustering is used for this purpose.
Complexity of network synchronization
Authors: Baruch Awerbuch
Venue: Journal of the ACM (JACM) (1985)

The problem of simulating a synchronous network by an asynchronous network is investigated. A new simulation technique, referred to as a synchronizer, which is a new, simple methodology for designing efficient distributed algorithms in asynchronous networks, is proposed. The synchronizer exhibits a trade-off between its communication and time complexities, which is proved to be within a constant factor of the lower bound.
The consistent comparison problem in N-version software
Authors: S S Brilliant, J C Knight, N G Leveson
Venue: ACM SIGSOFT Software Engineering Notes (1987)

Multi-version or N-version programming [5] has been proposed as a method of providing fault tolerance in software. The approach requires the separate, independent preparation of multiple (i.e. "N") versions of a piece of software for some application. These versions are executed in parallel in the application environment; each receives identical inputs and each produces its version of the required outputs. The outputs are collected by a voter and, in principle, they should all be the same. In practice there may be some disagreement. If this occurs, the results of the majority (if there is one) are assumed to be the correct output, and this is the output used by the system.
A VLSI Implementation of the Simplex Algorithm
Authors: A. A. Bertossi, M. A. Bonuccelli
Venue: IEEE Transactions on Computers (1987)

The use of a special-purpose VLSI chip for solving a linear programming problem is presented. The chip is structured as a mesh of trees and is designed to implement the well-known simplex algorithm. A high degree of parallelism is introduced in each pivot step, which can be carried out in O (log n) time using an m × n mesh of trees having an O(mn log m log3 n) area where m - 1 and n - 1 are the number of constraints and variables, respectively. Two variants of the simplex algorithm are also considered: the two-phase method and the revised one. The proposed chip is intended as being a possible basic block for a VLSI operations research machine.
Efficient Storage Management for Temporary Values in Concurrent Programming Languages
Authors: Donna Quammen, John P. Kearns, Mary L. Soffa
Venue: IEEE Transactions on Computers (1985)

An evaluation stack, used exclusively to store temporary values in expression evaluation, is known to be an effective mechanism in the implementation of high level languages. This work considers the efficient management of evaluation stacks for concurrent programming languages. Techniques for sharing a single evaluation stack among many processes, without copying on process switches, are developed. The best strategy for managing the evaluation stack is shown to depend strongly upon the scheduling paradigm adopted by the run-time support of the language. Simulation studies, driven by synthetic workloads, show that the techniques described in this paper exhibit substantial performance improvements over traditional temporary storage management schemes for concurrent languages.
Multilevel Logical Networks
Authors: M. Karpovsky
Venue: IEEE Transactions on Computers (1987)

In this correspondence we present a design technique for implementation of systems of Boolean functions in the form of multilevel AND-OR networks. We show that for a given system of Boolean functions, the transition from the traditional two-level AND-OR implementation to multilevel AND-OR implementations results in considerable savings in gate counts and delays. We discuss gate-array implementations of these multilevel networks and their space and time complexities. Experimental data for 11 different components of peripheral control units for VAX computers indicate that the transition from the two-level implementations to multilevel implementations results in average savings of about 40 percent in gate counts, of about 25 percent in required silicon areas and of about 25 percent in delays, which illustrate a good potential of the proposed techniques for design of cost-efficient gate arrays.
Optimal layout to avoid CMOS stuck-open faults
Authors: S. Koeppe
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

A set of layout rules is presented to cope with CMOS stuck-open faults by a design for testability at the layout-level. In applying these rules, open connections may either be avoided or their effects can be described by an easily detectable type of open faults known from CMOS inverters and NMOS logic. Hence, remaining open faults are usually covered by a complete stuck-at test pattern set.
On the expected behavior of disjoint set union algorithms
Authors: B Bollobás, I Simon
Venue: Proceedings of the seventeenth annual ACM symposium on Theory of computing (1985)

We show that the expected time of the Weighted Quickfind (QFW) disjoint set union and find algorithm to perform (n - 1) randomly chosen unions is cn + o(n/log n), where c = 2.0847 &hellip;. This implies, through an observation of Tarjan and Van Leeuwen, linear expected time bounds to perform O(n) unions and finds for a class of other union -find algorithms. We also prove that the expected time of the unweighted Quickfind (QF) algorithm is n2/8 + o(n(log n)2), and set the several related open questions of Knuth and Sch&ouml;nhage.
An Infornation-Theoretic Analysis of Relational Databases Part I: Data Dependencies and Information Metric
Authors: Tony T. Lee
Venue: IEEE Transactions on Software Engineering (1987)

Database design is based on the concept of data dependency, which is the interrelationship between data contained in various sets of attributes. In particular, functional, multivalued and acyclic join, dependencies play an essential role in the design of database schemas. The basic definition of an information metric and how this notion can be used in relational database are discussed in this paper. We use Shannon entropy as an information metric to quantify the information associated with a set of attributes. Thus, we prove that data dependencies can be formulated in terms of entropies. These formulas make the numerical computation and testing of data dependencies feasible. Among the different types of data dependencies, the acyclic join dependency is most important to the design of a relational database schema. The acyclic join dependency, with multivalued dependency as a special case, impose a constraint on the information-preserving decomposition of a relation. It is interesting that this constraint on a relation is similar to Gibbs' condition for separating physical systems in statistical mechanics. They both assert that entropy is preserved during the decomposition process. That is, the entropies of the corresponding set of attributes must satisfy the inclusion-exclusion identity.