No full-text available
To read the full-text of this research,
you can request a copy directly from the author.
Really Object-Oriented Software Metrics
Abstract
The efficiency in the software development can only be keept by quantification of the software development components (of the software product and the software process itself). The quantification as software measurement needs a unified strategy, methodology or approach to guarantee the goals of quality assurance, improvement and controlled software management. Presently, plenty of methods such as measurement frameworks, maturity models, goal-directed paradigms, process languages etc. exist to support this idea.
This paper gives an overview about the measurement framework methodologies and describes an object-oriented approach of a software measurement framework. The presented framework was applied to the object-oriented software metrics area and leads to really object-oriented software metrics. The usability of this approach was described in some object-oriented software development examples.
In order to apply the software metrics for the JAVA software development we use a general metrics classification of the University of Magdeburg in our Software Measurement Laboratory [DuFo96].
The year 2000 problem (Y2K) is “not just a technical problem, it is a worldwide business problem affecting people and organizations everywhere” [1]. The complexity of this problem and its solution can be resolved succesfully only on a measurement-based software development or maintenance environment.
In this paper we analyse the “measurement situation” on the Y2K area and consider the possibilities of the application of the existing results on the field of software measurement. In order to present the measurement aspects in a systematic manner, we use our measurement framework that leeds to a persistent metrics program in a given software development or application environent.
As the role that software metrics in general and coupling in particular play with respect to maintainability of software products is widely accepted, current approaches to handle coupling and / or cohesion in object-oriented systems are evaluated. Having identified some inadequacies , we provide a comprehensive framework to deal with all sorts of coupling. This framework takes into account the distinction between object level-and class level coupling. This distinction refers to dynamic dependencies between objects on one hand and static dependencies between implementations on the other hand, representing important aspects of software quality at run-time and during the maintenance phase, respectively. As far as cohesion is concerned, we analyze a well known metric put forward by Chidamber and Kemerer and restated by Li and Henry. As a result, we present a graph theoretic improved version of this metric.
While software metrics are a generally desirable feature in the software management functions of project planning and project evaluation, they are of especial importance with a new technology such as the object-oriented approach. This is due to the significant need to train software engineers in generally accepted object-oriented principles. This paper presents theoretical work that builds a suite of metrics for object-oriented design. In particular, these metrics are based upon measurement theory and are informed by the insights of experienced object-oriented software developers. The proposed metrics are formally evaluated against a widelyaccepted list of software metric evaluation criteria.
Now in its second edition, this best seller presents detailed information about how to construct, evaluate, and use questionnaires. New to this second edition is a chapter that includes two different methods of sampling and determining an appropriate sample size for reliable results. the author has updated the chapter on reliability and validity to cover more information about other forms of reliability. Also added is a chapter devoted to presenting examples on real customer satisfaction measures and how they can be used. Other topics include guidelines for developing questionnaires, scale development, the concept of quality, frequencies, sampling error, and two methods of determining important service or product characteristics as perceived by the customer.
In this approach, we propose criteria which can assess the quality of C++ classes, developed using ADTs and inheritance features in object-oriented programming environment. Proposed criteria consist of two parts: one is module strength, the other is coupling which have characteristics of C++ classes with ADTs and inheritance mechanism. These criteria can be applied to assess the quality of the components written in C++ before registering into the library.
Aspects of software Measurement history of Software Measurement foundation of Software Measurement I foundations of Software Measurement II Measurement theory and object-oriented software measures desirable properties of software measures validation of software measures and prediction models applications of software measures afterword solutions of exercises glossary of terms and terms used as synonyms. Attachment 1 - the system ZD-MIS attachment 2 - proof of the equivalence of extensive structures attachment 3 - proof of the theorems of chapter 8 attachment 4 - proof of the theorems of chapter 5 attachment 5 - notations and used symbols attachment 6 - axioms systems definitions theorems exercises references to literature name and subject indexes.
Object-Oriented design refers to a set of disciplines for organizing large software systems. Language support for object-oriented design includes facilities for data abstraction and inheritance. C++ is an extension of the C programming language that directly supports object-oriented constructs. Key features of C++ include support for classes, objects, and messages, operator overloading, and simplified heap storage manipulations. This paper describes how these features affect software development strategies. An idiom developed in our laboratory is illustrated in an example.
The development of software metrics for object oriented (OO) languages is receiving increasing attention. We examine the reasons why this is a much more challenging problem than for conventional languages. It seems premature to develop and apply OO metrics while there remains uncertainty not only about the precise definitions of many fundamental quantities and their subsequent impact on derived metrics, but also a lack of qualitative understanding of the structure and behaviour of OO systems. We argue that establishing a standard terminology and data model will help provide a framework for both theoretical and empirical work and increase the chances of early success. One potential benefit is improvement of the ability to perform independent validation of models and metrics. We propose a data model and terminology and illustrate the importance of such definitions by examining the seemingly straightforward concept of the number of methods per class. We discuss the implications of ambiguities in definitions for a suite of metrics which has recently been proposed. Preliminary results from our analysis of industrial systems are presented.
An abstract is not available.
An abstract is not available.
An abstract is not available.
A conceptual framework that gives a rationalized overview of the subject of software measurement is presented. The framework is based on 1.(a) a rigorous approach to measurement extracted from basic ideas in measurement theory, and2.(b) a classification scheme that partitions the domain of software production by considering the entities that are amenable to measurement.
This framework is proposed as a conceptual basis for the teaching material to be produced by the “METKIT” (Metrics Educational ToolKIT) ESPRIT project; in particular, it gives rise to a systematic classification of the subject matter of Software Measurement.
Software metrics are widely used to measure software complexity and assure software quality. However, research in the field of software complexity measurement of a class hierarchy has not yet been carefully studied. The authors introduce a novel factor called unit repeated inheritance (URI) and an important method called the inheritance level technique (ILT) to realize and measure the object-oriented software complexity of a class hierarchy. The approach is based on the graph-theoretical model for measuring the hierarchical complexity in inheritance relations. The proposed metrics extraction shows that inheritance is closely related to the object-oriented software measurement and reveals that overuse of the repeated (multiple) inheritance will increase software complexity and be prone to implicit software errors
Recent government software initiatives have made it mandatory for industry to increase its emphasis on software quality. Ford Aerospace & Communications Corporation recognized the need for software product excellence eight years ago, and established a program of planned and systematic activities to determine, achieve, and maintain the required software quality. This session will present progress made, lessons learned, potential pitfalls of establishing a software quality assurance program, and sustaining it. Topics to be discussed will include: Establishing policies, standards and procedures; Elements of the SQA program; Attracting and retaining qualified software professionals; Independent reporting; Gaining top management and customer support; Overcoming organizational resistance to change; Do's and don't's of problem escalation; and where do we go from here?
In this paper, we investigate how to incorporate program complexity measures with a software quality model. We collect software complexity metrics and fault counts from each build during the testing phase of a large commercial software system. Though the data are limited in quantity, we are able to predict the number of faults in the next build. The technique we used is called times series analysis and forecasting. The methodology assumes that future predictions are based on the history of past observations. We will show that the combined complexity quality model is an improvement over the simpler quality only model. Finally, we explore how the testing process used in this development may be improved by using these predictions and suggest areas for future research.
Software quality metrics have potential for helping to assure the quality of software on large projects such as the Space Shuttle flight software. It is feasible to validate metrics for controlling and predicting software quality during design by validating metrics against a quality factor. Quality factors, like reliability, are of more interest to customers than metrics, like complexity. However quality factors cannot be collected until late in a project. Therefore the need arises to validate metrics, which developers can collect early in a project, against a quality factor. We investigate the feasibility of validating metrics for controlling and predicting quality on the Space Shuttle. The key to the approach is the use of validated metrics for early identification and resolution of quality problems.
It is shown how the whole idea of a 'software complexity measure' can be axiomatized in such a way as to include the more familiar concrete examples and to allow for new measures that might offer advantages not captured by those previously introduced. In particular, a new testing measure is introduced, based on the 'multiple-condition' test strategy. Comparisons are made between this new measure and the more traditional metrics. In addition, a more general theoretical study is initiated, showing the effect of the axiomatic development in relation to the treatment of program structuredness.