ppxscal/embedding_network huggingface dataset:
Timing verification system based on delay time hierarchical nature
Authors: Minoru Nomura, Shinichi Sato, Nobuo Takano, Toshinori Aoyama, Akihiko Yamada
Venue: Proceedings of the 19th Design Automation Conference (1982)

A hierarchical timing verification system is described. It can evaluate all logical paths in a chip without any specific manual input information, using a path tracing algorithm. This hierarchical approach can drastically reduce the number of logical paths to be traced and the corresponding computation time. This system is used for designing master slice (gate array) LSIs and building block LSIs.
Random matroids
Authors: John H. Reif, Paul G. Spirakis
Venue: Proceedings of the twelfth annual ACM symposium on Theory of computing (1980)

We introduce a new random structure generalizing matroids. These random matroids allow us to develop general techniques for solving hard combinatorial optimization problems with random inputs.
Designing data entry programs using state diagram as a common model
Authors: Moses M. Ling
Venue: Proceedings of the 6th international conference on Software engineering (1982)

A minicomputer based data entry system recently developed at Bell Laboratories supports 73 transaction types and approximately 1000 fields. The user communicates with the system from a CRT terminal in field-by-field mode via a uniform interface. This paper presents a common design for the family of data entry programs that process the various types of transactions. The design is represented by a compact, orderly, and verifiable model to demonstrate the consistent program behavior. The model is formalized and proved correct to validate the design. The common model reduces design effort, provides design generality, enables code generation, and enhances ease of maintenance. The correctness proof eliminates high level design errors and their consequences. In the general area of business application, a common design lends itself to quickly mass produce components of a software product, and makes it easy to maintain them later.
DMS: A comprehensive system for managing human-computer dialogue
Authors: John Roach, H. Rex Hartson, Roger W. Ehrich, Tamer Yunten, Deborah H. Johnson
Venue: Proceedings of the 1982 conference on Human factors in computing systems (1982)

As the complexity of human-computer interfaces increases, those who use these interfaces as well as those reponsible for their design have recognized an urgent need for substantive research in the human factors of software development [2], [5]. Because of the magnitude of the task of producing software for individual human-computer interfaces, appropriate tools are needed for defining and improving such interfaces, both in research and production environments. This paper describes the research being carried out to construct DMS (Dialogue Management System), which is a complete system for defining, modifying, executing, and metering human-computer dialogues.
On the complexity of grammar and related problems
Authors: H. B. Hunt,  III, T. G. Szymanski
Venue: Proceedings of seventh annual ACM symposium on Theory of computing (1975)

In [1] and [2] a complexity theory for formal languages and automata was developed. This theory implies most of the previously known results and yields many new results as well. Here we develop an analogous theory for several classes of more practically motivated problems. Two such classes, both closely related to formal language and automata theory, suggest themselves - grammar problems and program scheme problems. Here, our primary emphasis is on grammar problems of interest in parsing and compiling. Other problems considered include - (1) possible techniques for proving non-trivial lower complexity bounds for problems in P; (2) the relationship of the complexity of tree automaton equivalence, structural equivalence, and grammatical covering; and (3) the complexity of the equivalence problem for schemes. In each case we relate the computational complexity of a problem to its underlying combinatorial structure. The remainder of the paper is divided into four sections.
The complexity of loop programs
Authors: Albert R. Meyer, Dennis M. Ritchie
Venue: Proceedings of the 1967 22nd national conference (1967)

Anyone familiar with the theory of computability will be aware that practical conclusions from the theory must be drawn with caution. If a problem can theoretically be solved by computation, this does not mean that it is practical to do so. Conversely, if a problem is formally undecidable, this does not mean that the subcases of primary interest are impervious to solution by algorithmic methods. In the next section we describe such a class of programs, called &ldquo;Loop programs.&rdquo; Each Loop program consists only of assignment statements and iteration (loop) statements, the latter resembling the DO statement of FORTRAN, and special cases of the FOR and THROUGH statements of ALGOL and MAD. The bound on the running time of a Loop program is determined essentially by the length of the program and the depth of nesting of its loops.
A new approach to program testing
Authors: James C. King
Venue: Proceedings of the international conference on Reliable software (1975)

The current approach for testing a program is, in principle, quite primitive. Some small sample of the data that a program is expected to handle is presented to the program. If the program produces correct results for the sample, it is assumed to be correct. Much current work focuses on the question of how to choose this sample. We propose that a program can be more effectively tested by executing it "symbolically." Instead of supplying specific constants as input values to a program being tested, one supplies symbols. The normal computational definitions for the basic operations performed by a program can be expanded to accept symbolic inputs and produce symbolic formulae as output. If the flow of control in the program is completely independent of its input parameters, then all output values can be symbolically computed as formulae over the symbolic inputs and examined for correctness. When the control flow of the program is input dependent, a case analysis can be performed producing output formulae for each class of inputs determined by the control flow dependencies. Using these ideas, we have designed and implemented an interactive debugging/testing system called EFFIGY.
SIGMOD(Paper Session)
Authors: Fred J. Maryanski, Paul S. Fisher, Virgil E. Wallentine, A. M. Koss, J. M. Noonan, S. B. Yao
Venue: Proceedings of the 1976 annual conference (1976)

Data base technology has progressed to the stage where software facilities for managing large amounts of data are readily available. This session will address several issues related to the design of effective and efficient data bases. The issues to be addressed are the following: (1) The efficiency of a custom-built DBMS vs. the efficiency of vendor-supplied DBMSs. (2) The use of analytic models as an aid in selecting physical data base structures. (3) The use of a separate machine to manage a data base.
Minimum test patterns for residue networks
Authors: D. C. Bossen, D. L. Ostapko, A. M. Patel, M. S. Schmookler
Venue: Proceedings of the 8th Design Automation Workshop (1971)

Residue networks are logic trees consisting of residue gates which calculate the modulo-m sum of two or more inputs. The principal result of this paper is that for a single output residue network consisting of modulo-m gates having n or less inputs each, the required number of test patterns is mn, provided the gates are of a particular logical construction. This represents a minimum number of test patterns since that is exactly the number of test patterns required for a complete functional test of a single modulo-m gate with n inputs. In the next section, an application of the method described in this paper is briefly illustrated. The properties of residue gates which are necessary and sufficient for the use of this method and various means for generating the test patterns are described in the remaining sections.
Building and accessing an REL database
Authors: Steve D. Gadol, Egon E. Loebner
Venue: ACM SIGSOC Bulletin (1982)

This paper discusses the construction of an experimental database at Hewlett-Packard Laboratories using the REL ENGLISH software provided by Frederick and Bozena Thompson of the California Institute of Technology. Of special interest is the quasi-natural interface and its ability to tolerate ambiguities. This provides a support mechanism for multiple user views of the same data in which disambiguation is accomplished during semantic processing.
A methodology for decomposing system requirements into data processing requirements
Authors: Kenneth G. Salter
Venue: Proceedings of the 2nd international conference on Software engineering (1976)

Top level system design is considered, with attention focused on the decomposition of system requirements into subsystem requirements. Primary interest is in the data processing subsystem. Implementation details involving operating systems, selection and configuration of computers, and choice of specific algorithms are excluded from this study. A methodology is presented for transforming system requirements into functional structure and system operating rules. This methodology is viewed as the first step of a comprehensive software development methodology comprising: top level design, algorithm development, computer selection, and the translation of the functional algorithmic design into operational software. The top level design is carried to such detail that algorithms, to be developed subsequently and to be realized ultimately with hardware or software, can be considered bounded by the interfaces of the data processing subsystem (DPS). That is, the interfaces are defined sufficiently well that the algorithm designer needs to consider neither the destination of data leaving the DPS nor the source of data entering the DPS. A system can be decomposed into four structural elements: functions, control, functional flows, and data. Each of these elements is a subject of the decomposition methodology. The inter-relationships of system functions are structured to define a partial ordering of system functions that is amendable to representation as a directed graph. The system control mechanism is defined to be a finite state machine, whose only cycles are loops, having START and END states. For real time operation END states fold onto START states. Functional flows represent each output of the control machine as a serial/parallel execution of the functions, consistent with their partial ordering. Data is used to relate the several functions within a functional flow, to drive the control mechanism, and to link control to the functional flows.
MAP/1 tutorial
Authors: Robin J. Miner, Laurie J. Rolston
Venue: Proceedings of the 16th conference on Winter simulation (1984)

MAP/1TM is a simulation-based Modeling and Analysis Program developed by Pritsker and Associates for use in designing and evaluating discrete part manufacturing systems. MAP/1 is a generalized model of a discrete part manufacturing system, which is parameterized to represent a specific manufacturing facility. Parameters which describe the manufacturing facility configuration and associated operating rules are input to the MAP/1 analysis program, which produces a set of predefined output reports and provides measures of facility performance. Using MAP/1, in-depth simulation analyses may be performed to investigate alternative system configurations and operating procedures.
A varistructured fail-soft cellular computer
Authors: G. J. Lipovski
Venue: Proceedings of the 1st annual symposium on Computer architecture (1973)

The architecture of a von-Neumann class computer is considered, in which the user programmer can request, at the beginning of his task, one of many word widths, and one of many memory heights. Several users are able to space share the computer. We call this feature varistructure. The computer is a minimally, yet strongly connected cellular structure consisting of microcomputers, and has the capability of being fail-soft.
Analysis of structured programs
Authors: S. Rao Kosaraju
Venue: Proceedings of the fifth annual ACM symposium on Theory of computing (1973)

We investigate various control structures to understand their computational complexity and limitations. It is generally felt that GOTO-less programs constructed from the classical primitives are very restrictive; structured programming languages like BLISS, however, incorporating Repeat-Exit constructs appear to ease this sense of restrictiveness. In this paper we analyze this construct. We answer a conjecture of Knuth and Floyd as a special case of the general theory. We also investigate a general Top-Down Programming construct, which we call the TDn-construct. We structurally characterize the class of GOTO-less programs. We also generalize such an analysis and solve an open problem of B&ouml;hm and Jacopini.
Computer graphic modeling of american sign language
Authors: Jeffrey Loomis, Howard Poizner, Ursula Bellugi, Alynn Blakemore, John Hollerbach
Venue: Proceedings of the 10th annual conference on Computer graphics and interactive techniques (1983)

The essential grammatical information of American Sign Language (ASL) is conveyed through changes in the movement and spatial contouring of the hands and arms. An interactive computer graphic system is described for the analysis and modeling of sign language movement. This system consists of four components. The first component reconstructs actual movements in three dimensions and allows the user to interactively segment and transform the data for later analysis. The second component allows a user to interactively create synthetic signs by specifying angle functions in a jointed model. The third component provides a novel technique for manipulating movement quality independently of spatial path. The fourth component allows the building of complex stimuli and real-time stimulus sequencing for psycholinguistic experiments. The emphasis is on interactive techniques and data structures that allow analysis and modeling of the complex hand and arm movements of American Sign Language.
Programming cost estimate: Is it reasonable?
Authors: Robert E. Boydston
Venue: Proceedings of the 7th international conference on Software engineering (1984)

A basic concern when considering a programming cost estimate is its reasonableness. A statistical examination of over thirty completed products was conducted, using least square error methods, to develop an improved method for establishing a central value and an acceptable range of values for programming product cost estimates. Eight variables associated with the coding process, such as the number of lines of new and modified Basic Assembler Language and number of new modules, were found to be useful in developing reasonableness equations. Using regression equations developed from the variables, we developed reasonableness tests that compare the estimate prepared by the developer to the actual development effort applied to previous products. Insight also was gained about programmer productivity, the quality of code estimations, and the optimum number of lines of code per module. Estimates are usually based on the experience of the past. But whatever method is used, the main consideration is the error of estimate associated with that method. The basic question about any estimate is: how good is it? The current state of the art of the cost estimating of software projects evolved from the works of Walverton1 attempting to correlate the size of effort in person-months with the size of the product expressed in Thousand Lines of Source Code (KLOC). Large dispersion of data forced Walston and Felix2 to take into account additional variables such as programmer experience and the complexity of the application as well as over twenty variables. Putnam3 simplified staffing (life cycle curve) to a small and easily managed set of parameters that could be expressed in the form of nomograms. This paper contributes to the software cost estimation by identifying those variables of the product which were found to be governing: The importance of distinguishing higher level language Programming Language Systems (PLS) from low level Basic Assembler Language (BAL), the importance of recognizing the major increase of effort if code is modified rather than new code created. The magnitude of these differences is quantified. Finally in the analysis of the optional number of modules for a product, a balance is shown between the intramodule complexity and the intermodule complexity. Parametric data associated with program product development costs has been actively collected since mid-1976 by the Program Cost Estimating Department, now located at IBM's Santa Teresa Laboratory. This data represents the actual person-month resources used to match program development requirements. Products that were analyzed are a collection of classic IBM mainframe products: languages (such as Cobol, PL/I, APL), utilities (VSAM, OS utilities, sort, etc.), and data base products (IMS, Data Dictionary, etc.). These are &ldquo;system programs&rdquo; rather than applications. The range and median sizes of the products are shown in Table 1. Twenty six of the thirty products contain modified modules.
Computer aided diagnostic design for electronic switching systems
Authors: Frank M. Goetz
Venue: Proceedings of the 7th Design Automation Workshop (1970)

With the advent of integrated circuitry, digital simulation has replaced physical fault insertion as the primary means for evaluating diagnostic tests. At Bell Laboratories, an improved version of the sequential analyzer was integrated into a data management system with a number of support programs. The system was used to evaluate the diagnostic program for a 32K core memory system under development for electronic switching system (ESS) applications. Important circuit design feedback was obtained through simulation early in the development cycle, making possible an unprecedented high level of switching system fault detection. Processing techniques were developed to select and order tests to obtain high diagnostic resolution with minimum vulnerability to inconsistencies.
Desirable floating-point arithmetic and elementary functions for numerical computation
Authors: D. E. Hull
Venue: Proceedings of the SIGNUM Conference on the Programming Environment for Development of Numerical Software (1978)

The purpose of this talk is to summarize proposed specifications for floating-point arithmetic and elementary functions. The topics considered are: the base of the number system, precision control, number representation, arithmetic operations, other basic operations, elementary functions, and exception handling. The possibility of doing with-out fixed-point arithmetic is also mentioned. The specifications are intended to be entirely at the level of a programming language such as Fortran. The emphasis is on convenience and simplicity from the user's point of view. Conforming to such specifications would have obvious beneficial implications for the portability of numerical software, and for proving programs correct, as well as attempting to provide facilities which are most suitable for the user. The specifications are not complete in every detail, but it is intended that they be complete &ldquo;in spirit&rdquo; - some further details, especially syntactic details, would have to be provided, but the proposals are otherwise relatively complete.
A Modular Computer With Petri Net Array Control
Authors: S. S. Reddi
Venue: Proceedings of the 1978 annual conference (1978)

This paper presents a computer system with modular functional units which establishes data and control paths dynamically by means of a programmable Petri net array. The input program control flow and the desired allocation of hardware resorces are specified by means of a Petri net and the array by realizing this net controls the data flow between the functional unit. The system exploits parallelism present in the hardware and the program to the extent specified by the programmer. Some of the advantages of the present approach are that the program status is reflected by the array status, and hence can be monitored by observing the latter and that precise resource allocation/scheduling can be enforced by the user.
On Bernoulli's method for solving algebraic equations, II
Authors: Bernard Dimsdale
Venue: Proceedings of the 1956 11th ACM national meeting (1956)

In a previous paper on the subject Bernoulli's method was extended to cover those cases in which there were several roots of equal largest modulus. The method had an advantage over Graeffe's method in that it dealt only with the original roots, and the disadvantage that there was a lower order of convergence. The present paper is concerned with the elimination of this disadvantage. Certain considerations relative to computer applications are also discussed.
The architecture of the SPERRY UNIVAC 1100 series systems
Authors: B. R. Borgerson, M. D. Godfrey, P. E. Hagerty, T. R. Rykken
Venue: Proceedings of the 6th annual symposium on Computer architecture (1979)

This paper presents an overview of the architecture of the SPERRY UNIVAC&reg; 1100 Series systems. The principal topics are instruction and data formats, main storage and addressing, process management, and I/O.
The IEEE Computer Society task force on computer architecture
Authors: George E. Rossmann
Venue: Proceedings of the 3rd annual symposium on Computer architecture (1976)

The subject of computer architecture as currently taught in most computer engineering and computer science programs is a mixture of architectural principles, organizational strategies, and implementation techniques. This blurring of the hierarchy of system levels that characterize the structure of a computer has made it very difficult for students (and often instructors as well) to determine what were the forces that led to the design decisions they have seen reflected in machines. In view of these circumstances, a task force was established by the IEEE Computer Society to prepare a detailed specification for a course of study in computer architecture for students whose major interest is in computer engineering or computer science.
An Interactive Graphics System for the design of integrated circuits
Authors: Beatriz Infante, Diane Bracken, Bill McCalla, Sam Yamakoshi, Ellis Cohen
Venue: Proceedings of the 15th Design Automation Conference (1978)

IGS (Interactive Graphics System) is a computer design aid specifically developed for the layout of integrated circuits. User specification of process information makes the system process-independent while retaining the features which make it a useful layout tool. The ability to place interconnect on a coarse grid greatly diminishes the chances of misalignment. Automatic, incremental checking of cell-to-cell, cell-to-component, and component-to-component spacing reduces the number of design rule violations. Rudimentary forms of topology verification are provided in the ability to trace electrical connectivity.