No abstract available.

No abstract available.

Abstract Decades of research on maintenance activities in the procedural paradigm has produced several conclusions. Among these conclusions are recommendations that a reduction in maintenance cost could be achieved by a more controlled design process, and by more rigorous testing of potential problem areas earlier in the life‐cycle. With the increased emphasis on the object‐oriented paradigm, the authors performed an empirical study of the maintenance patterns in two commercial object‐oriented systems. Although this is a preliminary study, intuition is presented as insight into the object‐oriented maintenance activities.

Little or no empirical validation exists for many of software engineering's basic assumptions. While some of these assumptions are intuitive, the need for scientific experimentation remains clear. Several assumptions are made about the factors affecting software reuse, and in particular, the role of the object-oriented paradigm. This paper describes the preliminary results of a controlled experiment designed to evaluate the impact of the object-oriented paradigm on software reuse. The experiment concludes that (1) the object-oriented paradigm substantially improves productivity, although a significant part of this improvement is due to the effect of reuse, (2) reuse without regard to language paradigm improves productivity, (3) language differences are far more important when programmers reuse than when they do not, and (4) the object-oriented paradigm has a particular affinity to the reuse process.

Abstract Maintenance of software makes up a large fraction of the time and money spent in the software life‐cycle. By reducing the need for maintenance these costs can also be reduced. Predicting where maintenance is likely to occur can help to reduce maintenance by prevention. In this paper, maintenance is defined as correction of errors in the program. This paper details a study of the use of software quality metrics to determine high‐complexity components in a software system. By the use of a history of maintenance done on a particular system, it is shown that a predictor equation can be developed to identify components which needed maintenance activities. This same equation can also be used to determine which components are likely to need maintenance in the future. Through the use of these predictions and software metric complexities, it should be possible to reduce the likelihood of a component needing maintenance. This might be accomplished by reducing the complexity of that component through further decomposition. Even though this is only one study, this methodology of developing maintenance predictors could be applied in any environment.

The authors describe an experiment which compares the maintainability of two functionally equivalent systems in order to explore the claim that systems developed with object-oriented languages are more easily maintained than those programmed with procedural languages. Supporting evidence was found that programmers produce more maintainable code with an object-oriented language than with a standard procedural language.>

Abstract A metrics methodology can dramatically reduce the problems associated with software maintenance. However, several issues must be addressed in order to develop and use these techniques successfully. This paper defines a metrics methodology which is designed to deliberately integrate maintainability into software as it is being developed. The benefits of using this approach are discussed. Then several issues which complicate the development and use of the methodology are examined. Previous maintenance studies which incorporate the methodology into two different commercial environments are used to demonstrate the difficulties in implementation and contrast the differences in approach.

Research was performed in an effort to support the theory that software metrics can be used to monitor maintainability during multiple phases of the software life cycle. A methodology for integrating maintainability into software during the software development process by using software metrics is presented. A brief overview of the metrics used in this study is given. An example of how the methodology has been applied in a commercial software development environment is provided.>

Abstract For many years the software engineering community has been attacking the software reliability problem on two fronts. First via design methodologies, languages and tools as a pre‐check on complexity and secondly by measuring the complexity of produced software as a post‐check. This research attempts to unify the approach to creating reliable software by providing the ability to measure the complexity of a design prior to its implementation. We have successfully defined and applied software metrics to graphical designs in an effort to predict software complexity early in the software life cycle. Metric values from the graphical design are input to predictor equations, provided in this paper, to give metric values for the resultant source code.

Software quality metric were developed to measure the complexity of software systems. The authors relate the complexity of the system as measured by software metrics to the amount of maintenance necessary to that system. The authors have developed a model which uses several software quality metrics as parameters to predict maintenance activity. A description is given of three classifications of metrics that are used to measure the quality of source code: code metrics, which measure physical characteristics of the software, such as length or number of tokens; structure metrics, which measure the connectivity of the software, such as the flow of information through the program and flow of control; and hybrid metrics, which are a combination of code and structure metrics.>

In the last decade, the field of Computer Science has undergone a revolution. It has started the move from a mysterious art form to a detailed science. The vehicle for this progress has been the rising popularity of the field of Software Engineering. This innovative area of computer science has brought about a number of changes in the way we think of, and work with, the development of software. Due to this renovation, a field that started with little or no design techniques and unstructured, unreliable software has progressed to a point where a plethora of techniques exist to improve the quality of a program design as well as that of the resultant software. The popularity of structured design and coding techniques prove that there is widespread belief that the overall product produced using these ideas is somehow better, and statistics seem to indicate that this belief is true. Until recently, however, there existed no technique for quantitatively showing one program better than its functional equivalent. In the past few years, the use of software quality metrics seems to indicate that such a comparison is not only possible, but is also valid.

Abstract The design and analysis of the structure of software systems has typically been based on purely qualitative grounds. In this paper we report on our positive experience with a set of quantitative measures of software structure. These metrics, based on the number of possible paths of information flow through a given component, were used to evaluate the design and implementation of a software system (the UNIX operating system kernel) which exhibits the interconnectivity of components typical of large‐scale software systems. Several examples are presented which show the power of this technique in locating a variety of both design and implementation defects. Suggested repairs, which agree with the commonly accepted principles of structured design and programming, are presented. The effect of these alterations on the structure of the system and the quantitative measurements of that structure lead to a convincing validation of the utility of information flow metrics.

This paper makes an attempt to outline Software Engineering course with particular attention on the administration of the project.

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.