This paper describes a new metric for evaluating the cost effectiveness of software reviews. The proposed metric is based on the degree to which costs needed for detecting all faults from software are reduced by software reviews in a project. The metric can be interpreted as combining two conventional metrics proposed by Fagan (1976) and Collofello and Woodfield (1989). As the proposed metric is normalized by virtual testing cost, we can compare the values of it among any different kind of projects. Using an experimental evaluation of the conventional metrics and the proposed metric for data collected in an industrial environment, we show the validity and usefulness of the proposed metric. In addition, we present a method to estimate a value of the proposed metric by using only the values which can be computed during the software reviews.

The telegram analysis problem posed by P. Henderson and R. A. Snowdon has been repeatedly taken into account. This paper adds yet another contribution to this problem. We propose a rigorous specification method, and describe how programs can be derived from it. This method functional programming by which procedural programs can be easily derived from a formal specification in the form of an abstract sequential machine. The method has been applied to sorting, file handlers and High Level Data Link Control Procedures.

This paper customizes Goal/Question/Metric (GQM) project monitoring models for various projects and organizations to take advantage of the data from the software tool EPM and to allow the tailoring of the interpretation models based upon the context and success criteria for each project and organization. The basic idea is to build less concrete models that do not include explicit baseline values to interpret metrics values. Instead, we add hypothesis and interpretation layers to the models to help people of different projects make decisions in their own context. We applied the models to two industrial projects, and found that our less concrete models could successfully identify typical problems in software projects.

We present a comparison of correlated failures for multiversion software using community error recovery (CER) and software breeding (SB). In CER, errors are detected and recovered at checkpoints which are inserted in all the versions of the software. SB is analogous to the breeding of plants and animals. In SB, versions consist of loadable modules, and a driver exchanges the modules between versions to detect and eliminate faulty modules. We formulate reliability models to estimate the probability of failure for software using either CER or SB. Our reliability models assume failures in the checkpoints in CER and the driver in SB. We use beta-binomial distribution for modeling correlated failures of versions, because much of the evidence suggests that the assumption that failures in versions occur independently is not always true. Our comparison indicates that multiversion software using SB is more reliable than that using CER when the probability of failure in the checkpoints in CER or the driver in SB is 10-7.

This letter discusses a relation between reliability and network topology of starred polygon with redundant nodes. Each node of starred polygon is augmented by a spare node, and the degree of survivability is newly defined to evaluate reliability. The main result presents three special topologies of starred polygon with redundant nodes that realize an optimal degree of survivability.

To provide the processor arrays with adequate fault-tolerant capabilities, a number of spare or redundant processors are prepared within the arrays. For such processor arrays, reconfiguration should be executed to bypass faulty processors. Concerning reconfiguration of processor arrays, Melhem presented a minimization problem (called the SPA problem). The SPA problem is to find an assignment of spare processors to faulty processors that minimizes the number of dangerous processors. Here, the dangerous processors are processors, for which there remains no longer any spare processor to be assigned when one more faults occur. In this paper, we present a more rigorous definition of the SPA problem, in which input parameters are n2 ordinary processors, 2n spare processors and m (mn2) faulty processors, and the output is an optimal assignment of spare processors to faulty processors, in the sense that the number of dangerous processors is minimum. Then, we develop an efficient algorithm based on the necessary and sufficient conditions, which allows highly efficient computation of spare processor assignment. The worstcase time complexity of the proposed algorithm is O(n2).

When a group of developers are involved in the distributed development of some software product, they must communicate with one another frequently to exchange information about the product. To reduce the penalty of communication, the support environment should provide developers with their necessary information and update the information automatically while the product is modified by developers. Furthermore, the environment must meet the following requirements despite of workstation failures: whether a specific information is correct or not should always be decidable; as much information as possible should be updated correctly and efficiently. This paper presents a framework to construct such a fault-tolerant environment based on attribute grammars. In the framework, a product is represented by an attributed tree, which is partitioned into several subtrees {T1,,Tm}. Attribute values in each subtree Ti(1im) express the information about the product required by a developer. We introduce a set of redundant data and algorithms to meet the fault-tolerance requirements mentioned above. The correctness of an attribute value in Ti can then be decided in O(mn0log n) time, where n0n, and n is the number of attribute instances in Ti. All available attribute values can be updated with time complexity O(m2n1 log n) and communication complexity O(m2), where n1 is the number of attribute instances that must be reevaluated.

In the program development process, it is ofren necessary for programmers to know the differences between two programs, or two different versions of a program. Since programs have structures such as iteration statement and selection statement, applying text-based tools such as UNIX diff to identify the differences may produce unsatisfactory results. In this paper, we exploit a tree as the internal representation of a program, obtain the mapping between two trees and display the program differences visually based on the mapping and pretty-printing technique so that the structural differences can be identified immediately.

Marc Kellner proposed an example problem intending to compare modeling and describing techniques of software process. In this paper, we will describe our approach to understanding and describing the problem, from a process/product relation view, and synchronization/concurrent view. Also, we will show that a description of the problem is translated for execution and its correctness is validated.

This letter describes system architecture of a measurement environment called GINGER that helps programmer productivity by automatically collecting and analyzing data about software development activities. Based on the result of analysis, the environment gives programmers feedback so that they can recognize and improve their activities. The first prototype system of GINGER is currently implemented in a UNIX environment. We expect that the proposed environment will improve the overall productivity of programmers and the quality of resulting products.