Showing papers in "IEEE Transactions on Software Engineering in 1981"
TL;DR: This paper defines and validates a set of software metrics which are appropriate for evaluating the structure of large-scale systems and can be interpreted to reveal various types of structural flaws in the design and implementation.
Abstract: Structured design methodologies provide a disciplined and organized guide to the construction of software systems. However, while the methodology structures and documents the points at which design decisions are made, it does not provide a specific, quantitative basis for making these decisions. Typically, the designers' only guidelines are qualitative, perhaps even vague, principles such as "functionality," "data transparency," or "clarity." This paper, like several recent publications, defines and validates a set of software metrics which are appropriate for evaluating the structure of large-scale systems. These metrics are based on the measurement of information flow between system components. Specific metrics are defined for procedure complexity, module complexity, and module coupling. The validation, using the source code for the UNIX operating system, shows that the complexity measures are strongly correlated with the occurrence of changes. Further, the metrics for procedures and modules can be interpreted to reveal various types of structural flaws in the design and implementation.
830 citations
TL;DR: The proof method is based upon specifying a process by a pair of assertions, analogous to pre-and post-conditions in sequential program proving, and the correctness of network specification is proven by applying inference rules to the specifications of component processes.
Abstract: We present a proof method for networks of processes in which component processes communicate exclusively through messages We show how to construct proofs of invariant properties which hold at all times during network computation, and terminal properties which hold upon termination of network computation, if network computation terminates The proof method is based upon specifying a process by a pair of assertions, analogous to pre-and post-conditions in sequential program proving The correctness of network specification is proven by applying inference rules to the specifications of component processes Several examples are proved using this technique
562 citations
TL;DR: It is shown that various algorithms for producing tidy drawings of trees contain some difficulties that lead to aesthetically unpleasing, wider than necessary drawings, and a new algorithm is presented with comparable time and storage requirements that produces tidier drawings.
Abstract: Various algorithms have been proposed for producing tidy drawings of trees–drawings that are aesthetically pleasing and use minimum drawing space. We show that these algorithms contain some difficulties that lead to aesthetically unpleasing, wider than necessary drawings. We then present a new algorithm with comparable time and storage requirements that produces tidier drawings. Generalizations to forests and m-ary trees are discussed, as are some problems in discretization when alphanumeric output devices are used.
532 citations
IBM1
TL;DR: This paper illustrates, by means of a detailed example, how formal grammatical description can be used as a predictive tool to compare alternative designs for ease of use and to identify design choices which could cause users to make mistakes.
Abstract: Formal grammatical description has not generally been applied in the human factors area, which traditionally draws on behavioral science for its methodology. This paper illustrates, by means of a detailed example, how formal grammatical description can be used as a predictive tool to compare alternative designs for ease of use and to identify design choices which could cause users to make mistakes.
288 citations
TL;DR: An incremental programming environment (IPE) as discussed by the authors is based on compilation technology, but providing facilities traditionally found only in interpretive systems, such as support for a single programmer working on a single program.
Abstract: This paper describes an incremental programming environment (IPE) based on compilation technology, but providing facilities traditionally found only in interpretive systems. IPE provides a comfortable environment for a single programmer working on a single program.
244 citations
TL;DR: The problem of optimally assigning the modules of a program over the processors of an inhomogeneous distributed processor system is analyzed and modules are assigned to the processors on which they execute most rapidly while taking into account the overhead of interprocessor communication.
Abstract: The problem of optimally assigning the modules of a program over the processors of an inhomogeneous distributed processor system is analyzed. The objective is to assign modules, wherever possible, to the processors on which they execute most rapidly while taking into account the overhead of interprocessor communication. Factors contributing to the cost of an assignment are 1) the amount of computation required by each module, 2) the amount of data transmitted between each pair of modules, 3) the speed of each processor, and 4) the speed of the communication link between each pair of processors.
231 citations
TL;DR: A system for mechanically transforming formal program specifications into efficient implementations under interactive user control is described and illustrated through a detailed example.
Abstract: A system for mechanically transforming formal program specifications into efficient implementations under interactive user control is described and illustrated through a detailed example. The potential benefits and problems of this approach to software implementation are discussed.
167 citations
TL;DR: It is discovered that the predominant number of persistent errors in large-scale software efforts are errors of omitted logic, that is, the code is not as complex as required by the problem to be solved.
Abstract: Persistent software errors-those which are not discovered until late in development, such as when the software becomes operational-are by far the most expensive kind of error. Via analysis of software problem reports, it is discovered that the predominant number of persistent errors in large-scale software efforts are errors of omitted logic..., that is, the code is not as complex as required by the problem to be solved. Peer design and code review, desk checking, and ultrarigorous testing may be the most helpful of the currently available technologies in attacking this problem. New and better methodologies are needed.
128 citations
TL;DR: This paper examines the use of the on-line user data sets at the Stanford Linear Accelerator Center (SLAC) computer installation through the analysis of 13 months of file reference data and finds that most files are used very few times and appear to be referenced as a renewal process with a skewed interreference distribution.
Abstract: In most large computer installations files are moved between on-line disk and mass storage (tape, integrated mass storage device) either automatically by the system and/or at the direction of the user. In this paper we present and analyze long term file reference data in order to develop a basis for the construction of algorithms for file migration. Specifically, we examine the use of the on-line user (primarily text editor) data sets at the Stanford Linear Accelerator Center (SLAC) computer installation through the analysis of 13 months of file reference data. We find that most files are used very few times. Of those that are used sufficiently frequently that their reference patterns may be examined, we find that: 1) about a third show declining rates of reference during their lifetime, 2) of the remainder, very few (about 5 percent) show correlated interreference intervals, and 3) interreference intervals (in days) appear to be more skewed than would occur with the Bernoulli process. Thus, about two-thirds of all suffi1ciently active files appear to be referenced as a renewal process with a skewed interreference distribution. A large number of other file reference statistics (file lifetimes, interference distributions, moments, means, number of uses/ file, file sizes, file rates of reference, etc.) are computed and presented. Throughout, statistical tests are described and explained. The results of our analysis of file reference patterns are applied in a companion paper to the development and comparative evaluation of file migration algorithms.
94 citations
TL;DR: An experiment was designed and conducted to confirm certain suppositions concerning the beneficial effects of a particular disciplined methodology for software development and revealed several programming aspects for which statistically significant differences existed between the disciplined methodology and the control groups.
Abstract: A software engineering research study has been undertaken to empirically analyze and compare various software development approaches; its fundamental features and initial findings are presented in this paper. An experiment was designed and conducted to confirm certain suppositions concerning the beneficial effects of a particular disciplined methodology for software development. The disciplined methodology consisted of programming teams employing certain techniques and organizations commonly defined under the umbrella term structured programming. Other programming teams and individual programmers both served as control groups for comparison. The experimentally tested hypotheses involved a number of quantitative, objective, unobtrusive, and automatable measures of programming aspects dealing with the software development process and the developed software product. The experiment's results revealed several programming aspects for which statistically significant differences existed between the disciplined methodology and the control groups. The results were interpreted as confirmation of the original suppositions and evidence in favor of the disciplined methodology. This paper describes the specific features of the experiment; outlines the investigative approach used to plan, execute, and analyze it; reports its immediate results; and interprets them according to intuitions regarding the disciplined methodology.
88 citations
IBM1
TL;DR: Several models of synchronous and asynchronous parallel computation and their use in analyzing algorithms and the importance of interprocessor communication in parallel processing is demonstrated.
Abstract: As multiple processor systems become more widely accepted the importance of parallel programming increases. In this paper, approaches to the design and analysis of parallel algorithms are investigated. Through several examples, the importance of interprocessor communication in parallel processing is demonstrated. Various techniques that are applicable in the design and analysis of parallel algorithms are examined with emphasis on those techniques that incorporate communication aspects. The paper discusses several models of synchronous and asynchronous parallel computation and their use in analyzing algorithms. Relatively primitive methodologies for designing parallel algorithms are discussed and the need for more general and practical methodologies is indicated.
TL;DR: It is shown that READ throughput diminishes if the number of copies exceeds an optimal value and the theoretical model developed is applied to a system in which consistency is preserved through the use of Ellis' ring algorithm.
Abstract: We consider the effect on system performance of the distribution of a data base in the form of multiple copies at distinct sites. The purpose of our analysis is to determine the gain in READ throughput that can be obtained in the presence of consistency preserving algorithms that have to be implemented when UPDATE operations are carried out on each copy. We show that READ throughput diminishes if the number of copies exceeds an optimal value. The theoretical model we develop is applied to a system in which consistency is preserved through the use of Ellis' ring algorithm.
TL;DR: In this paper, a formal specification development and validation methodology is proposed for the development of reliable software, especialy with respect to the final software validation and testing activities, and the experiences of applying the methodology to the pilot software are discussed and the impact on the quality of the software is assessed.
Abstract: This paper discusses the necessity of a good methodology for the development of reliable software, especialy with respect to the final software validation and testing activities. A formal specification development and validation methodology is proposed. This methodology has been applied to the development and validation of a pilot software, incorporating typical features of critical software for nuclear power plant safety protection. The main features of the approach indude the use of a formal specification language and the independent development of two sets of specifications. Analyses on the specifications consists of three-parts: validation against the functional requirements consistency and integrity of the specifications, and dual specification comparison based on a high-level symbolic execution technique. Dual design, implementation, and testing are performed. Automated tools to facilitate the validation and testing activities are developed to support the methodology. These includes the symbolic executor and test data generator/dual program monitor system. The experiences of applying the methodology to the pilot software are discussed, and the impact on the quality of the software is assessed.
TL;DR: A methodology of program development by transformations is outlined, and ways of representing the transformation rules are discussed, and the relationship between notions of their correctness and the semantic definition of programming languages is studied.
Abstract: A methodology of program development by transformations is outlined. In particular, ways of representing the transformation rules are discussed, and the relationship between notions of their correctness and the semantic definition of programming languages is studied. How transformation techniques are complemented by the use of abstract data types and assertions is described. In the resulting calculus of transformations, the single rules not only represent design or optimization techniques, but they also incorporate verification principles. To illustrate this approach, the Warshall algorithm is developed by successive applications of transformations.
TL;DR: A refinement paradigm for implementing a high-level specification in a low-level target language is discussed, and a particular implementation of this program synthesis paradigm is described that has automatically implemented a number of programs in the domain of symbolic processing.
Abstract: A refinement paradigm for implementing a high-level specification in a low-level target language is discussed. In this paradigm, coding and analysis knowledge work together to produce an efficient program in the target language. Since there are many possible implementations for a given specification of a program, searching knowledge is applied to increase the efficiency of the process of finding a good implementation. For example, analysis knowledge is applied to determine upper and lower cost bounds on alternate implementations, and these bounds are used to measure the potential impact of different design decisions and to decide which alternatives should be pursued. In this paper we also describe a particular implementation of this program synthesis paradigm, called PSI/SYN, that has automatically implemented a number of programs in the domain of symbolic processing.
TL;DR: Verification and compile-time checking of the behavior of programs in real time is an important issue in many applications, e.g., process control, lab automation, and monitoring of missiles and vehicles.
Abstract: Verification and compile-time checking of the behavior of programs in real time is an important issue in many applications, e.g., process control, lab automation, and monitoring of missiles and vehicles. Present day programming languages and compilers lack the facilities of calculating execution times of programs.
TL;DR: A major survey of individuals from all areas of the computer field to determine the general consensus on SEPM problems and indicated research directions which, if followed, the respondents believed would lead to solutions for these problems.
Abstract: Software engineering project management (SEPM) has been the focus of much recent attention because of the enormous penalties incurred during software development and maintenance resulting from poor management. To date there has been no comprehensive study performed to determine the most significant problems of SEPM, their relative importance, or the research directions necessary to solve them. We conducted a major survey of individuals from all areas of the computer field to determine the general consensus on SEPM problems. Twenty hypothesized problems were submitted to several hundred individuals for their opinions. The 294 respondents validated most of these propositions. None of the propositions was rejected by the respondents as unimportant. A number of research directions were indicated by the respondents which, if followed, the respondents believed would lead to solutions for these problems.
IBM1
TL;DR: This paper presents a simple uniform methodology for sharpening data flow information by considering certain recursive path sets of practical importance and indicates that qualified analysis is feasible and substantialy more informative than ordinary analysis.
Abstract: It is known that not aU paths are possible in the run time control flow of many programs. It is also known that data flow analysis cannot restrict attention to exactly those paths that are possible. It is, therefore, usual for analytic methods to consider aU paths. Sharper information can be obtained by considering a recursive set of paths that is large enough to include aUl possible paths, but smaU enough to exclude many of the impossible ones. This paper presents a simple uniform methodology for sharpening data flow information by considering certain recursive path sets of practical importance. Associated with each control flow arc there is a relation on a finite set Q. The paths that qualify to be considered are (essentially) those for which the composition of the relations encountered is nonempty. For example, Q might be the set of all assignments of values to each of several bit variables used by a program to remember some facts about the past and branch accordingly in the future. Given any data-flow problem together with qualifying relations on Q associated with the control flow arcs, we construct a new problem. Considering all paths in the new problem is equivalent to considering only qualifying paths in the old one. Preliminary experiments (with a smaUl set of real programs) indicate that qualified analysis is feasible and substantialy more informative than ordinary analysis.
TL;DR: This correspondence shows how correct confidence limits and maximum likelihood estimates can be obtained from the test results.
Abstract: Mills capture-recapture sampling method allows the estimation of the number of errors in a program by randomly inserting known errors and then testing the program for both inserted and indigenous errors This correspondence shows how correct confidence limits and maximum likelihood estimates can be obtained from the test results Both fixed sample size testing and sequential testing are considered
TL;DR: This paper reports the results of an experiment in applying large-scale software engineering procedures to small software projects, where two USC student teams developed a small, interactive application software product to the same specification.
Abstract: This paper reports the results of an experiment in applying large-scale software engineering procedures to small software projects. Two USC student teams developed a small, interactive application software product to the same specification, one using Fortran and one using Pascal. Several hypotheses were tested, and extensive experimenal data collected. The major conclusions were as follows.
TL;DR: A conceptual framework of software maintainability and an implemented procedure for evaluating a program's documentation and source code for maintainability characteristics and some preliminary results from the use of this methodology by the Air Force Test and Evaluation Center are presented.
Abstract: This paper describes a conceptual framework of software maintainability and an implemented procedure for evaluating a program's documentation and source code for maintainability characteristics. The evaluation procedure includes use of closed-form questionnaires completed by a group of evaluators. Statistical analysis techniques for validating the evaluation procedure are described. Some preliminary results from the use of this methodology by the Air Force Test and Evaluation Center are presented. Areas of future research are discussed.
TL;DR: The problem of performing multiple attribute clustering in a dynamic database is studied and the extended K-d tree method is presented, using the basic k-D tree structure after modification as the structure of the directory which organizes the data records in the secondary storage.
Abstract: The problem of performing multiple attribute clustering in a dynamic database is studied. The extended K-d tree method is presented. In an extended K-d tree organization, the basic k-d tree structure after modification is used as the structure of the directory which organizes the data records in the secondary storage. The discriminator value of each level of the directory determines the partitioning direction of the corresponding attribute subspace. When the record insertion causes the data page to overload, the attribute space will be further partitioned along the direction specified by the corresponding discriminator.
TL;DR: This presentation explains how the design of software for distributed computing systems is more complicated due to many design constraints and interactions of software components of the system.
Abstract: Distributed computing systems represent a wide variety of computer systems, ranging from a centralized star network to a completely decentralized computer system. The design of software for distributed computing systems is more complicated due to many design constraints and interactions of software components of the system.
TL;DR: The basic concept of the entity-relationship approach to the logical database design is provided, and is used to derive 3NF relations, and an improved table form of the relations is introduced to provide a clear and concise user's view of databases.
Abstract: The nondeterministic or deterministic entity-relationship model of a database is formaRy defined as a user's view of that database in terms of a collection of time-varying relations: the regular or weak entity relations, or the regular or weak relationship relations. Both nondeterministic and deterministic entity-relationship models have the same strength to characterize information concerning entities and relationships which exist in our minds. An improved table form of the relations is introduced to provide a clear and concise user's view of databases. The basic concept of the entity-relationship approach to the logical database design is provided, and is used to derive 3NF relations. FinaUly, a method of representing physicaly these relations, which are generated by the use of the entity-relationship approach to the logical database design, is presented. Thus, the entity-relationship approach to the logical and physical database design can also be realized.
IBM1
TL;DR: This paper proposes two distributed access control schemes for a bus network that are simple and asynchronous, and provide for collision-free communication among ports, and provides a bounded, guaranteed time to transmisidon for each port.
Abstract: This paper considers access control for local area computer communication networks. We propose two distributed access control schemes for a bus network. The schemes are simple and asynchronous, and provide for collision-free communication among ports. In addition, one of the schemes provides a bounded, guaranteed time to transmisidon for each port. We also show that this scheme is efficient in the use of the bus bandwidth, in the sense that there is only a small fraction of time during which the bus is idle when there is at least one packet available for transmission.
TL;DR: An object-oriented multilevel model of computation is used to discuss recoverability and crash resistance issues in distributed systems to ensure that a group of processes leave the system state consistent despite faults in the system.
Abstract: An object-oriented multilevel model of computation is used to discuss recoverability and crash resistance issues in distributed systems. Of particular importance are the issues that are raised when recoverability and crash resistance properties are desired from objects whose concrete representations are distributed over several nodes. The execution of a program at a node of the system can give rise to a hierarchy of processes executing various parts of the program at different nodes. Recoverability and crash resistance properties are needed to ensure that such a group of processes leave the system state consistent despite faults in the system.
TL;DR: LR is an LR(1) parser generation system written entirely in portable ANS1 standard Fortran 66 and has been successfully operated on a number of computers.
Abstract: LR is an LR(1) parser generation system. It is written entirely in portable ANS1 standard Fortran 66 and has been successfully operated on a number of computers. LR uses a powerful algorithm of Pager's to generate a space efficient parser for any LR(1) grammar. Generated parsers have been used in a variety of compilers, utility programs, and applications packages.
TL;DR: A hierarchical graph model for programs based on the concepts of recursive graphs (RG's) and Codd relations is presented to clearly represent the structure of a program implemented in a structured language, such as Pascal, Algol, or PL/1 so that the program can be analyzed and modifications to the programs can be clearly specified.
Abstract: In this paper a hierarchical graph model for programs based on the concepts of recursive graphs (RG's) and Codd relations is presented. The purpose of the model is to clearly represent the structure of a program implemented in a structured language, such as Pascal, Algol, or PL/1, so that the program can be analyzed and modifications to the program can be clearly specified. The model uses an RG representation for the control flow and the data flow with an equivalent relational representation. It also has a relational representation for the objects defmed within the program. The various aspects of the model are illustrated using Pascal constructs and a model for an example Pascal program is given.
TL;DR: An approximate expression of the probability distribution of the number of blocked first- level servers conditioned upon a service completion of a first-level server is obtained and this expression compares well with simulation data.
Abstract: The exponential open queue network model studied here consists of n symmetrical queues in parallel served by independent first-level servers in tandem with a second-level server. Blocking of the flow of units through a first-level server occurs each time the server completes a service. The server remains blocked until its blocking unit completes its service at the second-level server. An approximate expression of the probability distribution of the number of blocked first-level servers conditioned upon a service completion of a first-level server is obtained. This expression compares well with simulation data. Based on this distribution, an approximate expression of the queue-length probability distribution is derived assuming a processor-sharing type of service. The exact condition for stability of the queue network is also derived. Some potential applications are discussed, and a quantitative evaluation of the model is given through a case study.
TL;DR: A simple portable interpreter for testing the specifications of problems is presented and specificiations are supposed to be expressed in the formalism of attribute grammars, so that the parsing can be directed by the semantics.
Abstract: A simple portable interpreter for testing the specifications of problems is presented in this paper. These specificiations are supposed to be expressed in the formalism of attribute grammars. The parsing and the semantics evaluation are carried out simultaneously, so that the parsing can be directed by the semantics. This increases the power of the grammars and context sensitive characteristics of a language can be described.