Object-Oriented Metrics: an Annotated BibliographyEmpirical Software Engineering Research Group

Department of ComputingBournemouth University

Poole BH12 5BB, UK

Email: mshepper@bournemouth.ac.ukhttp://dec.bournemouth.ac.uk/ESERG/

This updated bibliography is copyright of Bournemouth University. The bibliography may be copied and distributed freely for non-profit making purposes, provided this copyright is acknowledged and this copyright notice is attached to any copies made.

[1] Aarsten, A. and M. Morisio. 'Using object oriented technology to measure the software process', in Proc. Proc. 3rd IFIP Int. Conf. on Achieving Quality in Software. Firenze, Italy: 1996.

Keywords: Man, Qual

Abstract: "This paper reports on how object-oriented concepts and technology have been applied to measure a software process in the ESSI AEFTA (Application Enabler Technology for Factory Automation) application experiment. Measurement is considered as a full scale project consisting of 1) modelling the software process, 2) defining goals for the project, 3) formalizing goals in process measures defined on the process model, 4) designing the technological support for measures (procedures and tools, repository), 5) implementing the technological support, 6) implementing the measurement process, 7) assessing the measurement process, modifying it, if needed. The object-oriented approach has been applied in 1, 4 and 5. The process model is defined using OMT; process measures are defined using a query language to express queries on OMT object models; the repository for measures is obtained by automatic translation of the OMT process model into a set of persistent C++ classes; process measures are manually translated in C++ functions members of the persistent classes. The advantages of applying the OO approach are discussed: sharing of tools, training, know-how and mindset with the rest of the project; ease in changing measures to adapt to changes in the process, thus possibility of applying an evolutionary incremental lifecycle to the measurement process; lower effort in the implementation of the technological support for measurement."

Notes: Maurizio Morisio is at morisio@polito.it. See also [Morisio, 1995, "A methodology to measure the software process"]

[2] Abbott, D. H., T. D. Korson, et al., A proposed design complexity measure for object-oriented development. No. TR 94-105, Clemson University, 1994.

Keywords: Prod, Des, Emp

Abstract: See also Ojha and McGregor, 1994. The measurement of software complexity has been a key interest of software engineers for many years. However, design metrics for the object-oriented paradigm have been little studied. We propose a metric for measuring the number and strength of the object interactions permitted by an object-oriented design and show that this metric is useful for predicting experts' design

preferences. The metric is derived from the design information captured in class definitions and hence can be calculated relatively early in the development life-cycle and calculated objectively. The conceptual model of complexity that supports the metric distinguishes two types of complexity applicable to class definitions - interaction level and interface size - and the derivation of the metric shows how these two measures relate to the proposed metric. To validate the metric, we prepared/located 9 sets of 2 or 3 design alternatives and subjected these to evaluation by both the proposed metric and a collection of object-oriented design experts. We found that the experts' preferred alternatives and the alternatives preferred by the metric agreed in 16 of 20 cases, thereby providing evidence of the predictive power of the metric.

Notes: The TR is available by anon ftp: ftp://ftp.cs.clemson.edu/techreports/94-105.ps.Z.

[3] Abernethy, K. and J. C. Kelly. 'Comparing object-oriented and data flow models-a case study', in Proc. 1992 ACM Computer Science Conference. ACM, New York, NY, USA, 1992.

Keywords: Des, Emp, Prod

Abstract: Object-oriented analysis is the newest component of a proposed object-oriented software life cycle methodology. In this paper, we make comparisons between the standard data flow diagram (DFD) models and the newly introduced object models within the context of an existing moderately complex (approx. 65,000 lines) software project. In particular, we compare the complexities of competing models for the project domain using some simple metrics.

[4] Abreu, F. B. 'Metrics for Object-Oriented Development', in Proc. Proc. 3rd International Conference on Software Quality. Lake Tahoe, Nevada, USA: 1993.

Keywords: Prod, Theory

Abstract: There is an increasing need for metrics adapted to the Object-Oriented (OO) paradigm to help manage and foster quality in software development. This paper reviews the usefulness of metrics, discusses some inadequacies of "traditional" metrics to encompass development under the OO paradigm and proposes a framework for classifying OO metrics. In this framework, metrics are classified along two independent vectors: category and granularity. The rationale behind each category is presented. Candidate metrics are suggested within the referred framework. Finally, some research directions that require further effort are identified.

[5] Abreu, F. B. 'MOOD - Metrics for Object-Oriented Design', in Proc. OOPSLA'94 Workshop Paper Presentation. 1994.

Keywords: Prod, Des, Theory

Abstract: Annotation from C. Gibbon.

Unfortunately, a little too sparse owing to the restrictions on the OOPSLA'94 Workshop. He releases the need for external and internal attributes. Presents copious mathematical notations to encompass metrics pertaining to encapsulation, polymorphism, information hiding, message passing, inheritance and reuse. Furthermore, the paper lists a set of criterion which design metrics should fulfil.

[6] Abreu, F. B. 'Object-oriented software engineering: measuring and controlling the development process',

in Proc. 4th International Conference on Software Quality. Washington DC: American Society of Quality Control, 1994.

Keywords: Prod, Des, Reuse, Qual, Man

Abstract: A set of metrics measuring inheritance, encapsulation, information hiding and polymorphism. These are envisaged as aids to setting design standards, making comparisons and to the management of projects.

[7] Abreu, F. B., 'Design Quality Metrics for Object-Oriented Software Systems', ERCIM News, (23), 1995.

Keywords: Des, Prod

Notes: Also available from http://www-ercim.inria.fr/publication/Ercim_News/enw23/abreu.html

[8] Abreu, F. B. and R. Carapuca, 'Candidate Metrics for Object-Oriented Software within a Taxonomy Framework', J. of Systems & Software, 26, pp87-96, 1994.

Keywords: Des, Rev

Abstract: This article offers an overview of the state of the art in object-oriented (OO) metrics as well as some new contributions. The usefulness of metrics is reviewed. The inappropriateness of "traditional" metrics to encompass development under the OO paradigm is discussed. A framework for classifying metrics is suggested. Metrics are classified along two vectors: category and granularity. The usefulness and rationale behind each category are presented. Candidate metrics are suggested within the proposed framework. Finally, some research directions that require further effort are identified.

Notes: Introduces the TAPROOT framework (TAxonomy PRecis for Object-Oriented meTrics) which has two axes, category and granularity. The categories are: design; size; complexity; reuse; productivity; and quality. The granularities are: method; class; and system. They show how all (?) of the OO metrics proposed so far fit into this framework, where there are no examples they propose some.

[9] Abreu, F. B., R. Esteves, et al. 'The design of Eiffel programs: quantitative evaluation using the MOOD metrics', in Proc. TOOLS'96. Santa Barbara, California, USA: 1996.

Keywords: Des, Prod, Emp

[10] Abreu, F. B., R. Esteves, et al., The design of Eiffel programs: quantitative evaluation using the MOOD metrics. Technical Report , INESC, 1995.

Keywords: Emp, Des, Prod

Abstract: Gives details on how the MOOD metrics may be implemented for Eiffel. An extensive empirical examination of the metrics is made in order to determine their expected ranges of values, the extent to which they are size-independent etc.

[11] Abreu, F. B., M. Goulao, et al. 'Toward design quality evaluation of object-oriented software systems', in Proc. 5th International conference on software quality. Austin, Texas, USA: 1995.

Keywords: Des, Qual

[12] Abreu, F. B. and W. Melo. 'Evaluating the impact of object-oriented design on software quality', in Proc. 3rd International Software Metrics symposium. Berlin, Germany: IEEE Computer Society Press, 1996.

Keywords: Qual, Des, Emp, C++

Abstract: Describes the results of a study where the impact of object-oriented (OO) design on software quality characteristics is experimentally evaluated. A suite of Metrics for OO Design (MOOD) was adopted to measure the use of OO design mechanisms. Data collected on the development of eight small-sized information management systems based on identical requirements were used to assess the referred impact. Data obtained in this experiment show how OO design mechanisms such as inheritance, polymorphism, information hiding and coupling, can influence quality characteristics like reliability or maintainability. Some predictive models based on OO design metrics are also presented.

[13] Achee, B. L. and D. L. Carver. 'Evaluating the quality of reverse engineered object-oriented designs', in Proc. 1997 IEEE Aerospace Conference. Proceedings. IEEE, New York, USA, 1997.

Keywords: Des, Qual

Abstract: Software quality is a multifaceted concept that can be described from different perspectives. Five perspectives are the transcendental view, user view, manufacturing view, product view, and value-based view. The definition of software quality is based upon the perspective taken. However, these views do not address the design phase of the software lifecycle. Moreover, the issues pertinent to forward engineering do not necessarily parallel those pertinent to reverse engineering. The quality of a forward engineered design can be discussed in several contexts, such as how well the design represents the requirements specification or the evaluation of the design using a given set of metrics. In reverse engineering, however, this is not the case. The issues involved in evaluating the quality of an object-oriented design extracted from an imperative language differ from those involved in evaluating a forward engineered object-oriented design. This paper discusses the shortcomings of measuring the quality of a reverse engineered object-oriented design using current models based on forward engineering, and offers insights to a plausible solution.

[14] Ada, Ada and C++: a business case analysis. No. 1-800-AdaIC-11, Ada Information Clearinghouse, 1991.

Keywords: C++, Emp, Man

Abstract: Report on 5 independent studies carried out for the US Air Force to determine whether there might sometimes be a case for waiving the requirement for contractors to work in Ada in favour of C++. Rather than trying to identify whether there are specific circumstances which might make C++ the better choice, the studies do an overall comparison of data on costs, error rates, language facilities etc. The conclusion is that Ada is a more mature language than C++, is better supported and leads to more reliable and maintainable products. This is one of the few sources of comparison data which I have seen, but it is a bit dated now: for instance, the TRW substudy estimated (more than 3 years ago) that Ada was 3 years behind Ada in maturity and tool support.

Notes: A very useful summary, extracted from a press conference given by Lloyd Mosemann II of the US Air Force, was posted to the Ada Joint Program Office bulletin board. I saw this on the ami Electronic Discussion Group and can mail people a copy. The report itself can be ordered from Ada Information Clearinghouse, PO Box 46593, Washington DC 20050-6593, Tel: 703 685 1477, Fax: 703 685 7019, E-mail: adainfo@ajpo.sei.cmu.edu

[15] Adams, S. 'OO metrics to investigate', in Proc. OOPSLA'92 Workshop: Metrics for Object-Oriented Software Development. Vancouver, Canada: 1992.

Keywords: Prod

Notes: See Roberts' report on this workshop [Roberts 1992].

[16] Agresti, W. W. and W. M. Evanco, 'Projecting software defects from analysing Ada designs', IEEE Transactions on Software Engineering, 18(11), pp988-997, 1992.

Keywords: Emp, Des

[17] Alagic, S. 'Polymorphic and Reflective Type Structures', in Proc. Technology of Object-Oriented Languages and Systems (TOOLS 8). Santa Barbara, USA: Prentice Hall, 1992.

Keywords: Theory, Rev

Abstract: A tutorial introduction to some difficult work in type theory. Presenting a model of polymorphism for subtypes, parametric types and higher order types (kinds).

[18] Al-Janabi, A. and E. Aspinall, 'An evaluation of software design using the DEMETER tool', Software Engineering Journal, 8(6), pp319-324, 1993.

Keywords: Tool, Emp, Prod, Des

Notes: A study of 3 small (1.2-5KLOC) systems found that various measures of coupling were able to "explain" just under 60% of code quality in terms of average no. of decisions.

[19] Alkadi, G. and D. L. Carver. 'Application of metrics to object-oriented designs', in Proc. 1998 IEEE Aerospace Conference Proceedings. IEEE, New York, NY, USA, 1998.

Keywords: Des, Prod, Emp, Tool

Abstract: The benefits of object-oriented software development are now widely recognized. However, methodologies that are used for the object-oriented software development process are still in their infancy. There is a lack of methods available to assess the quality of the various components that are derived during the development process. In this paper, we describe a method to assess the quality of object-oriented designs. We utilize a basic set of object-oriented metrics that is proposed by Shyam Chidamber et al. (1991 and 19994). We perform experimental tests on a set of object-oriented designs using the NOC metric. Also, we refer to our ongoing work to provide automated assistance to help restructure the design based on the metric findings.

[20] Alonso, F., J. L. Fuertes, et al. 'A quality model: how to improve the object-oriented software process', in Proc. SMC'98 (1998 IEEE International Conference on Systems, Man, and Cybernetics). IEEE, New York, NY, USA, 1998.

Keywords: Qual

Abstract: We have established a quality model for the object oriented paradigm. Quality is divided into factors and these into criteria. We have designed 350 measures, bearing in mind a particular attribute of the object orientation, and have been connected to the criteria to set up the model. We outline a new methodology for applying this model to improve the object oriented software process by establishing a set of steps to be applied in the phases of object oriented development.

[21] Aman, M., T. Yanaru, et al., 'A metric for class structural complexity focusing on relationships among class members', IEICE-Transactions-on-Information-and-Systems., E81-D(12), pp1364-1373, 1998.

Keywords: Prod, Theory

Abstract: We represent a class structure using a directed graph in which each node corresponds to each member of the class. To quantify the dependence relationship among members, we define weighted closure. Using this quantified relationship and effort equation proposed by M.H. Halstead (1977), we propose a metric for class structural complexity.

[22] Ammann, M. H. and R. D. Cameron. 'Measuring program structure with inter-module metrics', in Proc. Eighteenth Annual International Computer Software and Applications Conference (COMPSAC 94). IEEE Comput. Soc. Press, Los Alamitos, CA, USA, 1994.

Keywords: Qual, Tool, Prod

Abstract: A good structure is an important quality aspect of a program. Well-structured, modular programs are less costly to maintain than unstructured monolithic ones. Quantitatively assessing structure and modularity of programs can be useful to help ensure that a program is well-structured by indicating a potential need for restructuring of poorly structured code. However, previous structure metrics do not sufficiently account for the modular features used in modern, object-oriented programming languages. We propose four novel measures to assess the modular structure of a software project. Our measures are based on the principle of vocabulary hiding and measure a form of cohesion. A metrics prototype tool has been implemented for the Modula-3 programming language. Informal tests suggest that they are indeed useful to assess the quality of the program structure.

[23] Anderson, B., Architecture and maintenance in object technology. Unpublished report , Electronic Systems Engineering, University of Essex, UK, 1994.

Keywords: Des, Maint

Abstract: In order to explore the impact of different architectures on software maintenance, we took the following approach: write two versions of the same application with differing architectures; implement the same specific changes to both versions; measure the cost of making each change using simple metrics; and compare the costs of each change between architectures, and also within the same architecture. For our

example we chose a simple banking application which must operate on a number of different kinds of account.

[24] Andrade, R. and G. H. Travassos. 'Principles, guidelines and metrics: their relationship and application to reduce structural complexity of object oriented design', in Proc. European Software Measurement Conference. FESMA 98. Technologisch Instituut Vzw, Antwerpen, Germany, 1998.

Keywords: Prod, Qual

Abstract: The tendency of software complexity is to increase for each new software product developed. When software seems highly complex an associated problem is to guarantee the quality of the products throughout the software development process. There are several studies related to reducing OO software complexity, such as principles and guidelines, while a great deal of metrics to control OO software quality have been proposed. However, the relation between OO software complexity reduction techniques and metrics are still not well explored. This relation can help in design decisions that follow metrics application tasks. This work presents a summary of a research about the simultaneous application of metrics for OO design quality and techniques to reduce OO software complexity.

[25] Antoniol, G., F. Calzolari, et al. 'Adapting function points to object oriented information systems', in Proc. Advanced Information Systems Engineering. 10th International Conference, CAiSE'98. Springer-Verlag, Berlin, Germany, 1998.

Keywords: Size, Tool, Prod

Abstract: The object oriented paradigm has become widely used to develop large information systems. This paper presents a method for estimating the size and effort of developing object oriented software. The approach is analogous to function points, and it is based on counting rules that pick up the elements in a static object model and combine them in order to produce a composite measure. Rules are proposed for counting "Object Oriented Function Points" from an object model, and several questions are identified for empirical research. A key aspect of this method is its flexibility. An organization can experiment with different counting policies, to find the most accurate predictors of size, effort, etc. In its environment. "Object Oriented Function Points" counting has been implemented in a Java tool, and results on size estimation obtained from a pilot project with an industrial partner are encouraging.

[26] Antoniol, G., R. Fiutem, et al. 'Using metrics to identify design patterns in object-oriented software', in Proc. Proceedings Fifth International Software Metrics Symposium. IEEE Comput. Soc, Los Alamitos, CA, USA, 1998.

Keywords: Prod, Des, Emp, Tool

Abstract: Object-oriented design patterns are an emergent technology: they are reusable micro-architectures, high level building blocks. This paper presents a conservative approach, based on a multi-stage reduction strategy using OO software metrics and structural properties to extract structural design patterns from OO design or code. Code and design are mapped into an intermediate representation, called Abstract Object Language, to maintain independence from the programming language and the adopted CASE tools. To assess the effectiveness of the pattern recovery process a portable environment written in Java, remotely accessible by means of any Web browser, has been developed. Based on this environment, experimental results obtained on public domain and industrial software are discussed in the paper.

[27] Archer, C., Measuring object-oriented software products. Tech. report No. SEI-CM-028, Software Engineering Institute, Carnegie Melon University, 1995.

Keywords: Rev, Man

Abstract: "This module provides an overview of the merging of a paradigm and a process, the object-oriented paradigm and the software measurement process. The concept of a measure and the process of measurement are discussed briefly, followed by a presentation of the issues raised by object-oriented software development."

Notes: Length 81 pages. Reports from the SEI are available from Research Access Inc., Fax. +1 412 321 2994. E-mail: requests@rai.com. Web: http://www.rai.com/.

[28] Archer, C. and M. Stinson, Object-oriented software measures. Tech. report No. SEI-95-TR-002, Software Engineering Institute, Carnegie Melon University, 1995.

Keywords: Rev

Abstract: "This paper provides an overview of the merging of a paradigm and a process, the object-oriented paradigm and the software measurement process. A taxonomy of object-oriented software measures is created, and existing object-oriented software measures are enumerated, evaluated, and placed in taxa. This report includes an extensive bibliography of the current object-oriented measures that apply to the design and implementation phases of a software project. Examples of computation of representative measures are included."

Notes: Length 67 pages. See [Archer 1995] on availability.

[29] Armour, F., B. Catherwood, et al. 'Experiences Measuring Object Oriented System Size with Use Cases', in Proc. ESCOM. Wilmslow, UK: 1996.

Keywords: Ind, Size

[30] Arnold, M. and P. Pedross. 'Software size measurement and productivity rating in a large-scale software development department', in Proc. Proceedings of the 1998 International Conference on Software Engineering. IEEE Comput. Soc, Los Alamitos, CA, USA, 1998.

Keywords: Des, Size, Emp, Ind

Abstract: Some current object-oriented analysis methods provide use cases. Scenarios or similar concepts to describe functional requirements for software systems. The authors introduced the use case point method to measure the size of large-scale software systems based on such requirements specifications. With the measured size and the measured effort the real productivity can be calculated in terms of delivered functionality. In the status report they summarize the experiences made with size metrics and productivity rates at a major Swiss banking institute. They analyzed the quality of requirements documents and the measured use case points in order to test and calibrate the use case point method. Experiences are based on empirical data of a productivity benchmark of 23 measured projects (quantitative analysis), 64 evaluated questionnaires of project members and 11 post benchmark interviews held with selected project managers (qualitative analysis).

[31] Avotins, J. 'Towards an object-oriented metric modeling method', in Proc. OOPSLA'96 - workshop: OO product metrics. 1996.

Keywords: Qual, Man, Des

Abstract: A paper presenting the authors method for modelling OO design metrics in an object oriented manner. The idea behind the work is the comparison of existing metric modelling methods to the waterfall lifecycle and it's associated problems. The author postulates that existing metric models suffer from the same problems caused by a strict top-down methodology as does the waterfall model. The solution presented is to define a method which includes reversibility and seamlessness. From the authors view point the only way to achieve this is to adopt an object-oriented metric modelling method. The cluster lifecycle model is used as the basis for defining a new metric model. An overview is given of this proposed method and the tools which have been developed to support it. The method also takes elements from GQM and the metric modelling method of Shepperd and Ince.

[32] Avotins, J. and C. Mingins. 'Metrics for Object-Oriented Design', in Proc. TOOLs 12. Melbourne: Prentice Hall, 1993.

Keywords: Tool, Prod, Des

Abstract: Quality is not an innate property of object-oriented design. A solid set of techniques and methods is required to ensure quality. Formal design theories and their associated metrics can be analysed to produce design principles, and fine tune the current a posteriori and posteriori design approaches. An iterative fine tuning quality design policy, and an associated tool that supports this policy are also presented.

[33] Ayerbe, A. and I. Vazquez. 'Software products quality improvement with a programming style guide and a measurement process', in Proc. The Twenty-Second Annual International Computer Software and Applications Conference (Compsac '98). IEEE Comput. Soc, Los Alamitos, CA, USA, 1998.

Keywords: C++, Qual, Prod

Abstract: Quality requirements of industrial software are very high and the correctness of the source code is of great importance for this purpose. For this reason, the objective of QUALIMET (ESSI Project 23982) is to improve the software development process, introducing a set of style norms to be used when coding in C++, defining a set of metrics to be used on the source code in order to check its quality and testing this approach in a baseline project. The paper presents the work that is being carried out under this project It is expected that at the end of QUALIMET, the incorporation of these quality assurance techniques into the current methodology for developing software, will allow to have a complete methodology that guarantees software product quality, minimising the complexity of the code earlier in the programming process, yielding more maintainable and less error-prone software and improving the quality of the software and the satisfaction of customers.

[34] Balasubramanian, N. V. 'Object-Oriented Metrics', in Proc. Asia-Pacific Software Engineering Conference. IEEE, 1996.

Keywords: Prod

Abstract: The paper introduces class complexity, cohesion ratio, and weighted method send out as

improved/new metrics for object-oriented software. The work of Chidamber and Kemerer (1991, 1994) is used as a comparison platform. Illustrations are provided by solving a simple graphical problem using two design approaches. They are also used to validate the model proposed. Desirability of a composite complexity model is discussed and one possible approach is given.

Notes: Based on CK metrics plus additional measures. Applied to two student programs but analysis of results not provided

[35] Bandi, R. K. and V. K. Vaishnavi. 'Validating object-oriented design complexity metrics', in Proc. OTC '96. Object Technology Centers. Comsoft, Collegedale, TN, USA, 1996.

Keywords: Maint

Abstract: Many organizations are introducing object oriented methods and languages into their software development practices. A major motivation for organizations to move to OO technology is to reap the promised quality and productivity gains. Software metrics have the potential for use in procedures to control software development process, thereby controlling costs and schedules as well as the quality of the software product. As a result there is a great interest in metrics for object oriented systems. Many metrics have been proposed, but very few of them have been validated. This research focuses on the validation of these metrics with respect to maintainability of object oriented systems.

[36] Banker, R. D., S. M. Datar, et al., 'A model to evaluate variables impacting the productivity of software maintenance projects', Management Science, 37(1), 1991.

Keywords: Size, Maint, Emp

[37] Banker, R. D., R. J. Kauffman, et al., 'An empirical test of object-based output measurement metrics in a computer aided software engineering (CASE) environment', Journal of Management Information Systems, 8(3 Winter 1991-92), pp127-150, 1991.

Keywords: Emp

[38] Banker, R. D., R. J. Kauffman, et al. 'Output measurement metrics in an object-oriented computer aided software engineering (CASE) environment: critique, evaluation and proposal', in Proc. Proceedings of the 24th Hawaii International Conference on System Science,. Hawaii: IEEE Computer Society Press, 1991.

Keywords: Prod

[39] Banker, R. D., R. J. Kauffman, et al., 'Automating output size and reuse metrics in a repository-based computer-aided software engineering (CASE) environment', IEEE Transactions on Software Engineering, 20(3), pp169-187, 1994.

Keywords: Size, Tool, Reuse

Abstract: Measurement of software development productivity is needed in order to control software costs, but it is discouragingly labor-intensive and expensive. Computer-aided software engineering (CASE) technologies-especially repository-based, integrated CASE-have the potential to support the automation of

this measurement. We discuss the conceptual basis for the development of automated analyzers for function point and software reuse measurement for object-based CASE. Both analyzers take advantage of the existence of a representation of the application system that is stored within an object repository, and that contains the necessary information about the application system. We also discuss metrics for software reuse measurement, including reuse leverage, reuse value, and reuse classification that are motivated by managerial requirements and the efforts, within industry and the IEEE, to standardize measurement. The functionality and the analytical capabilities of state-of-the-art automated software metrics analyzers are illustrated in the context of an investment banking industry application that is similar to systems deployed at the New York City-based investment bank where these tools were developed and tested.

[40] Banker, R. D., R. J. Kauffman, et al., 'Repository evaluation of software reuse', IEEE Trans. on Software Eng., 19(4), pp379-389, 1993.

Keywords: C++, Des, Emp, Ind, Reuse

Abstract: An empirical study of reuse based around CASE development tools and using object-based measures of reuse (similar to those used in MELO95). The evaluation is intended to address such questions as: what kind of objects are most likely to be reused? and Under what conditions is reuse most likely to occur? From the conclusion: "We asked whether expert programmers were also better at reuse, and found that the highest levels of reuse were achieved by the programmers with the highest outputs of objects."

[41] Bansiya, J. and C. Davis, 'Automated metrics and object-oriented development', Dr. Dobbs Journal, (December), pp42-48, 1997.

Keywords: Tool

Abstract: Tools for object-oriented metrics are essential in real-world software development. For metrics to be actively used, however, they need to be automated, easy to use, and flexible enough to meet different requirements and goals. To this end, we have developed Quality Metrics for Object-Oriented Development (QMOOD++), an automated tool that supports a suite of over 30 object-oriented metrics. In addition to making it easy to collect metrics data, QMOOD++ has a repository in which the metric data of analyzed projects can be stored and retrieved later for comparisons. QMOOD++ is a comprehensive, multiuser, multithreaded, integrated Windows 95/NT-based tool. Typically, object-oriented software development is iterative, with overlapping phases in the development process. While the basic set of objects, operations, attributes, and relationships are identified in the analysis phase, the details of a class's methods, parameters, data declarations, relationships, and algorithms are resolved during design. The results are hierarchies of well-defined classes that represent a blueprint for implementation.

[42] Bansiya, J. and C. Davis, An object-oriented design quality assessment model. , University of Alabama, 1997.

Keywords: qual

[43] Bansiya, J., L. Etzkorn, et al., 'A class cohesion metric for object oriented designs', Journal of object-oriented programming, 11(8), pp47-52, 1999.

Keywords: Prod

Abstract: Cohesion is a measure of relatedness or consistency in functionality of a software component. It is a highly desirable design characteristic because it measures separation of responsibilities, independence of components, and control of complexity. Cohesion has a significant effect on a design's understandability, effectiveness and adaptability. An early evaluation of design components for cohesion can significantly improve the quality of a design, by helping to identify and redesign components that have scattered functionality or inconsistencies, and that are complex. We present a new metric to evaluate cohesion among methods of a class early in the analysis and design phase. The metric evaluates the consistency (focus) of methods in a class interface using the parameter types of the methods. This metric can be applied to class declarations that only contain method prototypes (method name and parameter types). The effectiveness of the metric is validated and demonstrated by correlating its results with existing measures of cohesion such as the Lack of Cohesion Among Methods Metric (LCOM) proposed by Chidamber and Kemerer (1991) and later interpreted by Li and Henry (1993), and which can be applied only after the implementation of methods of a class. The metric is also correlated with the cohesiveness evaluation of classes done by experts.

[44] Barnard, J., 'A New Reusability Metric for Object-Oriented Software', Software Quality Journal, 7(1), 1998.

Keywords: Reuse

Abstract: Software reuse is big business. Managers of software houses know that reuse can bring financial rewards to their company, so long as effective reuse procedures are in place. Many companies are now starting their own reuse libraries. However, how can they decide what constitutes a reusable component? How can they measure the potential reusability of a component? What guidelines can developers take to ensure they are developing reusable software? Through surveys and experiments, this paper identifies the factors relating to the reusability of code and presents a reusability metric for object-oriented software, suggesting that this could be used by software houses in their reuse programmes.

[45] Barnes, M. G. and B. R. Swim, 'Inheriting software metrics', Journal of Object-Oriented Programming, (November-December), pp27-34, 1993.

Keywords: Des, Qual

Abstract: Software engineering must continue to automate the measurement and analysis of software quality and incorporate the reuse of existing software components to produce quality software. The authors present a conceptual extension to the OOP paradigm supporting the development of high-quality production-grade software. A quality object-oriented language (QOOL) extends the class concept to software metrics, assessing how well software is written, performs, and satisfies its design goals. In addition, they describe how QOOL environments could reduce the burden of quality assurance and increase software reuse. A prototype (ActQOOL) is presented.

Notes: G. Michael Barnes is at renzo@secs.csun.edu, Bradley Swim is at bswim.acm.org.

[46] Basili, V. R., L. C. Briand, et al., 'A validation of object-oriented design metrics as quality indicators', IEEE Transactions on Software Engineering, 22(10), pp751-761, 1996.

Keywords: Emp, Des, Prod

Abstract: This paper presents the results of a study in which we empirically investigated the suite of object-oriented (OO) design metrics introduced in (Chidamber and Kemerer, 1994). More specifically, our goal is to

assess these metrics as predictors of fault-prone classes and, therefore, determine whether they can be used as early quality indicators. This study is complementary to the work described in (Li and Henry, 1993) where the same suite of metrics had been used to assess frequencies of maintenance changes to classes. To perform our validation accurately, we collected data on the development of eight medium-sized information management systems based on identical requirements. All eight projects were developed using a sequential life cycle model, a well-known OO analysis/design method and the C++ programming language. Based on empirical and quantitative analysis, the advantages and drawbacks of these OO metrics are discussed. Several of Chidamber and Kemerer's OO metrics appear to be useful to predict class fault-proneness during the early phases of the life-cycle. Also, on our data set, they are better predictors than "traditional" code metrics, which can only be collected at a later phase of the software development processes.

[47] Bellizona, R., M. G. Fugini, et al., 'Reusing specifications in OO applications', IEEE Software, 12(March), 1995.

Keywords: Des, Reuse

Abstract: Martin West provided me with the following description: "Discusses the work of the ESPRIT ITHACA Project, which has produced a model and environment for reusing specifications. Centralised around a tool called Recast". Roberto Bellizona, Maria Grazia Fugini and Barbara Pernici are at Datamont Feruzzi Group Spa, Italy. The "Integrated Toolkit for Highly Advanced Computer Applications" (ITHACA) projects (no. 1: project 2121 and no. 2: project 2705) were run by Siemens-Nixdorf (contact Anna-Kristin Pröfock, Gustav-Meyer Allee 1, D-1000 BERLIN 65, Tel: +49 30 46071413, Fax: +49 30 46071485)".

[48] Benford, S., E. Burke, et al., Integrating software quality assurance into the teaching of programming, in Software Quality Assurance and Measurement: a Worldwide Perspective, N. E. Fenton, R. W. Whitty and Y. Lizuke, Editors, International Thomson Computer Press.: London, UK, 1995.

Keywords: C++, Qual

Abstract: A short overview of the Ceilidh (pron. Cayley) system. From the Ceilidh web page: "Ceilidh is an on-line coursework administration and auto marking facility designed to help both students and staff with programming courses. It helps students by informing them of the coursework required of them, and by offering them a helpful environment in which they can develop and submit their work on the computer. This avoids having to print solutions and hand them in; no paperwork is involved. It also marks programs directly, and informs both the student and teacher of the mark awarded. The marking uses a comprehensive variety of static and dynamic metrics to assess the quality of submitted programs. Ceilidh also provides students with on line access to notes, examples and solutions. The submission process is under the control of the teacher who can specify, for example, the degree of marking detail which the student receives, and the date after which submission will no longer be accepted." It currently supports C and C++ and includes the Chidamber and Kemerer metrics [Chidamber, 1991] (I think). Web page address is: http://www.crg.cs.nott.ac.uk/ceilidh or contact ltr@cs.nott.ac.uk. Ceilidh is freely available to academic institutions under a licensing agreement.

[49] Benlarbi, S. and W. Melo, Measuring Polymorphism and Common Interconnections in OO Software Systems. Technical Report No. CRIM-97/11-84, Centre de Recherche Informatique de Montreal, 1997.

Keywords: Prod

[50] Berard, E. V., Essays on object-oriented software engineering. Prentice Hall: 1993.

Keywords: Rev, Des

Abstract: From the entry in the OO Bibliography (see 'General' URL in section 1 of this list): "includes coverage of OO domain and requirements analysis" and from its citation in the OO FAQ metrics entry: "contains an elaborate bibliography and section on OO metrics".

[51] Berard, E. V., 1996. Metrics for object-oriented software engineering [online], Available from: http://www.toa.com/pub/html/moose.html[23/07/96].

[52] Berg, W., M. Cline, et al., 'Lessons learned from the OS/400 object oriented project', Commun. ACM, 38(10), pp54-64, 1995.

Keywords: C++, Ind, Man, Emp

Abstract: Good real-life experience report with useful detail on use of lines of code as a project management metric. Also addresses the success of moving to OO (80% of staff learned to design and implement classes and use inheritence; 15% reached a "respectable journeyman level"; 5% became top performers).

Notes: William Berg is at bilber@vnet.ibm.com, Marshall Cline is at cline@parashift.com, Mike Girou is at girou@parashift.com.

[53] Bertolino, A., R. Mirandola, et al. 'A case study in branch testing automation', in Proc. 3rd International Conference on Achieving Quality in Software. Chapman and Hall, London, 1996.

Keywords: C++, Emp, Ind, Prod, Test

Abstract: Describes a study carried out at Ericsson Telecomunicazioni R&D on "one of the biggest projects developed in Europe using Object Oriented Technology": part of a new generation Transmission Network. The aim was to predict the effort required for unit testing (to 80% branch coverage) using a new metric developed by Bertolino and MarrŽ. This appeared to outperform McCabe.

Notes: Antonia Bertolino is at bertolino@iei.pi.cnr.it, web: http://rep1.iei.cnr.it/People/bertolino.

[54] Bezant, SwisRAD Metrics and the Repository. , Bezant Object Technology, 1995.

Keywords: Size

Abstract: Baseline document describing the metrics to be collected by the Swiss Bank metrics club organized by Ian Graham in association with Bezant Limited. Contact is Mark Lewis, 100073.1340@compuserve.com.*/

Notes: Available from Bezant Limited, 6 St Mary's Street Wallingford, Oxfordshire OX10 0EL, UK.

[55] Bieman, J. M., Deriving measures of software reuse in object-oriented systems. Technical Report No. CS-91-112, Department of Computer Science, Colorado State University, 1991.

Keywords: Des, Reuse

Notes: Earlier version of [Bieman, 1992]

[56] Bieman, J. M., Deriving measures of software reuse in object oriented systems, in Formal Aspects of Measurement, T. Denvir, R. Herman and R. Whitty, Editors, Springer-Verlag: London, 1992.

Keywords: Des, Reuse

Abstract: Tackles the problem of measuring reuse in OO systems which support 'leveraged' reuse through inheritance. Measurements are described for 3 perspectives: the server, the client and the system.

Notes: Jim Bieman is at Colorado State University, University Services Centre, Fort Collins, Colorado 80523, USA Main tel: +303 491 7096 Main fax: +303 491 6639 E-mail: Bieman@CS.Colostate.Edu.

[57] Bieman, J. M., Metric development for object-oriented software, in Software Measurement: Understanding Software Engineering, A. Melton, Editor, Chapman and Hall: Kansas City, Missouri., 1995.

Keywords: Des

Abstract: The book is the proceedings of a software metrics workshop help in conjunction with the 1992 ACM Computer Science Conference.

[58] Bieman, J. M. and B. K. Kang. 'Cohesion and reuse in an object oriented system', in Proc. Proc. ACM Software Reusability Symp. (SRS'94),. 1995.

Keywords: C++, Des, Emp, Ind, Prod, Reuse

Abstract: Software engineers follow many structural rules of thumb, for example "good designs should consist of modules with high cohesion and low coupling''. Such design practices have not been validated empirically, in part, because automatable measures of attributes such as cohesion have not been available and the relevant studies have not been conducted. We define and apply two new measures of object oriented class cohesion to a reasonably large C++ system. We find that most of the classes are quite cohesive, but that the classes that are reused more frequently via inheritance exhibit clearly lower cohesion. Our results demonstrate that developers can use cohesion measurement to improve the reusability of the classes that they design.

[59] Bieman, J. M. and S. Karunanithi, 'Measurement of language supported reuse in object oriented and object based software', J. Systems and Software, 30(3), pp271-293, 1995.

Keywords: Des, Reuse

Abstract: A major benefit of object-oriented software development is the support for reuse provided by object-oriented and object-based languages. Yet, measures and measurement tools that quantify such language-supported reuse have been lacking. Comprehensive reuse measures, particularly for reuse with modifications, are necessary to evaluate the status of reuse in an organization and to monitor improvements. We develop a set of measurable reuse attributes appropriate to object-oriented and object-based systems and a suite of measures that quantify these attributes. One of our major objectives is to measure reuse in software

written in the object-based language Ada. A set of suitable primitive reuse measures are expressed in Ada Reuse Tables. These tables support the flexible use of primitive measures in programs with nested packages and subprograms, and Ada generic packages. We designed and implemented a prototype Ada Reuse Measurement Analyzer (ARMA) to generate measurement values from Ada programs. ARMA produces a reuse data representation and a corresponding forest representation of an Ada system that contain the information necessary to produce the primitive measures. Developers can use the representations to produce customized reports to satisfy a wide range of measurement goals. We use ARMA to measure primitive reuse attributes for a set of industrial Ada software. We also show that ARMA can be used to generate a set of component access and package visibility measures.

[60] Bieman, J. M. and L. M. Ott, 'Measuring functional cohesion', IEEE Transactions on Software Engineering, 20(8), pp644-657, 1994.

Keywords: Des, Prod, Theory

Notes: Looks a bit speculative as no empirical data to support the utility of the metric.

[61] Bieman, J. M. and J. X. Zhao. 'Reuse through inheritance: a quantitative study of C++ software', in Proc. Proc. ACM Software Reusability Symp. (SSR'95). 1995.

Keywords: C++, Des, Emp, Ind

Abstract: According to proponents of object oriented programming, inheritance is an excellent way to organize abstraction and a superb tool for reuse. Yet, few quantitative studies of the actual use of inheritance have been conducted. Quantitative studies are necessary to evaluate the actual usefulness of structures such as inheritance. We characterize the use of inheritance in 20 existing C++ software systems containing 2,665 classes. We measure the class depth in the inheritance hierarchies, and the number of child and parent classes in the collected software. We find that inheritance is used far less frequently than expected".

[62] Bilow, S., 'Software entropy and the need for object-oriented software metrics', JOOP, 5(8), pp6, 1993.

Keywords: Prod

Abstract: The proper questions we must ask ourselves are:(1) How do I know if my software will be simple, testable, and maintainable, and(2) How can I determine the life cycle viability of my potential designs at the earliest possible stage so that I can make rational decisions at every phase of development?

None of traditional software measurement techniques, whether token, control flow, data flow, application, or interconnection based, are able to assess the reusability, development speed, or dynamic complexity of an object-oriented system. In fact, many existing metrics are extremely misleading in the context of object-oriented software. For example, we rarely see high cyclomatic numbers, numerous lines of code, or large quantities of operators in Smalltalk methods. This does not indicate that Smalltalk programs are automatically 'better' than C programs. It only indicates that Smalltalk utilizes a paradigm that distributes functionality into smaller units. Object-oriented demands its own metrics; tailored to the patterns that exist within that paradigm. In other words, we need object-oriented metrics!

Neither object-oriented nor structured software development embodies a method for assessing complexity prior to coding.

There is an exceedingly urgent need for viable techniques for quantifying state models, information models, class structures, multiple inheritance, associations, code quality, class responsibility domains, coupling and cohesion, and many other elements of our software.

[63] Bilow, S. C. 'Applying graph theoretical analysis to object-oriented system models', in Proc. OOPSLA'92 Workshop: Metrics for Object-Oriented Software Development. Vancouver, Canada: 1992.

Keywords: Theory, Prod

Notes: See Roberts' report on this workshop [Roberts, 1992].

[64] Bilow, S. C. 'Borrowing from McCabe: what object-oriented methodologists can learn from cyclomatic complexity', in Proc. OOPSLA '92 Workshop 'Metrics for Object-Oriented Software Development'. 1992.

Keywords: Prod

Notes: See Roberts' report on this workshop [Roberts, 1992].

[65] Bilow, S. C. and B. Henderson-Sellers, 'Report on the Workshop on Pragmatic and Theoretical Directions in Object-Oriented Software Metrics , October 23, 1994', Q Methods Report, Committee on Quantitative Methods, Technical Council on Software Engineering, (No. 7, Winter 1995), 1995.

Keywords: Size, Rev

Abstract: A report on the OOPSLA '94 metrics workshop. Seven papers addressed issues including cost estimation and use of function points, and fuzzy logic. "... the whole group attempted to reach a consensus on the state of metrics by building a list of best and worst case metrics for a set of attributes."

Notes: This list of metrics is available from Steve Bilow (address see [Bilow, 1993]). The Q Methods Report is from Linda Ott at Michigan Technological University, linda@cs.mtu.edu. The papers presented were mainly short position papers, not meant for publication. [Brito e Abreu, 1994, "Object-oriented software engineering: measuring and controlling the development process" ] is an expanded version of one of them. See also [Bilow, 1993] for www source

[66] Bilow, S. C. and D. Lea. 'Workshop Report: Processes and Metrics for OO Software Development', in Proc. OOPSLA '93 Workshop Report: Processes and Metrics for OO Software Development. 1993.

Keywords: Rev

Notes: I haven't seen this or the workshop papers published anywhere, although the main OOPSAL'93 Proceedings were published as (Paepcke, A., ed.) SIGPLAN Notices 28 (10). Patrizia Sgubbi has told me that the OOPSLA'93 and OOPSLA'94 metrics workshop papers are on www at http://aaimzb.mathematik.uni-mainz.de/Personal/Mitarbeiter/OOPSLAMetrics.html. Steve Bilow is at steveb@orca.wv.tek.com. Doug Lea is at dl@g.oswego.edu.

[67] Binder, R. V., 'Design for testability in object-oriented systems', Communications of the ACM, 37(9),

pp87-101, 1994.

Keywords: Des, Man, Test

Abstract: Provides tables of metrics for testability and encapsulation, inheritance, polymorphism and complexity (compare with McCabe et al 1994). There is a very detailed discussion of the testing process in which these metrics may be deployed, addressing such issues as standards, tools, design for testability and process capability.

Notes: Binder is at RBSC Inc., email: rbinder@rbsc.com.

[68] Binkley, A. B. and R. Schach. 'Impediments to the effective use of metrics within the object-oriented paradigm', in Proc. OOPSLA'96 - workshop: OO product metrics. 1996.

Keywords: Man

[69] Binkley, A. B. and S. R. Schach, 'A Comparison of Sixteen Quality Metrics for Object-Oriented Design', Information Processing Letters, 58(6), pp271-275, 1996.

Keywords: Qual, Prod, Des

Abstract: A number of different object-oriented metrics for evaluating the quality of an object-oriented design have been put forward. These metrics are computed from a widely ranging variety of different design parameters, including the height of the inheritance tree, fan-in, fan-out, cohesion, and coupling. We examine sixteen different metrics for object-oriented design and measure the extent to which their predictions agree with those of a panel of design experts. We use the term design quality to denote the extent to which a design that meets its specifications is predicted to reduce implementation and maintenance effort. A more precise term is psychological design complexity because, strictly speaking, quality is a measure of adherence to specifications. However, the informal use of the term "design quality" to denote the goodness of a design goes back at least to 1978 and continues to this day.

[70] Blake, B. A. and P. Jalics, 'An assessment of object-oriented methods and C++', J. Object-oriented Programming, 9(1), pp42-48, 1996.

Keywords: C++, Emp, Reuse

Abstract: Discussion of obstacles to gaining the supposed benefits of OO. From the conclusion: "...reusing library objects may actually require more time than copying code from previous programs or even developing code from scratch. The experiments designed to prove code reuse enhances programmer productivity provided no such evidence.

Notes: Ben Blake is at bab@cis.csuohio.edu, Paul Jalics is at jalics@cis.csuohio.edu.

[71] Boehm, B. W., B. K. Clark, et al., An overview of the COCOMO 2.0 software cost model. Technical Report , University of Southern California, 1995.

Keywords: Size

Abstract: Includes cost estimation for object-oriented development via the estimation of software size using the metrics of [Chidamber, 1991].

Notes: Home page, including various papers, user manual and short bibliography: http://sunset.usc.edu/COCOMO2.0/Cocomo.html.

[72] Booch, G., 'Measures of goodness', Report on Object Analysis and Design (ROAD), 1(2), pp8-10, 14, 1994.

Keywords: Ind, Des, Maint

Abstract: Annotation from C. Gibbon.

Booch imparts some of his extensive experience in the field when faced with measures of goodness (metrics) for software products and processes. He divides these "measures of goodness" into two factions: strategic and the tactical. The former concerns itself with architecture, employing techniques to unearth corrosive and system-wide flaws in software. Whilst the latter focuses upon those issues that have relatively local implications. He cites inheritance lattices and choice of class protocols as examples. Booch concentrates on software development's macro process and identifies "measures of goodness" for its various phases (conceptualisation, analysis, design, evolution and maintenance).

[73] Booch, G., Object-Oriented Analysis and Design with Applications. 2nd Edition ed. Benjamin Cummins Publishing Co.: Redwood City, LA, 1994.

Keywords: Qual, Des, Man, Rev

Abstract: Section 7.5 of Grady Booch's new edition is on quality assurance and metrics. He also has a very extensive bibliography on general issues in software engineering.

Notes: A review of this book by T.H.Tse is given in ACM Computing Reviews, March 1995, rev. no. 9503-0135.

[74] Booch, G., 'Qualitaetsmasse', OBJEKTspektrum, (September-October), pp53-56, 1994.

Keywords: Qual

Abstract: Quality measures paper. OBJEKTspektrum is a German journal.

[75] Booch, G. and M. Vilot, 'Simplifying the Booch components', C++ Report, 5(5), pp41-52, 1993.

Keywords: C++, Des

Abstract: What factors contributed to making the C++ Booch Components into 'the incredible shrinking library?' This article examines, how the concepts of OOD and the features of C++ helped to organize and simplify the library. First, it provides a brief overview of the library showing its contents and organization. Then, it explores how inheritance and parameterization helped to streamline and simplify the library. The article concludes with a summary of how much each design change contributed to the overall size reduction. (14 Refs.).

[76] Bradley, L. 'Evaluating complex properties of object-oriented design and code', in Proc. International Software Quality Conference. Dayton, Ohio: 1991.

Keywords: Des

[77] Briand, L., C. Bunse, et al., An experimental comparison of the maintainability of object-oriented and structured design documents. No. ISERN-96-13, 1997.

Keywords: Emp, Man

Abstract: This paper presents a controlled experiment focusing on the following issues (i) are OO design documents easier to understand and modify than structured design documents?, (ii) Do they comply with quality design principles such as the ones provided by Coad and Yourdon? , and (iii) what is the impact of such design principles on the understandability and modifiability of design documents?Results strongly suggest that such design principles have a beneficial effect on the maintainability of OO design documents. However, there is no strong evidence regarding the alleged higher maintainability of OO design documents over structured design doments. Furthermore, results suggest that OO design documents are more sensitive to poor design practices.

[78] Briand, L. C., C. Bunse, et al. 'An experimental comparison of the maintainability of object-oriented and structured design documents', in Proc. Intl. Conf. on Software Maintenance. IEEE Computer Society Press, 1997.

Keywords: Emp, Maint

Notes: Reports on a student experiment to assess the impact of OO versus structured design and "good" versus "bad" design. (It is not, however, clear that this is a 2x2 factorial design since design quality might have different meanings depending upon the design paradigm. ) The authors report that "good" OO designs were easier to understand and modify than "bad" designs. Also "bad" structured design was easier to understand than "bad" OO design. No significant differences were detected between "good" OO and "good" structured design or between "good" and "bad" structured design. The authors conclude that OO designs may be more vulnerable to poor quality than traditional methods.

[79] Briand, L. C., J. Daly, et al. 'A comprehensive empirical validation of design measures for object-oriented systems', in Proc. 5th Intl. Metrics Symp. Bethesda, MD: IEEE Computer Society, 1998.

Keywords: Emp, Des, Prod

Abstract: This paper aims at empirically exploring the relationships between existing object-oriented coupling, cohesion, and inheritance measures and the probability of fault detection in system classes during testing. The underlying goal of such a study is to better understand the relationship between existing design measurement in OO systems and the quality of the software developed. Results show that many of the measures capture similar dimensions in the data set, thus reflecting the fact that many of them are based on similar principles and hypotheses. Besides the size of classes, the frequency of method invocations and the depth of inheritance hierarchies seem to be the main driving factors of fault-proneness.

[80] Briand, L. C., J. Daly, et al. 'Predicting fault-prone classes with design measures in object-oriented systems', in Proc. Proceedings Ninth International Symposium on Software Reliability Engineering. IEEE Comput. Soc, 1998.

Keywords: Emp, Prod, Qual

Abstract: The paper aims at empirically exploring the relationships between existing object oriented coupling, cohesion, and inheritance measures and the probability of fault detection in system classes during testing. The underlying goal of such a study is to better understand the relationship between existing product measurement in OO systems and the quality of the software developed. It is shown that by using a subset of existing measures, accurate models can be built to predict in which classes most of the faults are likely to lie in. By inspecting 48% of the classes, it is possible to find 95% of the faults. Besides the size of classes, the frequency of method invocations and the depth of inheritance hierarchies seem to be the main driving factors of fault proneness.

[81] Briand, L. C., J. Daly, et al. 'A unified framework for cohesion measurement in object-oriented systems', in Proc. 4th Intl. Software Metrics Symp. Alberquerque: IEEE Computer Society Press, 1997.

Keywords: Prod, Des

Abstract: The increasing importance being placed on software measurement has led to an increased amount of research in developing new software measures. Given the importance of object oriented development techniques, one specific area where this has occurred is cohesion measurement in object oriented systems. However despite an interesting body of work, there is little understanding of the motivations and empirical hypotheses behind many of these new measures. It is often difficult to determine how such measures relate to one another and for which application they can be used. As a consequence, it is very difficult for practitioners and researchers to obtain a clear picture of the state of the art in order to select or define cohesion measures for object oriented systems. To help remedy this situation a unified framework, based on the issues discovered in a review of object oriented cohesion measures, is presented. The unified framework contributes to an increased understanding of the state of the art as it is a mechanism for: (i) comparing measures and their potential use, (ii) integrating existing measures which examine the same concepts in different ways, and (iii) facilitating more rigorous decision making regarding the definition of new measures and the selection of existing measures for a specific goal of measurement.

[82] Briand, L. C., J. W. Daly, et al., A comprehensive empirical validation of project measures for object-oriented systems. , Fraunhofer Institute forExperimental Software Engineering, Kaiserslautern, 1998.

Keywords: Emp, Des, Prod

Abstract: This paper aims at empirically exploring the relationships between existing object-oriented coupling, cohesion, and inheritance measures and the probability of fault detection in system classes during testing. The underlying goal of such a study is to better understand the relationship between existing product measurement in OO systems and the quality of the software developed. Results show that many of the measures capture similar dimensions in the dataset, thus reflecting the fact that many of them are based on similar principles and hypotheses. However, it is shown that by using a subset of measures, accurate models can be built to predict in which classes most of the faults are likely to lie in. By inspecting an amount of code comparable to the one contained in faulty classes, it is possible to find between 90% and 95% of the faults, depending on the type of model validation considered. Besides the size of classes, the frequency of method invocation and the depth of inheritance hierarchies seem to be the main driving factors of fault proneness.

Notes: available at http://www.iese.fhg.de/ISERN/pub/isern_biblio_tech.html

[83] Briand, L. C., J. W. Daly, et al., A unified framework for cohesion measurement in object-oriented systems. No. ISERN-97-05, Fraunhofer Institute (IESE), 1997.

Keywords: Prod, Des

Notes: The same treatment given to coupling measurement in the above paper is given here to cohesion measurement: (i) a standardized terminology and formalism for expressing measures is provided, (ii) a review of the existing approaches to cohesion measurement in object-oriented systems takes place, (iii) a unified framework for cohesion measurement, based on the issues discovered in the review, is provided and all existing cohesion measures are then classified according to this framework, (iv) a review of the empirical validation work concerning existing cohesion measures is provided.

The paper is available on-line at:http://www.iese.fhg.de/ISERN/pub/isern.biblio.html#techno.

[84] Briand, L. C., J. W. Daly, et al., 'A unified framework for cohesion measurement in object-oriented systems', Empirical-Software-Engineering, 3(1), pp65-117, 1998.

Keywords: Prod, Rev

Abstract: One area where there is an increased amount of research on developing new software measures is cohesion measurement in object-oriented (OO) systems. It is often difficult to determine how such measures relate to one another and for which application they can be used, so it is difficult to obtain a clear picture of the state-of-the-art in order to select or define cohesion measures for OO systems. This situation is addressed and clarified through several different activities. (1) A standardized terminology and formalism for expressing measures is provided. (2) To provide a structured synthesis, a review of the existing approaches to measure cohesion in OO systems takes place. (3) A unified framework, based on the issues discovered in the review, is provided and all existing measures are then classified according to this framework. (4) A review of the empirical validation work concerning existing cohesion measures is provided. This paper contributes to an increased understanding of the state-of-the-art: a mechanism is provided for comparing measures and their potential use, integrating existing measures which examine the same concepts in different ways, and facilitating more rigorous decision-making regarding the definition of new measures and the selection of existing measures for a specific goal of measurement. In addition, our review highlights several important issues: (i) many measures are not defined in a fully operational form, (ii) relatively few of them are based on explicit empirical models as recommended by measurement theory, and (iii) an even smaller number of measures have been empirically validated.

[85] Briand, L. C., J. W. Daly, et al., A Unified Framework for Coupling Measurement in Object-Oriented Systems. Technical Report No. ISERN-96-14,, Fraunhofer Institute for Experimental Software Engineering, 1996.

Keywords: Des, Prod

Notes: The unified framework for coupling measurement is a mechanism for comparing coupling measures and their potential use, integrating existing coupling measures which examine the same concepts in different ways, and facilitating more rigorous decision making regarding the definition of new coupling measures and the selection of existing coupling measures for a specific goal of measurement. The unified framework is the

result of a structured synthesis, based on a review of existing frameworks and measures for coupling measurement in object-oriented systems. In this paper, first a standardized terminology and formalism for expressing measures is provided, which ensures that all measures using it are expressed in a fully consistent and operational manner. Second, a review of the existing frameworks and measures for coupling measurement in object-oriented systems takes place. Third, the unified framework, based on the issues discovered in the review, is provided and all existing measures are then classified according to this framework. Finally, a review of the empirical validation work concerning existing coupling measures is provided.

The paper is available on-line at:http://www.iese.fhg.de/ISERN/pub/isern.biblio.html#techno.

[86] Briand, L. C., J. W. Daly, et al., 'A unified framework for coupling measurement in object-oriented systems', IEEE-Transactions-on-Software-Engineering, 25(1), pp91-121, 1999.

Keywords: Prod, Rev

Abstract: The increasing importance being placed on software measurement has led to an increased amount of research developing new software measures. Given the importance of object-oriented development techniques, one specific area where this has occurred is coupling measurement in object-oriented systems. However, despite a very interesting and rich body of work, there is little understanding of the motivation and empirical hypotheses behind many of these new measures. It is often difficult to determine how such measures relate to one another and for which application they can be used. As a consequence, it is very difficult for practitioners and researchers to obtain a clear picture of the state of the art in order to select or define measures for object-oriented systems. This situation is addressed and clarified through several different activities. First, a standardized terminology and formalism for expressing measures is provided which ensures that all measures using it are expressed in a fully consistent and operational manner. Second, to provide a structured synthesis, a review of the existing frameworks and measures for coupling measurement in object-oriented systems takes place. Third, a unified framework, based on the issues discovered in the review, is provided and all existing measures are then classified according to this framework. This paper contributes to an increased understanding of the state-of-the-art.

[87] Briand, L. C., P. Devanbu, et al. 'An investigation into coupling measures for C++', in Proc. 19th Intl. Conf. on Softw. Eng. Boston, MA: IEEE Computer Society Press, 1997.

Keywords: C++, Des, Emp, Prod

Abstract: The paper proposes a comprehensive suite of measures to quantify the level of class coupling during the design of object oriented systems. This suite takes into account the different OO design mechanisms provided by the C++ language (e.g., friendship between classes, specialization, and aggregation) but it can be tailored to other OO languages. The different measures in our suite thus reflect different hypotheses about the different mechanisms of coupling in OO systems. Based on actual project defect data, the hypotheses underlying our coupling measures are empirically validated by analyzing their relationship with the probability of fault detection across classes. The results demonstrate that some of these coupling measures may be useful early quality indicators of the design of OO systems. These measures are conceptually different from the OO design measures defined by S.R. Chidamber and C.F. Kemerer (1994); in addition, our data suggests that they are complementary quality indicators.

Notes: A related technical report is available on-line at:http://www.iese.fhg.de/ISERN/pub/isern.biblio.html#techno.

[88] Briand, L. C., K. El Emam, et al., Theoretical and empirical validation of software product measures. No. ISERN-95-03, International Software Engineering Research Network, 1995.

Keywords: Theory, Emp, Prod

Abstract: This paper outlines Briand's approach to metric validation. He splits validation into theoretical and empirical. Theoretical validation is carried out to ensure that a measure is actually measuring what it purports to measure. The theoretical validation in this paper concentrates wholly on measurement theory. This should apply to both internal measures and the external measures to which they relate. Empirical validation is concerned with providing evidence that the measure is useful, i.e., if it is related to a measure of some external attribute. The paper considers the design of experiments to collect data and how the type of data affects the type of statistical technique used to analyse them.Generally the paper is useful , insightful and pragmatic. A good basis for deciding upon a validation strategy.

[89] Briand, L. C., K. El Emam, et al., 'On the application of measurement theory in software engineering', Empirical Software Engineering: an international journal, 1(1), 1996.

Keywords: Theory

Abstract: This paper presents a compelling counter argument to the current trend toward the strict application of measurement theory in software engineering. The authors quote work done in the social sciences and statistics to support this position. The main points covered are :-1, There is little basis for mandating that software complexity measures should be additive and that they should assume an extensive structure.2, It is not obvious that all non parametric statistics make use of only rank-order information in their calculation. Therefore, caution should be exercised even when strictly following the commonly found proscriptions on the use of statistical procedures.3, In software engineering, as in other disciplines, it is frequently difficult to know for certain the scale type of a measure. 4, The use of parametric statistics is more risky than the use of non parametric statistics in a field where measurement scales are not well understood. However, with care and after thorough reflection, such a risk may appear to be worth taking when one considers the following facts: i, Many common parametric techniques are robust to non-linear distortions of interval scales as long as they are not 'too extreme'. If this is the case, these statistics will have a tendency to be conservative and underestimate existing relationships and differences. ii, Parametric techniques are, in general, more powerful than non parametric statistics. An increased use of the less powerful non parametric statistics may lead to: a reduction in the empirical research because of the unfeasibility of the larger sample sizes required to attain reasonable power with non parametric statistics; and/or an increase in 'non-significant' findings which may cause many interesting relationships being overlooked.

They conclude that the software engineering community should not accept measurement theory prescriptions and proscriptions as though they were absolute (almost religious) and unquestionable. Pragmatism and common sense, combined with a reasonable dose of rigour, should always prevail.

[90] Briand, L. C., S. Morasca, et al. 'Assessing software maintainability at the end of high-level design', in Proc. IEEE Conference on Software Maintenance. Montreal, Quebec, Canada: 1993.

Keywords: Des, Emp

Abstract: Lionel Briand writes: "We did a substantial amount of work on the subject of metrics for abstract data types. Moreover, we validated them experimentally, which is not the case of most (if not all) the metrics in the literature. Only a part of this work is published since several papers are still under review. The second reference is more complete since it was completed recently. The experimental results are only provided in the second reference."

Notes: He also has these papers on the following ftp site: ftp://ftp.cs.umd.edu in pub/sel/papers. However, the postscript files are not perfect because they have been generated from MS-word files on Mac. Hardcopies can be sent. Lionel is now at briand@iese.fhg.de. Walcélio Melo is at wmelo@crim.ca.

[91] Briand, L. C., S. Morasca, et al., Defining and validating high-level design metrics. Technical Report No. CS-TR 3301, UMIACS-TR-94-75, University of Maryland, 1994.

Keywords: Des, Emp

[92] Briand, L. C., S. Morasoa, et al. 'Measuring and Assessing Maintainability at the End of High Level Design', in Proc. Conference on Software Maintenance. Montreal, Canada: IEEE, 1993.

Keywords: Maint, Des, Prod

Abstract: Software architecture appears to be one of the main factors affecting software maintainability. Therefore, in order to be able to predict and assess maintainability early in the development process we need to be able to measure the high-level design characteristics that affect the change process. To this end, we propose a measurement approach, which is based on Object-Oriented Design principles and is partially language independent. We define metrics for cohesion, coupling, and visibility in order to capture the difficulty of isolating, understanding, designing and validating changes.

[93] Bristol, S. R. 'Tools for object-oriented (OO) metircs collection', in Proc. OOPSLA'96 - workshop: OO product metrics. 1996.

Keywords: Tool, Prod

Notes: Position paper.

[94] Brooks, C. L. and C. G. Buell. 'A tool for automatically gathering object-oriented metrics', in Proc. Aerospace and electronics conference. 1994.

Keywords: Tool

Abstract: Measuring software and the software development process are essential for organizations attempting to improve their software processes. For organizations using the object-oriented development approach, traditional metrics and metric gathering tools meant for procedural and structured software development are typically not meaningful. Chidamber and Kemerer proposed a suite of metrics for object-oriented design based upon measurement theory and guided by the insights of experienced object-oriented software developers. This paper presents the implementation of a tool to gather a subset of these proposed metrics for

an object oriented software development project. Software metrics can be gathered at many levels of granularity; this tool provides measurements at two levels: class-level and system-level. Class-level metrics measure the complexity of individual classes contained in the system. These metrics can be very useful for predicting defect rates and estimating cost and schedule of future development projects. Examples of class-level metrics are depth of inheritance tree and class coupling. System-level metrics deal with a collection of classes that comprise an object-oriented system. Number of class clusters and number of class hierarchies are two examples of system-level metrics. The tool was written in C++ and currently only supports C++ software measurement. The authors plan to add the capability to measure software written in other object-oriented languages in the near future.

[95] Brooks, I. 'Object-oriented metrics collection and evaluation with a software process', in Proc. OOPSLA `93 Workshop on Processes and Metrics for Object Oriented Software Development. Washington DC: 1993.

Keywords: Des, Emp, Size, Ind, Man, Qual

Notes: Not necessarily available as a paper. However, see the Workshop Report: [Bilow, 1993]. The following is taken from that report: "Irene Brooks presented a paper based on practical experience at Texas Instruments. She explained how TI has found measures of size, defect density, and defect intensity to be very useful in the schedule management and defect control. She commented that some traditional metrics like McCabe complexity measure do not appear to be useful for O-O development. She also noted that it seems necessary to find adequate measures for polymorphism, inheritance, and the cohesion between class attributes. Her primary goals are repeatability of process, quality measurement, project management and configuration control techniques." Irene is at elise@tasmania.works.ti.com.

[96] Brownlow, L. S. 'Early Estimating in the Object-Oriented Analysis and Design Environment', in Proc. European Software Cost Modelling Conference. Ivrea, Italy: 1994.

Keywords: Size, Ind, Emp

[97] Bucci, G., F. Fioravanti, et al. 'Metrics and tool for system assessment', in Proc. Fourth IEEE International Conference on Engineering of Complex Computer Systems. IEEE Comput. Soc, 1998.

Keywords: Tool, Qual

Abstract: A wide increment of object-oriented diffusion has been registered. This is accompanied by the needs of metrics and tools for assessing class reusability, maintainability, complexity, etc. Metrics have to produce confident results and have to be continuously revalidated on the basis of the specific purpose of their adoption. Tools for system assessment must be capable of satisfying the needs of each company by supporting the definition of more specific metrics and by providing appropriate views of software characteristics. These views are useful to give the developers as well as the managers immediately understandable representations of the system status. In this paper a new approach is proposed for system assessment. This approach is based on the adoption of new and well-known metrics together with a set of histograms and profiles that give a clear characterization of the system under development. The semantics of these histograms has been validated against several projects. A brief overview of the tool, TAC++, developed for system assessment is also included.

[98] Burbeck, S. L., 'Real-Time Complexity Metrics for Smalltalk Methods', IBM Systems Journal, 35(2), pp204-226, 1996.

Keywords: Small, Prod

Abstract: This paper presents the rationale for ubiquitous and immediate metric feedback on the complexity of Smalltalk methods whenever they are viewed or changed. It also presents seven metrics for Smalltalk methods that can be quickly and easily determined from the code and are suitable for real-time feedback. For each of these metrics, there is a description, an explanation of how it is determined and why it is related to complexity, and suggestions for how to improve code that receives a poor rating for the metric.

[99] Buth, A., 'Softwaremetriken für objekt-orientierte programmiersprachen', Arbeitspapiere der GMD (545), (June), 1991.

Notes: Angelika Linden (was Buth) is now at General Electric Corporate Research and Development in Schenectady, New York, lindenan@thuban.crd.ge.com. Address for GMD is: Postfach 1240, Schloss Birlinghoven, D-5205 Sankt Augustin 1, Germany, tel: (0) 49 2241142 440, fax: (0) 49 2241 142 618.

[100] Byard, C., 'Software beans: class metrics and the mismeasure of software', Journal of Object-Oriented Programming, 7(5), pp32-34, 1994.

Keywords: Man, Theory

Abstract: Object-oriented software has created a new "level playing field" for the software industry. For software measurement, it's a whole new ball game. Where there are beans, there are bean counters. Object-oriented software provides some obvious beans for counting that are being seized by those wishing to measure object-oriented software. Herein lies a danger. The mismeasure of software that the computer industry has practiced for years is examined. It engenders poor engineering and poor business decisions for developing and procuring software. When scientists envision an attribute, they strive to find a way to measure the attribute objectively. Such measures are helpful in comparing similar items. The danger is when measures of one attribute are incorrectly interpreted to apply to others.

Notes: A call for scientific measurement invoking Stephen Jay Gould's example, in The Mismeasure of Man (Norton & Co., NY, 1981), of measuring brain power as the weight of lead shot required to fill a skull. "Business people and software development teams should place no more faith in class metrics for making critical software decisions than lead shot in skulls for evaluating the intelligence of people. Instead they must focus on the end-goals for software and the resources needed to achieve them."Cory Byard is at cory.byard@daytonoh.ncr.com.

[101] Caldiera, G., G. Antoniol, et al. 'Definition and experimental evaluation of function points for object-oriented systems', in Proc. 5th Intl. Metrics Symp. Bethesda, MD: IEEE Computer Society, 1998.

Keywords: Emp, Man, Size

Abstract: We present a method for estimating the size, and consequently effort and duration, of object oriented software development projects. Different estimates may be made in different phases of the development process, according to the available information. We define an adaptation of traditional function points, called Object Oriented Function Points, to enable the measurement of object oriented analysis and design specifications. Tools have been constructed to automate the counting method. The novel aspect of our method is its flexibility. An organisation can experiment with different counting policies, to find the most accurate predictors of size, effort, etc. in its environment. The method and preliminary results of its

application in an industrial environment are presented and discussed.

Notes: Describes an adaptation to traditional function points to predict size and effort for OO developments. A small pilot study of 8 systems reveals a strong correlation between the FPs and size.

[102] Campanai, M. and P. Nesi. 'Supporting object-oriented design with metrics', in Proc. Technology of Object-Oriented Languages and Systems, TOOLS 13. Prentice Hall, Hemel Hempstead, UK, 1994.

Keywords: Theory, Des, Qual

Abstract: A framework for the estimation of object-oriented system specifications by using a set of software metrics covering technical, cognitive and process-oriented views is presented. The parameters defined in this paper allow the evaluation of a prevision model to quantify expected efforts as a function of the life-cycle stages. The use of metrics for the estimation of reusability, modularity, maintainability and testability is analyzed. These metrics are integrated in a CASE tool named TOOMS, which has been defined by our research group for the specification of reactive systems. TOOMS is based on TROL, a dual object-oriented language with both descriptive and operational capabilities. TOOMS allows one to describe the system at different levels of structural abstractions, and at different levels of specification detail. The metrics proposed are able to produce estimations at each level of system specification, thus allowing incremental specification/metrication.

[103] Cant, S. N., B. Henderson-Sellers, et al., 'Application of cogitive complexity metrics to object-oriented programs', Journal of Object Oriented Programming, 8(4), pp52-63, 1994.

Keywords: C++, Des, Emp

Abstract: A general model of cognitive complexity is described, including the ways in which a software engineer uses chunking and tracing to understand program code. A case study of a C++ development is presented. The results suggest that perceived modification complexity is predicted well by effects, while perceived error isolation complexity is predicted by determinants.

Notes: Offers marginal empirical support using subjective complexity.

[104] Cant, S. N., D. R. Jeffery, et al., A conceptual model of cognitive complexity of elements of the programming process. B Centre for Information Technology Research Report No. 57, University of New South Wales, 1992.

Keywords: Des

Notes: Full description of the complexity model used in [Cant, 1994]. (q.v. for authors' locations).

[105] Cant, S. N., D. R. Jeffery, et al., 'A conceptual model of cognitive complexity of elements of the programming process', Information & Software Technology, 37(7), pp351-362, 1995.

Keywords: Prod, Theory

Notes: A different view of complexity based upon a cognitive model including chunking and slicing. Lots of proposals but no empirical evidence.

[106] Capper, N. P., R. J. Colgate, et al., 'The impact of object-oriented technology on software quality: three case histories', IBM Systems Journal, 33(1), pp131-157, 1994.

Keywords: Ind, Qual, Emp, Reuse

[107] Cartwright, M. and M. Shepperd. 'Building predictive models from object-oriented metrics', in Proc. 8th European Software Control and Metrics Conf. Berlin: 1997.

Keywords: Emp, Des, Prod

Notes: May 26-28

[108] Cartwright, M. and M. Shepperd, An Empirical Study of Object-Oriented Metrics. Technical Report No. TR 97/01, Dept. of Computing, Bournemouth University, UK, 1997.

Keywords: Des, Emp, Ind, Prod

Abstract: An empirical investigation of an industrial OO system, using readily available measures to construct locally applicable metrics to predict defects and size. An html version may be downloaded: http://xanadu.bournemouth.ac.uk/staff/mshepperd/OOmetrics.html

[109] Cartwright, M. and M. Shepperd, An Empirical View of Inheritance. No. TR98-02, Empirical Software Engineering Group, Bournemouth University, 1998.

Keywords: Emp, Man

Notes: An earlier version of the IST journal paper.This report may be downloaded from : http://dec.bournemouth.ac.uk/ESERG/Technical_Reports/TR98-02/TR98-02.ps

[110] Cartwright, M. and M. Shepperd, 'An Empirical View of Inheritance', Information & Software Technology, 40(14), pp795-799, 1998.

Keywords: Emp, Man

Abstract: For some years software engineering researchers have been advocating object-oriented (OO) methods as apowerful approach to overcome many of the difficulties associated with software development. A central concept within OO is the use of the inheritance mechanism, primarily with a view to enhancing opportunities for reuse. This paper reviews the evidence we have concerning the use and the impact of inheritance within OO software. A striking result is how little the mechanism is used in practice. The paper then goes onto describe an experiment conducted at Bournemouth University to investigate the impact of class inheritance upon the maintenance of C++ software. The experiment was a replication of an experiment previously conducted at the University of Strathclyde. Two versions of a bibliographic database program were used. One used inheritance and the other a flat structure. It was found that subjects took significantly longer to make the same change on the program with inheritance, however, their changes were more compact. Interestingly the

Strathclyde group found that the time to make changes for the inheritance version was reduced. We conclude that there is an urgent need for further empirical work to study the impact of the inheritance mechanism using more subjects and in an industrial setting.

[111] Chae, H. S. and Y. R. Kwon. 'A cohesion measure for classes in object-oriented systems', in Proc. Fifth International Software Metrics Symposium. IEEE Comput. Soc, Los Alamitos, CA, USA, 1998.

Keywords: Prod

Abstract: Classes are the fundamental concepts in the object-oriented paradigm. They are the basic units of object-oriented programs, and serve as the units of encapsulation, which promotes the modifiability and the reusability of them. In order to take full advantage of the desirable features provided by classes, such as data abstraction and encapsulation, classes should be designed to have good quality. Because object-oriented systems are developed by heavily reusing the existing classes, the classes of poor quality can be a serious obstacle to the development of systems. We define a new cohesion measure for assessing the quality of classes. Our approach is based on the observations on the salient natures of classes which have not been considered in the previous approaches. A Most Cohesive Component (MCC) is introduced as the most cohesive form of a class. We believe that the cohesion of a class depends on the connectivity of itself and its constituent components. We propose the connectivity factor to indicate the degree of the connectivity among the members of a class, and the structure factor to take into account the cohesiveness of its constituent components. Consequently, the cohesion of a class is defined as the product of the connectivity factor and the structure factor. This cohesion measure indicates how closely a class approaches MCC; the closely a class approaches MCC, the greater cohesion the class has.

[112] Chan, E., 'A metrics based intelligent tutoring system for object-oriented design', International Journal of Applied Software Technology, 3(4), pp253-272, 1997.

Keywords: Tool, Des

Abstract: While the importance of object-oriented design is widely recognized, many newcomers have found the learning curve quite steep. In this paper, a metrics based tutoring system is described. The key premise is that some typical flaws in object-oriented design can be identified using the appropriate object-oriented metrics. By providing suitable feedback based on the metrics and other design checking rules, the system can help automate the learning process and provide a friendly self-learning environment to the student.

[113] Chaudhri, A. B., 'An annotated bibliography of benchmarks for object databases', ACM SIGMOD Record, (March), 1995.

Keywords: Rev

Abstract: Contains many papers relating to Object DBMS benchmarking. Akmal Chaudhri is at akmal@cs.city.ac.uk.

[114] Chaumun, M. A., H. Kabaili, et al. 'A change impact model for changeability assessment in object-oriented software systems', in Proc. Third European Conference on Software Maintenance and Reengineering. IEEE Comput. Soc, Los Alamitos, CA, USA, 1999.

Keywords: C++, Maint, Theory

Abstract: Growing maintenance costs have become a major concern for developers and users of software systems. Changeability is an important aspect of maintainability, especially in environments where software changes are frequently required. In this work, the assumption that high-level design has an influence on maintainability is carried over to changeability and investigated for quality characteristics. The approach taken to assess the changeability of an object-oriented (OO) system is to compute the impact of changes made to classes of the system. A change impact model is defined at the conceptual level and mapped on the C++ language. In order to assess the practicality of the model on large industrial software systems, an experiment involving the impact of one change is carried out on a telecommunications system. The results suggest that the software can easily absorb this kind of change and that well chosen conventional OO design metrics can be used as indicators of changeability.

[115] Chen, D. J. and D. T. K. Chen, 'An experimental study of using reusable software design frameworks to achieve software reuse', Journal of Object-Oriented Programming, 7(2), pp56-67, 1994.

Keywords: C++, Des, Emp, Reuse

Abstract: Reuse of code has some limitations; a higher level of reuse is design reuse. Software designs can be reused across programming languages to implement similar systems in different ways. This article proposes an approach to constructing Reusable Software Design Frameworks (RSDFs). The design framework provides an implementation-independent specification part and a language-dependent implementation part to rapidly prototype the software system to be constructed. To understand the software productivity and quality of the proposed RSDF, we perform an experiment to compare the proposed approach with a traditional design approach in terms of several software metrics. The experimental results show that the proposed approach demonstrates better performance according to these software metrics.

Notes: Discusses what constitutes a reusable software design framework (RSDF) and how to achieve one. Tried a student experiment on 20 graduate students in three groups: A (7 using C++ with reuse); B (7 using the RSDF approach); and C (6 using C in a traditional manner). All students had to develop a window management system, and metrics were collected for each development. B scored well on process measures such as time to produce and productivity (LOC/hour). McCabe and Halstead were also collected but this seems less meaningful. D.J. Chen is at djchen@csunix.csie.acta.edu.tw.

[116] Chen, D. J. and P. J. Lee, 'On the study of software reuse using reusable C++ components', Journal of Systems and Software, 20(1), pp19-36, 1993.

Keywords: C++, Des, Emp, Reuse

Abstract: Presents a methodology for producing and reusing reusable components in C++. Describes a controlled experiment using 19 students developing a data base system. This indicated that their method gives an advantage over traditional ("top-down or free style") development methods.

[117] Chen, D. J. and P. J. Lee, 'On the study of software reuse using reusable C++ components', Journal of Systems and Software, 20(1), pp19-36, 1993.

Keywords: C++, Reuse

Abstract: The article presents a way (based on object interface) to manufacture reusable software components

and proposes a software construction method with guidelines for using designed reusable C++ components. Currently, about 130 reusable C++ components have been developed and they have been classified into a manageable structure. A controlled experiment was conducted to substantiate the proposed software reuse approach in terms of software productivity and quality. Compared with the traditional design and implementation approach, the proposed approach demonstrates its advantages for both software productivity and software quality improvement. These advantages are evident from the software metrics generated in the experiment.

[118] Chen, J. Y. and J. F. Lu, 'A new metric for object-oriented design', Information & Software Technology, 35(4), pp232-240, 1993.

Keywords: Des, Emp

Abstract: The paper presents a new metric for the object-oriented design. The metric measures the complexity of a class in an object-oriented design. The metrics include operation complexity, operation argument complexity, attribute complexity, operation coupling, class coupling, cohesion, class hierarchy, and reuse. An experiment is conducted to build the metric system. The approach is to derive a regression model of the metrics based on experimental data. Moreover, subjective judgements by experts are incorporated in the regression model. This ensures that the metric system is pragmatic and flexible for the software industry.

Notes: An experiment using six subjects to assess various OO metrics and a depressing example of an experiment without a hypothesis. The authors use multiple regression techniques to derive a composite of 4 metrics (operation complexity, operation argument complexity, operation coupling and class coupling) to predict an expert's subjective judgement of class complexity (based upon 9 factors). The authors don't say whether they use a stepwise method, nor do they give the R squared so it is difficult to comment upon the significance of this work.

[119] Cheol, J. Y., 'A factor analysis of object-oriented software complexity measures for small size C++ programs', Journal of KISS, 23(7), pp711-720, 1996.

Keywords: Theory, C++, Emp

Abstract: The complexity measures of object-oriented programs proposed in several papers are actually measuring the same thing. This paper includes a series of experiments analyzing relationships among some commonly used object-oriented program complexity measures. Identifying relationships is important in selecting the most significant measures to collect. Factor analysis, one of the advanced statistical analysis techniques, has been used to analyze software measures and is useful in identifying the important factors that influence variability in measures. This paper arranges object-oriented programs' complexity measures (variables), as proposed in several research studies, then analyzes the values of the complexity measures for C++ programs measured by a small-size tool automatically, and selects significant variables (factors) that affect the object-oriented software complexity by factor analysis. As a result, it is shown that three factors can be obtained by factor analysis. Factor 1 is closely correlated with the interface complexity caused by encapsulation. Factor 2 is related to the class of structure that explains the degree of object-orientation for the size of program, and factor 3 is related to the degree of reuse. From the results, we recognize that these three factors must be considered when developing a complexity measurement model for object-oriented software.

[120] Chidamber, S. R., D. P. Darcy, et al., Managerial use of object oriented software metrics. Working Paper No. 750, Katz Graduate School of Business, Univ. of Pittsburgh, 1997.

Keywords: Des, Prod, Emp

Notes: Contains a worked example and some empirical data to support the Chidamber and Kemerer metrics suite.

[121] Chidamber, S. R., D. P. Darcy, et al., 'Managerial use of object oriented software metrics: an exploratory analysis', IEEE Transactions on Software Engineering, 24(8), pp629-639, 1998.

Keywords: Emp, Des

Abstract: With the increasing use of object-oriented methods in new software development, there is a growing need to both document and improve current practice in object-oriented design and development. In response to this need, a number of researchers have developed various metrics for object-oriented systems as proposed aids to the management of these systems. In this research, an analysis of a set of metrics proposed by Chidamber and Kemerer (1994) is performed in order to assess their usefulness for practising managers. First, an informal introduction to the metrics is provided by way of an extended example of their managerial use. Second, exploratory analyses of empirical data relating the metrics to productivity, rework effort and design effort on three commercial object-oriented systems are provided. The empirical results suggest that the metrics provide significant explanatory power for variations in these economic variables, over and above that provided by traditional measures, such as size in lines of code, and after controlling for the effects of individual developers.

Notes: Updated version of the 1997 Tech Rep

[122] Chidamber, S. R. and C. F. Kemerer. 'Towards a Metrics Suite for Object Oriented Design', in Proc. OOPSLA '91. ACM, 1991.

Keywords: Des, Theory, Prod

Notes: First description of the well known Chidamber and Kemerer suite of metrics. The authors offer support for their ideas in the form Weyuker's nine axioms that complexity metrics ought to satisfy. See Weyuker, E. J. (1988). Evaluating software complexity measures. IEEE Transactions on Software Engineering, 14(9), 1357-1365.

[123] Chidamber, S. R. and C. F. Kemerer, A metrics suite for object oriented design. Technical Report No. WP No. 249, Center of Information Systems Research (MIT), 1993.

Keywords: Des, Prod

Abstract: This is an earlier version of the previous reference of Chidamber, S. R., & Kemerer, C. F. (1994). A metrics suite for object oriented design. IEEE Transactions on Software Engineering, 20(6), 476-493..

Notes: Chris Kemerer is at: CKEMERER@Katz.Business.Pitt.Edu.

[124] Chidamber, S. R. and C. F. Kemerer. 'MOOSE: Metrics for Object Oriented Software Engineering', in Proc. OOPSLA `93 Workshop on Processes and Metrics for Object Oriented Software Development. Washington DC: 1993.

Keywords: C++, Des, Emp, Small

Abstract: Not necessarily available as a paper. However, see the OOPSLA `93 Workshop Report: Steven C. Bilow, Tektronix, Inc. and Doug Lea, SUNY Oswego & N.Y. CASE Center. The following is taken from that report: The Chidamber and Kemerer metrics have generated a significant amount of interest and are currently the most well known suite of measurements for O-O software. In Shyam's quest to validate his metrics he has spent 3 months interviewing software designers and several month collecting empirical data from both C++ and Smalltalk projects. His principal points are that metrics must be theoretically rigorous and practically relevant. Toward those goals, the MOOSE metrics are beginning to show strong empirical validity.

[125] Chidamber, S. R. and C. F. Kemerer, 'A metrics suite for object oriented design', IEEE Transactions on Software Engineering, 20(6), pp476-493, 1994.

Keywords: Des, Prod

Abstract: Given the central role that software development plays in the delivery and application of information technology, managers are increasingly focusing on process improvement in the software development area. This demand has spurred the provision of a number of new and/or improved approaches to software development, with perhaps the most prominent being object-orientation (OO). In addition, the focus on process improvement has increased the demand for software measures, or metrics with which to manage the process. The need for such metrics is particularly acute when an organization is adopting a new technology for which established practices have yet to be developed. This research addresses these needs through the development and implementation of a new suite of metrics for OO design. Metrics developed in previous research, while contributing to the field's understanding of software development processes, have generally been subject to serious criticisms, including the lack of a theoretical base. Following Wand and Weber (1989), the theoretical base chosen for the metrics was the ontology of Bunge (1977). Six design metrics are developed, and then analytically evaluated against Weyuker's (1988) proposed set of measurement principles. An automated data collection tool was then developed and implemented to collect an empirical sample of these metrics at two field sites in order to demonstrate their feasibility and suggest ways in which managers may use these metrics for process improvement.

Notes: This paper restates the work presented in their earlier paper and cites general criticisms made at previous metrics work i.e.,· lacking a theoretical basis· lacking desirable measurement properties· being too implementation dependent· being too labour intensive to collectIt presents the results of applying the metrics to industrial software. In conclusion the paper states that : an advantage of design metrics is that it produces a clearer picture of the tradeoffs made during the design process; and OO metrics can help in selecting between possible designs the one that is most appropriate to the goals of the organisation.

[126] Chidamber, S. R. and C. F. Kemerer, 'Reply To Comments on "A Metrics Suite for Object-Oriented Design"', IEEE Transactions on Software Engineering, 21(4), pp265, 1995.

Keywords: Des

Abstract: Reply to [Churcher, 1995]: "In our view, the entire list of questions [about what methods should be included in the calculation of Number of Methods Per Class] can be answered by reference to a simple

principle that methods which required additional design effort and are defined in the class should be counted, and those that do not should not.

[127] Chung, C., T. Shih, et al., 'Integration Object-Oriented Testing and Metrics', International Journal of Software Engineering and Metrics, 7(1), pp125-144, 1997.

Keywords: Test

Abstract: Software testing methodologies and metrics are key issues to improve and assure software quality. They are important areas in the research of software engineering. However, not many focus on the testing criteria and metrics evaluation of a class hierarchy. The paper introduces an important concept named URI (Unit Repeated Inheritance) to realize integrated object oriented testing and object oriented metrics. The approach describes an ILT (Inheritance Level Technique) method as a guide to test object oriented software errors and measure the software complexity of a class hierarchy. The proposed technique shows that inheritance has a close relation to object oriented software complexity and reveals that overuse of repeated (multiple) inheritance will increase software complexity and be prone to implicit software errors. Also, two test criteria: intra level first and inter level first are presented.

[128] Chung, C., C. Wang, et al. 'Class Hierarchy Based Metrics for Object-Oriented Design', in Proc. Proceedings of the 1994 IEEE Region 10's Ninth International Conference. Frontiers of Computer Technology. Singapore: IEEE, 1994.

Keywords: Des, Prod

Abstract: Object-oriented technology, including object-oriented analysis (OOA), object-oriented design (OOD), and object-oriented programming (OOP), is a new promising approach to developing software systems to reduce software costs and to increase software extensibility, flexibility, and reusability. Software metrics are widely used to measure software complexity and assure software correctness. This paper proposes a metric to measure object-oriented software. Also, an important factor called URIs, is conducted to build the metric. This approach describes a graph-theoretical method for measuring the complexity of the class hierarchy. The proposed metric shows that inheritance has a close relation with object-oriented software complexity and reveals that misuse of repeated (multiple) inheritance will increase software complexity and be prone to implicit software errors.

[129] Chung, C. M. and M. C. Lee, 'Inheritance-based metric for complexity analysis in object-oriented design', Journal of Information Science and Engineering, 8(3), pp431-447, 1992.

Keywords: Des, Prod

Abstract: Object-oriented software development, including object-oriented analysis (OOA), object-oriented design (OOD) and object-oriented programming (OOP), is a promising new approach for developing software systems to reduce software costs and to increase software reusability, flexibility, and extensibility. Software metric is an important technique used to measure software complexity to improve software quality and enhance software correctness. For the past decade, most software metrics have been developed on procedure-oriented languages and widely applied to software complexity evaluation. Recently, many researches on software metrics have taken the object-oriented approach to measuring the complexity of OO software. However, few researches have led to insight into the relationships between object-oriented design complexity and inheritance. This paper describe a graph-theoretical metric for measuring the complexity of class hierarchy. This metric shows that inheritance has a close relation with object-oriented software complexity

and reveals that overuse of repeated (multiple) inheritance will increase software complexity and be prone to implicit software errors. An algorithm to support this software metric is presented. Its time complexity is O(n^3). (12 Refs.).

[130] Chung, C. M. and M. C. Lee. 'Inheritance-Based Object-Oriented Software Metrics', in Proc. TENCON '92 IEEE Region 10 Conference. Melbourne, Australia: IEEE, 1992.

Keywords: Prod

Abstract: There is no software metrics based on object-oriented programming languages (OOPLs) developed to help object-oriented software development. A graph-theoretical complexity metric to measure object-oriented software complexity is described. It shows that inheritance has a close relation with the object-oriented software complexity, and reveals that misuse of repeated (multiple) inheritance will increase software complexity and be prone to implicit software errors. An algorithm to support this software metric is presented. Its time complexity is O(n^3).

[131] Chung, C. M. and M. C. Lee, 'Object-oriented programming software metrics', International Journal of Mini and Microcomputing, 16(1), pp7-15, 1994.

Keywords: Prod, Theory

Abstract: Object-oriented software development, including object-oriented analysis, object-oriented design, and object-oriented programming, is a new and promising approach to developing software systems in order to reduce software costs and increase reusability, flexibility, and extensibility. Software metric is an important technique used to measure software complexity, to improve software quality and enhance software correctness. However, there is no software metrics based on object-oriented programming languages developed to facilitate object-oriented software development. This paper describes a graph-theoretic complexity metric and illustrates how it can be used to manage and control object-oriented software complexity. It shows that inheritance has a close relation with the object-oriented software complexity, and reveals that misuse of repeated (multiple) inheritance will increase software complexity and be prone to implicit software errors. An algorithm to support this inheritance-based software metric is presented. Its time complexity is O(n^3).

[132] Chung, C. M., T. K. Shih, et al. 'A graph-theoretical metric for object-oriented software complexity', in Proc. Proceedings of the Eleventh International Symposium on Computer and Information Sciences. ISCIS. Middle East Tech. Univ, Ankara, Turkey: 1996.

Keywords: Theory, Prod

Abstract: Software metrics are widely used to measure software complexity and assure software quality. However, research in the field of the software complexity of a class hierarchy has not yet been carefully studied. We introduce a novel factor named URI (Unit Repeated Inheritance) and an important method named ILT (Inheritance Level Technique) 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 metric shows that inheritance has a close relation to the object oriented software complexity and reveals that overuse of repeated (multiple) inheritance will increase software complexity and be prone to implicit software errors.

[133] Chung, C. M., T. K. Shih, et al. 'Inheritance hierarchy metric', in Proc. Eleventh International Symposium on Computer and Information Sciences. ISCIS. Middle East Tech. Univ, Ankara, Turkey: 1996.

Keywords: Qual, Theory

Abstract: The object oriented (OO) paradigm has a valuable programming technique. However, very few software metrics have been proposed in the field of the OO paradigm. Even of those proposed, not many focus on the complexity of an inheritance hierarchy. We propose a suite of software metrics to measure the complexity of an inheritance hierarchy and introduce two indicators: Inheritance Density (ID) and Level Density (LD). These indicators show how the inheritance hierarchy influences software complexity. Also, we evaluate our proposed OO metrics by E.J. Weyuker's (1988) software metrics evaluation criteria.

[134] Chung, C. M., T. K. Shih, et al., 'Object-oriented software testing and metric in Z specification', Information Sciences, 98(1-4), pp175-202, 1997.

Keywords: Theory, Prod

Abstract: Software testing and metrics are key issues for improving software quality. They are important issues in the research of software engineering. In line with the methodologies of object-oriented analysis and design, many testing and metrics techniques have been proposed. However, not many focus on the testing criteria and metrics evaluation of an inheritance hierarchy. The authors introduce a concept named unit repeated inheritance (URI) in Z to realize object-oriented testing and object-oriented metrics. The approach describes an inheritance level technique (ILT) method as a guide to test and measure the software complexity of an inheritance hierarchy. The measurement of inheritance metrics and some testing criteria thus can be formed based on the proposed mechanism.

[135] Chung, C. M., T. K. Shih, et al., 'Object-oriented software development techniques-combining testing and metrics', International Journal on Information and Management Sciences, 6(4), pp17-34, 1995.

Keywords: Test, Prod

Abstract: Software testing methodologies and metrics are widely applied to assuring and evaluating software quality. However, current software testing and metrics based on object-oriented programming languages are developed individually. This paper introduces an important method named URI (Unit Repeated Inheritance) to build integrated object-oriented testing and object-oriented metrics. The approach describes ILT (Inheritance Level Technique) methods for a guide to test software errors and measure software complexity. The proposed techniques show that inheritance has a close relation with object-oriented software complexity and reveal that overuse of repeated (multiple) inheritance will increase software complexity and be prone to implicit software errors. Also, two test criteria: intra level first and inter level first are presented.

[136] Churcher, N. and M. J. Shepperd. 'Object-Oriented Software Metrics: Holy Grail or Poison Chalice?', in Proc. OOPSLA'94, Metrics Workshop Position Paper. Portland, Oregon: ACM, 1994.

Keywords: Prod, C++

Abstract: "Interest in OO metrics is growing rapidly. The problem of developing software metrics for OO systems is considerably more complex than the corresponding problem for conventional languages. Yet this simpler problem remains unsolved and the reputation of the whole field of software metrics has been tarnished by the lack of rigour in both theoretical and empirical work. 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 discuss some of the issues we have encountered in our own work and identify some of the factors which we believe are critical for the successful growth of OO metrics."

[137] Churcher, N. and M. J. Shepperd, 'Comment on "A metrics suite for object oriented design"', IEEE Transactions on Software Engineering, 21(3), pp263-265, 1995.

Keywords: C++, Des

Abstract: This paper largely supports Chidamber and Kemerer (CK) in their attempts to produce metrics with a sound theoretical basis. It does however make the point that the detailed counting strategies for the primitive counts on which the metrics are based were not specified. As it says "while there is no ideal counting strategy, it is important to make explicit the technique actually employed as misleading results may be obtained if like is not compared with like." The paper continues with an extended example of the large variations in results which may be found if different counting strategies are used. The paper stresses the importance of using and documenting the precise form appropriate to a particular circumstance, especially if the count s to be used in a composite or indirect metric.

[138] Churcher, N. I. and M. J. Shepperd, 'Towards a Conceptual Framework for Object Oriented Software Metrics', ACM SIGSOFT Software Engineering Notes, 20(2), pp69-76, 1995.

Keywords: C++, Des, Emp

Abstract: This paper covers much of the ground also covered by their March '95 paper and also Shepperd '92. It starts by questioning whether it is premature to develop OO metrics while there are still uncertainties in the definitions of many fundamental properties and a lack of even qualitative understanding of the behavior and structure of OO systems. A set of proposed standardised terms is given together with an associated proposal for architectural modelling. Although these are presented as implementation independent they seem heavily influenced by terminology and constructs of C++. It re-iterates the point made in previous papers that extreme caution should be exercised in trying to extend metrics designed for conventional systems into the OO domain. Since recent studies show that both complexity and the size of methods tend to be small it is suggested that the connectivity structure may be more important the than the content of individual methods in OO systems. This connectivity is made up of both architectural structure and call-graph structure. A suggestion is also made that usual static analysis techniques may not be sufficient to fully capture the dependencies in OO systems because of polymorphism and that this may cause problems for metrics and maintenance. The paper restates that the failure to precisely the counting rules used for a metric introduces unnecessary uncertainty into derived metrics and so lowers the usefulness of the results to other researchers. A detailed demonstration of this is given using number of methods per class as an example. Finally the CK metrics are examined and the effects on each metric of the choice of counting rules is considered.

[139] Cimitile, A., A. de Lucia, et al. 'Identifying objects in legacy systems', in Proc. Proceedings Fifth International Workshop on Program Comprehension. IWPC'97. IEEE Comput. Soc. Press, Los Alamitos, CA, USA, 1997.

Keywords: Des, Qual

Abstract: We present an approach to decomposing legacy systems written in procedural languages into

objects. The identification of the objects is centred around persistent data scores, such as files or tables in the database, while programs and subroutines are candidate to implement object methods. The approach proposed for assigning programs and subroutines as object methods exploits object oriented design metrics. The rationale behind this choice is that any object oriented decomposition of a legacy system should not lead to a poor design, as this would make the reengineered system more difficult to maintain.

[140] Cimitile, A., A. de Lucia, et al., 'Identifying objects in legacy systems using design metrics', Journal of Systems and Software, 44(3), pp199-211, 1999.

Keywords: Qual, Des

Abstract: Many organisations are migrating towards object-oriented technology. However, owing to the business value of legacy software, new object-oriented development has to be weighed against salvaging strategies. The incremental migration of procedurally oriented systems to object-oriented platforms seems to be a feasible approach, although it must be considered as risky as redevelopment. This approach uses reverse engineering activities to abstract an object-oriented model from legacy code. The paper presents a method for decomposing legacy systems into objects. The identification of objects is centred around persistent data stores, such as files or tables in the database, while programs and routines are candidates for implementing the object methods. Associating the methods to the objects is achieved by optimising selected object-oriented design metrics. The rationale behind this choice is that the object-oriented decomposition of a legacy system should not result in a poor design, as this would make the re-engineered system more difficult to maintain.

[141] Ciupke, O. 'Analysis of object-oriented programs using graphs', in Proc. Object-Oriented Technology, ECOOP'97 Workshops Proceedings. Springer-Verlag, Berlin, Germany, 1998.

Keywords: Theory, Tool

Abstract: Complex interdependencies between different parts of a system are a major problem for the maintenance, evolution, and reorganization of large programs. In an object oriented system, such dependencies exist due to different kinds of interrelationships between the different kinds of entities which make up the system. Reengineering large object oriented systems requires methods and tools for analyzing these dependencies. Graph theory is well understood and encompasses a large number of concepts, methods and algorithms which can be applied for these purposes. Graphs are already widely used in an informal way as a notation for the design of programs. Examples for this are most modelling languages, such as the UML. Graphs can also be used in a formal way to describe the complex dependency relationships in an object oriented system. The article explains how this can be achieved. By using graph theory and reengineering, a single monolithic tool was built which could: visualize object oriented systems in an improved way compared to existing reengineering tools; detect problems by performing queries on graphs; implement object oriented metrics in the form of simple queries; and visualize the results of queries.

[142] Coad, P. and E. Yourdon, Object-Oriented Design. Yourdon Press/Prentice Hall: 1991.

Keywords: Des, Rev

Abstract: Chapter 8 deals with metrics.

[143] Coffee, P. 'Objects at work: striking the cost/benefit balance', in Proc. 1992 Borland International Developers' Conference. 1992.

Keywords: Man, Size

[144] Condry, C., 'A decade of object-oriented programming books', Journal of Object-Oriented Programming, 7(5), pp59-68, 1994.

Keywords: Rev

Abstract: "A comprehensive list of 455 object technology related books and videos published in the last decade. The listings are grouped by subject and alphabetized by author."

[145] Constantine, L., 'Efficient Objects', Object Magazine, 7(7), pp71-72, 18, 1997.

Keywords: Rev

Abstract: Software metrics are a matter of putting things into numbers, so they can be based on almost anything that can be counted, rated or ranked. The best-known metrics are measures of program size or complexity. On the simple, straightforward end of the spectrum is the venerable count of code length. On the other are function points and feature points and their other elaborately-institutionalized kind. The more sophisticated metrics have their advantages and adherents, but just counting classes or methods can be worth almost as much as the most elaborate and theoretically-informed measurement scheme. For numerous reasons, size and complexity metrics are often the first to be considered by software project managers. The author discusses different types of software metrics for object oriented programs.

[146] Consultants, Special issue on object technology. , 1995.

Keywords: Rev, Emp, Ind

Abstract: Contains profiles of many companies using and supplying OT. Also a market survey involving "250 of the UK's largest IT investors", although it is not clear how many participated fully. The bulk of participants (61%) are in the financial domain. Most have been using OT for upto 3 years (only 22% for 3 or more) and by far the single most popular methodology is Rumbaugh (30% compared to 9% each for Booch and Jacobsen.

Notes: Compare with [KPMG, 1994].

[147] Coppick, J. C. and T. J. Cheatham. 'Software metrics for object-oriented systems', in Proc. Annu. ACM Computer Science Conf. Kansas: ACM Press, 1992.

Keywords: Prod

Abstract: The application of software complexity metrics within the object-oriented paradigm is examined. Several factors affecting the complexity of an object are identified and discussed. Halstead's (1977) software science metrics and McCabe's (1976) cyclomatic complexity metric are extended to an object. A limit for the cyclomatic complexity of an object is suggested.

Notes: Tries to apply the Halstead metrics and McCabe's v(G) to OO code implemented in LISP Flavors. There are many appeals to the intuition and no meaningful empirical data.

[148] Cruz, C. D. 'A proposal of an object oriented development cost model', in Proc. European Software Measurement Conference. FESMA 98. Technologisch Instituut Vzw, Antwerpen, Germany: 1998.

Keywords: Size, Prod

Abstract: When computers were first used, in large scale, software cost represented less than 20% of the total cost of computer systems. However, today, this cost means about 80%. This fact explains the interest in measuring and controlling software development project cost. Software cost estimation methods have arisen to improve software product development plans. Quantitative methods, or metrics, can be applied to increase cost estimation accuracy, improving the organizations ability to plan new projects. Due to the lack of cost variables behavior theories, cost models are based on past experiences to estimate product size and project cost. These models establish, using statistical methods, functional relationships between size variables and development effort. Nevertheless, when new technologies are applied to develop a software product, the lack of experiences makes impossible the use of statistical methods to raise the most important cost variables. Therefore, traditional methods, composed by variables that do not consider the emerging aspects, are used to estimate costs of the new projects. This is the case of projects in the object oriented technology area and, because of that, the proposal of this article is to show a software cost model that uses size metrics applied to the object oriented technology, as well as factors to adjust the productivity taxes. The goal is obtaining more accuracy in cost estimation results.

[149] CTR, Directory of Object Technology. Vol. ISBN 1-884842-08-9. SIGS Books: 1995.

Keywords: Rev

Abstract: Lists 1309 products, 731 services, 200 training and mentoring contacts, 500 books, and 330 company listings.

Notes: Contact CTR at CTRreports@aol.com.

[150] Daly, J., Replication and multi-method approach to empirical software engineering research. Doctoral Thesis , Univ. of Strathclyde, 1996.

Keywords: Emp, Theory, Des, Maint

[151] Daly, J., A. Brooks, et al. 'The effect of inheritance on the maintainability of object-oriented software: an empirical study', in Proc. Intl. Conf. on Softw. Maintenance (ICSM'95). Nice: IEEE Computer Society Press, 1995.

Keywords: Des, Emp

Abstract: Marc Roper is at marc@strath.ac.uk.

[152] Daly, J., A. Brooks, et al. 'Evaluating the effect of inheritance on the maintainability of object-oriented software', in Proc. Empirical Studies of Programmers. Washington, DC: 1996.

Keywords: Emp, Maint, Des

Notes: Nice study of the effects of the depth of inheritance upon time taken to carry out a maintenance task. The authors found flat structures and depths of 5 were less maintainable than a depth of 3. Slightly marred by the use of student subjects and a very trivial task. Also the subjects were not provided with any design documentation.

[153] Davis, J. and T. Morgan, 'Object-oriented development at Brooklyn Union Gas', IEEE Software, 10(1), pp67-74, 1993.

Keywords: Ind, Small

Abstract: Discussion of the development of Customer-Related Information System (CRIS) in "a Smalltalk-like execution environment with object-oriented features". "Two years of maintenance and enhancements since its start-up have demonstrated that we can naturally adapt its object model to changes."

Notes: John Davis is at Andersen Consulting, Tom Morgan is at Brooklyn Union Gas, 74155.416@compuserve.com.

[154] de Almeida, M. A., H. Lounis, et al. 'An Investigation on the Use of Machine Learned Models for Estimating Software Correctability', in Proc. 20th IEEE Intl. Conf. on Softw. Eng. Kyoto, Japan: IEEE Computer Society Press, 1998.

Keywords: Prod

Notes: Investigates several machine learning algorithms for prediciting software cost via software code measures.

[155] de Champeaux, D., Object-oriented development process and metrics. Prentice Hall International: Englewood Cliffs, NJ, 1997.

Keywords: Prod

[156] de Champeaux, D., A. Anderson, et al. 'Case study of object-oriented software development', in Proc. OOPSLA. 1991.

Keywords: C++, Ind, Man, Emp

Abstract: Another report on the [de Champeaux, 1991] case study. From the paper: "The defect rate for code written for the entire system was roughly equivalent to that reported for C code developed throughout the industry. By contrast, the C++ code, comprising about 30% of the entire code written, was reported to have a defect rate of less than 50% of that for the C code."

[157] de Champeaux, D., A. Anderson, et al., Case study of object-oriented software development. No. Report no. HPL-91-170, Hewlett-Packard Lab., 1991.

Keywords: Des, Emp, Ind, Man, Size

Abstract: These are the highlights of a successfully completed application of object-oriented software

development for a new product. The project was of medium size, the duration was less than 24 months (from the end of the requirements specification to product shipment), and the average team size was 8-10 software engineers. The authors discuss how the team dealt with major new aspects: a different paradigm, a different programming language, a different user interface environment, and a different development environment. In spite of all these novelties and in spite of the fact that the code size had been underestimated by about 75%, the project schedule slipped only by 20%. The authors touch upon all phases of the development life cycle: requirements capture, OO analysis, OO design, OO implementation and the verification phase. Some management perspectives are addressed as well. (2 Refs.).

Notes: Dennis de Champeaux is at ddc@netcom.com.

[158] Debnath, N. C., S. Islam, et al. 'An automated software model generator', in Proc. International Conference on Computers and Their Applications. Cary, NC, USA: Int. Soc. Comput. & Their Appl.-ISCA, 1998.

Keywords: Tool

Abstract: Object-oriented development of an automated software model generator for mechanically generating three commonly used software engineering models and metrics are discussed. The input and output specifications of the generator are described. The software model generator developed can be useful in designing and implementing a CASE tool for studying a vector of software models and metrics, and thus may significantly help enhance software engineering validation experiments and the software maintenance process.

[159] Deubler, H. H. and M. Koestler, 'Introducing object-orientation into large and complex systems', IEEE Trans. on Software Eng., 20(11), pp840-848, 1994.

Keywords: C++, Ind, Qual, Emp

Abstract: Discusses the rewriting of part of Siemens Nixdorf's BS2000 operating system in C++. Errors in a prototype were found to be only 1/3 of the usual density: "We attribute this totally to the properties of object orientation supported by a language like C++ including strong typing, type safe linkage..." However, there was a penalty: CPU instructions in the C++ prototype were 10-15% greater than the original /390 assembler code.

[160] Doake, J. and I. Duncan. 'Amber metrics for the testing and maintenance of object-oriented designs', in Proc. Second Euromicro Conference on Software Maintenance and Reengineering. IEEE Comput. Soc, Los Alamitos, CA, USA, 1998.

Keywords: Test, Maint, Size, Des

Abstract: For testing to be focused and efficient during object oriented design and development, it is necessary to detect and analyse problematic constructs. Measures of detection must be simplistic but meaningful. Due to the iterative nature of system development, measurement effort must be automatic or negligible. It is argued that currently available measures are used, but effort is put into understanding what the results mean for maintenance and testing. Design based metrics can be used to outline the maintenance cost. Reducing the effort in performing and checking system alterations radically affects the overall cost of system development.

[161] Dorman, M. 'Unit testing of C++ objects', in Proc. EuroSTAR. London: 1993.

Keywords: C++, Test, Prod

Abstract: Concept of the unit test (as class testing) and definition of a test tool (Cantata) that measures Halstead's metrics, Myers-Mccabe, Hansen et al for C++ programs.

Notes: The EUROSTAR conferences are organised by Software Quality Engineering, 3000-2 Hartley Road, Jacksonville, FL 32257, USA, tel: (904) 268 8639, fax: (904) 268 0733, contact: Bill Hetzel.

[162] Dumke, R., Software metrics: a subdivided bibliography. Research Report No. IRB 007/92, University of Magdeburg, Germany, 1993.

Keywords: Rev

Abstract: A large bibliography which is regularly updated (December '93 is the latest I've got a copy of). There is a fairly short section on object-oriented metrics. No annotations.

Notes: Electronic versions of files bib.tex and analyse.exe via anonymous ftp from ftp.cs.tu-magdeburg.de in directory /pub/metrik.

[163] Dumke, R., Experiences in object-oriented software development — the empirical basis for object-oriented software metrics. Research Report No. IRB 002/94, University of Magdeburg , Germany, 1994.

Keywords: Rev

Abstract: A summary of 18 'readings' in object-oriented metrics including: the 1st edition of [Booch, 1994], [Bieman, 1991], [Bradley, 1991], [Chen, 1993], [Chidamber, 1993], [Lake, 1992], [Lorenz, 1993], [Ponder, 1992], [Sharble, 1993]

[164] Dumke, R., E. Foltin, et al. 'Measurement based quality assurance in object-oriented software development', in Proc. OOIS'95. Dublin City University: 1995.

Keywords: Qual

[165] Dumke, R. and I. Kuhrau. 'Tool-based quality management in object-oriented software development', in Proc. QSDT'94. Washington: 1994.

Keywords: C++, Des, Qual, Small

Abstract: Describes a tool-based metrication method for object-oriented software development. This approach is based on the notions of the "compactness of software development" and the "total measurement framework". The first step of the application of this approach was given for the OOA/OOD/OOP method of Coad and Yourdon (1991) and its usefulness is discussed. The object-oriented programming (OOP) is based on Smalltalk, but the results can be used for measurement-based OOP in C++.

[166] Dumke, R., K. Neumann, et al., 'The metric based compiler — a current requirement', ACM SIGPLAN Notices, 27(12), pp29-38, 1992.

Keywords: Tool

[167] Dumke, R. and A. Winkler. 'The nonclassical use of software metrics', in Proc. Int. Conf. on Software Quality. Research Triangle Park: 1992.

Keywords: Small

Abstract: Includes the Smalltalk/V extension for simple size and complexity measurement in relation to other programming paradigms.

[168] Dumke, R. and H. Zuse. 'Software-metriken in der objektorientierten software-entwicklung', in Proc. Deutsche Hochschulschriften 561. HVSnsel, Hohenhausen, Egelsdbach, Frankfurt: 1994.

Notes: Reiner Dumke is at the University Of Magdeburg in Germany: dumke@irb.cs.tu-magdeburg.de.

[169] Dumke, R. R. 'An object-oriented software measurement and evaluation framework and its application in an industrial environment', in Proc. CONQUEST '98. Conference on Quality Engineering in Software Technology. ASQF, Erlangen, Germany, 1998.

Keywords: Emp, C++, Theory

Abstract: The efficiency of software development (i.e. to produce good software products based on an efficient software process) must be controlled by a quantification of the software development process, as well as the product in the different phases and the resources. The quantification by means of software measurement needs a unified strategy, methodology or approach as one important prerequisite to guarantee the goals of quality assurance, improvement and controlled software management to be achieved. Nowadays, plenty of methods such as measurement frameworks, maturity models, goal-directed paradigms, process languages etc., exist to support this idea. But most of them are based on a `static' or `functional' approach and do only assess software processes and products. The paper describes a real object oriented (OO) approach of a software measurement framework aimed at evaluating OO software products. It reasons the applicability of metrics based evaluation as an indicator for the quality assurance of the OO development process. The new measurement framework was applied to an industrial C++ product and the results are discussed.

[170] Dumke, R. R. and E. Foltin. 'Metrics-based evaluation of object-oriented software development methods', in Proc. Second Euromicro Conference on Software Maintenance and Reengineering. IEEE Comput. Soc, Los Alamitos, CA, USA, 1998.

Keywords: Qual, Theory

Abstract: The efficiency of software development (i.e. producing good software products based on an efficient software process) must be controlled by a quantification of the software development methodologies. This is a main aspect of a successful method/technology change in the area of software maintenance as a means of method adaptation. The descriptions of object-oriented (OO) methods or comparisons of some of these features are usually given by a listing of their features. These descriptions describe the functionality of a particular development method but often fail to address quality issues like efficiency, maintainability,

portability, maturity, etc. This paper describes the evaluation of technology change related to OO development methods. It discusses the applicability of metrics-based evaluation as an indicator of the quality assurance of the OO development process.

[171] Dumke, R. R., E. Foltin, et al. 'Measurement-based quality assurance in object-oriented software development', in Proc. International Conference on Object Oriented Information Systems, OOIS '95. Springer-Verlag, Berlin, Germany, 1996.

Keywords: Des, Theory

Abstract: This paper describes the fundamental ideas of our present project-the software measurement laboratory-as a method of metrication of object-oriented software development. The underlying measurement framework starts at the first step of the software development (the problem definition) and measures the metric mutations in the object-oriented paradigm of Coad/Yourdon.

[172] Dumke, R. R. and A. S. Winkler. 'Object-oriented software measurement in an OOSE paradigm', in Proc. Software Measurement and Management. Int. Function Point Users Grup, Westerville, OH, USA, 1996.

Keywords: Theory, Man, Small

Abstract: This paper describes a new view of software measurement as an object-oriented approach for the measurement itself: The recent strategies in software measurement are based on a general improvement approach in a functional way. They define a general input of quality requirements and want to obtain by the "functions" of the SQA (software quality assurance) an output as an improved software process or software product. In our new approach the software development such as new design, enhancement or maintenance keeps the present quality as initial basis level. This approach is demonstrated on the object-oriented software engineering (OOSE) approach of Coad/Yourdon with the implementation system Smalltalk.

[173] Dumke, R. R. and A. S. Winkler. 'Managing the component-based software engineering with metrics', in Proc. Fifth International Symposium on Assessment of Software Tools and Technologies. IEEE Comput. Soc. Press, Los Alamitos, CA, USA, 1997.

Keywords: Qual, Java

Abstract: Describes the management of software development component characteristics, such as quality and/or complexity. We define a key problem in software development change: the software development complexity and the methods to reduce this. In component-based software engineering, "component-based" metrics are also necessary in our new object-oriented measurement framework. Tools for the support of the software measurement process are classified as computer-assisted measurement and evaluation (CAME) tools. Some aspects of Java software development measurement and evaluation are discussed.

[174] Durnota, B. and C. Mingins. 'Tree-Based Coherence Metrics in Object-Oriented Design', in Proc. TOOLS 12. 1992.

Keywords: Des, Prod

Abstract: A method is proposed to analyze how well an object-oriented design, or implementation, has

decomposed its problem domain into classes that have tight internal interactions. A distance matrix is constructed based on the number of methods not in common in the 'path' of all method calls for any given pair of methods. A cluster analysis is carried out using this distance matrix. A metric is constructed which incorporates various properties one would wish a coherence metric to have. An inspection of the resulting dendrogram can be used to suggest system redesigns. The method is illustrated with Eiffel examples.

[175] Dvorak, J., 'Conceptual Entropy and Its Effect on Class Hierarchies.', IEEE Computer, 27(June), pp59-63, 1994.

Keywords: Small, Prod, Emp, Tool

Abstract: This paper reports on an experiment which required designers to develop the class hierarchy from a collection of Smalltalk classes. The results suggest that the deeper in the hierarchy the designers got the more confusing things were. The author then proposes a tool for automatically refining class hierarchies to counter the increasing entropy in an evolving application hierarchy. The following guidelines are given for minimising conceptual entropy. They are used in an algorithm which is intended for the automatic restructuring of class hierarchies.

1. Making explicit the hierarchy's conceptual architecture.1.1 A high level of abstraction1.2 Simplicity1.3 Analysability2. Quantitative subclassing criteria.2.1 Conceptual specificity2.2 Conceptual consistency2.3 Conceptual distance

Notes: Steve's final thought, 'has the author not read Cook's work on Smalltalk class interfaces?'

[176] Ebert, C. and I. Morschel, 'Metrics for quality analysis and improvement of object-oriented software', Information & Software Technology, 39(7), pp497-509, 1997.

Keywords: Ind, Emp, Qual

Abstract: Software metrics play an important role in analysing and improving the quality of software work products during their development. Measuring the aspects of software complexity for object-oriented software helps to improve the quality of such systems during their development, with particular emphasis on reusability and maintainability. It is widely accepted that more widespread use of object-oriented techniques can only come about when there are tool systems that provide development support beyond visualising code. Unfortunately, many object-oriented metrics are defined and applied to classroom projects but no evidence is given that the metrics are useful and applicable both from an experience viewpoint and from a tools viewpoint-for industrial object-oriented development. Distinct complexity metrics are developed and integrated in a Smalltalk development support system called SmallMetric. Thus, one achieves a basis for software analysis (metrics) and development support (critique) of Smalltalk systems. The main concepts of the environment including the underlying metrics are explained, its use and operation is discussed, and some results of the implementation and its application to several industrial projects are given with examples.

[177] Eckert, G. and P. Golder, 'Improving object-oriented analysis', Information & Software Technology, 36(2), pp67-86, 1994.

Keywords: Rev, Des

Abstract: A very thought provoking paper which reviews published attempts to define OOA methods and finds them wanting. They use an extended ER notation as a meta-modelling tool for this comparison. They finally propose a nested object-relationship-operation framework which is based on a consistent object model and deals with encapsulation and possibly even object clustering.

[178] Eder, J., G. Kappel, et al., Coupling and cohesion in object-oriented systems. Tech. Rep. , University of Klagenfurt, 1994.

Keywords: Rev, Des

Abstract: Presents a taxonomy of types of coupling and cohesion in OO systems. An overview is given in [Stiglic, 1995].

[179] Ejiogu, L. O., 'On diminishing the vibrant confusion in software metrics', SIGPLAN Notices, 32(2), pp35-38, 1997.

Keywords: Rev

Abstract: Since the advent of object oriented programming (OOP) more vibrant confusion has surfaced in the research and applications of software metrics. Following the extensive bibliography of R. Whitty (1996), it is crystal clear that after nearly twenty years of software measurements, several problems still plague the science of software measurement, ranging from classifications to rational mathematical formulations of what to measure. It is the purpose of the article to briefly highlight some fundamental truths of this discipline.

[180] El Emam, K. 'The predictive validity criterion for evaluating binary classifiers', in Proc. Fifth International Software Metrics Symposium. IEEE Comput. Soc, Los Alamitos, CA, USA, 1998.

Keywords: Maint, Theory, Emp

Abstract: The development of binary classifiers to identify highly error-prone or high maintenance cost components is increasing in the software engineering quality modeling literature and in practice. One approach for evaluating these classifiers is to determine their ability to predict the classes of unseen cases, i.e., predictive validity. A chi-square statistical test has been frequently used to evaluate predictive validity. We illustrate that this test has a number of disadvantages. The disadvantages include a difficulty in using the results of the test to determine whether a classifier is a good predictor, demonstrated through a number of examples, and a rather conservative Type I error rate, demonstrated through a Monte Carlo simulation. We present an alternative test that has been used in the social sciences for evaluating agreement with a "gold standard". The use of this alternative test is illustrated in practice by developing a classification model to predict maintenance effort for an object oriented system, and evaluating its predictive validity on data from a second object-oriented system in the same environment.

[181] Eldh, S. 'Helping developers do their job better in an OO environment', in Proc. STAR '96: Fifth International Conference, Software Testing, Analysis and Review. Software Quality Engineering, Jacksonville, FL, USA, 1996.

Keywords: C++, Qual, Ind

Abstract: Ericsson Hewlett-Packard Telecommunications have a problem with many faults which are found late in a project (i.e. during the system test), and these faults should be found at earlier stages of development and testing. I had the opportunity to analyse, suggest, implement and re-evaluate a number of actions in a development project. There are many issues which must be handled in order to improve a development process. Most of the suggestions proposed in this paper could be used in any environment and are not directly aimed at object orientation. This paper discusses how it is possible to support the developers in a complex real-time object-oriented environment using C++ and I show how it is possible to quickly make some improvements. The key areas are to introduce a better review process, some measurements and better testing tools. Developers must also be trained, and minimum standards of testing, at the unit level, should be enforced. If you ignore the quality process you will end up testing quality in the product instead of developing a quality product.

[182] Embley, D. W., R. B. Jackson, et al., 'OO systems analysis: is it or isn't it?', IEEE Software, 12(July), pp19-33, 1995.

Keywords: Rev, Des

Abstract: "Design features can creep into analysis methods when such methods evolve from a design-and-implementation perspective. Although these features may aid design, they are likely to hinder analysis. The authors introduce an object-oriented analysis method that contains no design features". The method, called OSA, is compared with five other OO methods. OSA has significantly fewer design features and more analysis features.

Notes: David Embly is at embly@cs.byu.edu.

[183] Embley, D. W. and S. N. Woodfield. 'Assessing the quality of abstract data types written in Ada', in Proc. 10th Intl. Conf. on Software Eng. Singapore: Computer Society Press, 1988.

Keywords: Des, Qual

[184] Erni, K. and C. Lewerentz. 'Applying design-metrics to object-oriented frameworks', in Proc. 3rd International Software Metrics Symposium. IEEE Comput. Soc. Press, Los Alamitos, CA, USA, 1996.

Keywords: Des, Qual, Emp, Tool

Abstract: Presents a novel way of using object-oriented design metrics to support the incremental development of object-oriented programs. Based on a quality model (the factor-criteria-metrics model), so-called multi-metrics relate a number of simple structural measurements to design principles and rules. Single components of an object-oriented program like classes or subsystems are analyzed to determine whether they conform to specific design goals. Concise measurement reports, together with detailed explanations of the obtained values, identify problem spots in system design and give hints for improvement. This allows the designer to measure and evaluate programs at an appropriate level of abstraction. This paper details the use of the multi-metrics approach for the design and improvement of a framework for industry and its use for graphical applications. Multi-metrics tools were used with several versions of the framework. The measurement results were used in design reviews to quantify the effects of efforts to reorganize the framework. The results showed that this approach was very effective at giving good feedback, even to very experienced software developers. It helped them to improve their software and to create stable system

designs.

[185] Ernst, D. and F. Houdek. 'Applying metrics to cross-technical evaluations', in Proc. European Software Measurement Conference. FESMA 98. Technologisch Instituut Vzw, Antwerpen, Germany: 1998.

Keywords: Emp

Abstract: Metrics form an essential element within empirical investigations. But selecting appropriate metrics is difficult, even with goal-driven approaches such as GQM. We performed a cross-technical evaluation comparing structured and object-oriented methods for the development of embedded systems. Thereby we used a broad range of different metrics. In this paper, we describe our observations made when using different kinds of metrics and give suggestions for selecting metrics within cross-technical evaluations.

[186] Etzkorn, L., J. Bansiya, et al., 'Design and code complexity metrics for OO classes', Joop, 12(1), pp35-40, 1999.

Keywords: Des, Prod, Emp

Abstract: We examine the implementation and usage of various OO code and design complexity metrics. We introduce a new OO code metric, Average Method Complexity (AMC), that measures certain aspects of code complexity not handled by current code complexity metrics. We also discuss a new OO design metric, called Class Design Entropy (CDE), that uses the information content of a class as a measure of complexity. Over a set of C++ classes, we compare the complexity determinations of several OO code and design metrics to the complexity ratings of a team of highly trained C++ experts. Finally, we discuss some of the measurement differences between OO design metrics and OO complexity metrics.

[187] Etzkorn, L., C. Davis, et al., 'A practical look at the lack of cohesion in methods metric', Joop, 11(5), pp27-34, 1998.

Keywords: Des, Prod

Abstract: Software metrics for the procedural software development paradigm have been extensively studied. Metrics such as McCabe's (1976) cyclomatic-complexity metric and Halstead's (1977) Software Science metrics are well known and frequently used to measure software complexity in the procedural paradigm. More recently, software metrics that are tailored to the measurement of design complexity in the object-oriented paradigm have been developed. Chidamber and Kemerer (1991) proposed a draft suite of software metrics for object-oriented software that included six object-oriented design metrics based on measurement theory. This suite of metrics included depth of the inheritance tree (DIT), number of children (NOC), coupling between objects (CBO), response for a class (RFC), weighted methods per class (WMC), and lack of cohesion of methods (LCOM). The LCOM metric has been subject to multiple interpretations that can greatly influence the LCOM value derived for a particular class. This article compares and analyzes the definition and implementation variations of the LCOM metric, and provides an assessment of this metric.

[188] Etzkorn, L. H. and C. G. Davis, 'Automated object-oriented reusable component identification', Knowledge Based Systems, 9(8), pp517-524, 1996.

Keywords: Tool, Maint, Reuse

Abstract: An automated tool to assist in the understanding of legacy code can be useful both in the areas of software reuse and software maintenance. Most previous work in this area has concentrated on functionally-oriented code. Whereas object-oriented code has been shown to be inherently more reusable than functionally-oriented code, in many cases the eventual reuse of the object-oriented code was not considered during development. The paper describes an approach that makes preparing existing object-oriented code for reuse easier and more quantifiable. This problem includes two primary sub-problems: understanding the function of components, and applying an appropriate set of metrics to the components to quantify reusability. The research described in the paper addresses an approach to the automated understanding of object-oriented code. A knowledge-based system that implements the approach is described. The paper also briefly discusses the formulation of reusability metrics for object-oriented code.

[189] Etzkorn, L. H., C. G. Davis, et al. 'The program analysis tool for reuse: identifying reusable components', in Proc. FLAIRS-98. Proceedings of the Eleventh International Florida Artificial Intelligence Research Symposium Conference. AAAI Press, Menlo Park, CA, USA, 1998.

Keywords: Tool, Reuse

Abstract: Software reuse has been demonstrated to increase productivity, reduce costs, and improve software quality. The research that has addressed this problem has concentrated on code created in the functional domain. However, in recent years much object-oriented code has been developed. In many cases eventual reuse of the code was not considered in the software development process, and so even though the object-oriented paradigm tends to result in more reusable code than that developed in the functional decomposition paradigm, the code itself was not specifically designed for reuse. An approach for the automated identification of reusable components in object-oriented legacy code is presented in this paper. This approach includes a natural language processing, knowledge-based tool for the identification of components reusable in a chosen domain. It also includes a reusability metrics tool that uses low level OO metrics to determine high level reusability quality factors in order to quantify the reusability of OO components.

[190] Evanco, W. M. 'Poisson models for subprogram defect analyses', in Proc. Achieving Quality in Software. Proceedings of the Third International Conference on Achieving Quality in Software. Chapman & Hall, London, UK, 1996.

Keywords: Maint, Theory

Abstract: A wide variety of metrics characterizing software and the software development process have been identified in the research literature. Of particular interest are measures of software complexity, many of which have been related to software quality factors such as reliability or maintainability. For Ada systems, the hierarchy of subprograms composes a layered virtual machine within an object-based framework. Poisson analyses are proposed for the identification of the determinants of defects in these subprograms. Software complexity (measured during design or implementation) as well as characteristics of the software development environment influence the number of defects identified during the testing phase. The Poisson models are calibrated on the basis of measures extracted from the code of Ada projects and data from software change reports. One of the models is used to estimate defects at the subprogram and project levels for the calibration data, and these estimates are then compared to the actual defects. To demonstrate cross-language applicability, defect predictions are made at the subsystem level for a project coded in the C programming language and compared to the actual subsystem defects. Notable results from the analysis are that extensively modified reused subprograms (>25% changed) have substantially more defects than new code of otherwise comparable characteristics and that software development environment volatility (as measured by non-defect changes per thousand source lines of code) is a strong determinant of subprogram defects.

[191] Fatah, A., An iterative model for estimating development effort of object oriented software. , IBM Australian Programming Centre, 1994.

Keywords: Des, Size

Abstract: Martin West provided me with the following description: "Discusses limitations with current estimation models; the effects of non-functional requirements; effects of the development environment. Proposes using complexity measures instead of LOC as the basis for estimation. Defines class complexity = Static complexity(SC) + Dynamic complexity(DC) + Functional complexity(FC). DC = f(#Attributes, #relationships), DC = f(#states), FC = f(#functions, complexity of the function). Estimation is performed at three stages, requirements specification, analysis, and design. Uses Boehm/Laranjeira confidence level model ([Laranjeira, 1990]): Estimate * ( 1 + exp(-Bn) ) <= Actual <= Estimate / ( 1 + exp(-Bn) ), where B is a measure of the competency of the organisation (0.1 = Low, 1.0 = High)."

Notes: Ahmed Fatah is at afattah@vnet.ibm.com.

[192] Fayad, M. E. and M. Fulghum, Object-oriented Experiences. SIGS Books: New York, 1996.

Keywords: Man, Rev

Abstract: Addresses issues to do with take-up of OO, including the learning curve.

[193] Fenton, N. E., S. L. Pfleeger, et al., 'Science and substance: a challenge to software engineers', IEEE Software, 11(July), pp86-95, 1994.

Keywords: Rev, Theory

Abstract: The challenge is to provide rigorous empirical evidence for or against the uptake of new software technologies. OO is one of those considered and the state of play in evaluating the benefits of OO is summarised, using 5 criteria proposed by the authors: (1) empirical evaluation has been performed; (2) real situations have been assessed; (3) appropriate measures have been chosen relative to experimental goals; (4) the time scales of experiments have been realistic; but (5) experimental design has often been questionable.

[194] Fetcke, T., A. Abran, et al. 'Mapping the OO-Jacobson Approach into Function Point Analysis', in Proc. TOOLS USA 97: Technology of Object-Oriented Languages and Systems. Santa Barbara, California: 1997.

Keywords: Size, Man

Abstract: Function Point Analysis measures user requested functionality independent of the technology used for implementation. Software applications are represented in an abstract model that contains the items that contribute to the functional size. When Function Point Analysis is applied to object-oriented software, the concepts of the development method have to be mapped into that abstract model.

This article proposes a mapping of the use case driven Object-Oriented Software Engineering method by Jacobson et al. into the abstract Function Point model. The mapping has been formulated as a small set of concise rules that support the actual measurement process. Our work demonstrates the applicability of Function Point Analysis as a measure of functional software size to the OO-Jacobson approach. This supports

the thesis that Function Point Analysis measures independent of the technology used for implementation and that it can be used in the object-oriented paradigm.

Notes: This paper is available electronically from:http://www.cs.tu-berlin.de/~fetcke/publications.htmlor from the Software Engineering Management Research Laboratory: http://saturne.info.uqam.ca/Labo_Recherche/lrgl.html

[195] Fiedler, S. P., 'Object-oriented unit testing', Hewlett-Packard Journal, (April), 1989.

Keywords: C++, Ind, Test

Abstract: "A small case study on testing C++ objects" [Hoffman, 1995].

[196] Fioravanti, F., P. Nesi, et al. 'Assessment of system evolution through characterization', in Proc. Proceedings of the 1998 International Conference on Software Engineering. IEEE Comput. Soc, Los Alamitos, CA, USA, 1998.

Keywords: Qual, Emp, Prod

Abstract: Owing to the growing diffusion of the object-oriented paradigm and the need to keep the process of software development under control, industries are looking for metrics/indicators capable of evaluating system evolution to control quality, reusability, maintainability, etc. Some new metrics are proposed for monitoring system development and maintenance. These metrics are used with a set of histograms to give a clear characterization of the system under development. Histograms call be profitably used to detect critical conditions during the system life-cycle. The semantics of these histograms has been validated against several projects: an example is also reported.

[197] Fioravanti, F., P. Nesi, et al. 'A Tool for Process and Product Assessment and C++ Application', in Proc. 2nd Intl. Conf. on Software Maintenance and Reengineering (CSMR98). Florence: 1998.

Keywords: C++, Tool, Maint

Abstract: The present diffusion of the object-oriented paradigm and of the techniques for maintaining under control the development process must be supported by suitable tools. These tools should be based on confident and validated object-oriented metrics for assessing the several aspects of product and process development: effort, maintainability, re-usability, etc, as well as they should be capable of supporting the definition of specific metrics, profiles and histograms. These are useful to give the developers and managers an immediate representation of the system status. These tools must also provide metrics suitable for producing confident results since the early phases of the development life cycle. Mechanisms for metrics definition, validation and tuning must be available in order to establish a process of continuous improvement. This paper presents TAC++ (Tool for Analyzing C++ Code) which supports all mentioned features and includes the most important metrics presented in the literature and many others.

[198] Fitzpatrick, J., 'Applying the ABC Metric to C, C++, and Java', C++ Report, , 1997.

Keywords: C++, Java, Prod

[199] Frakes, W. B. and C. J. Fox, 'Sixteen questions about software reuse', Commun. ACM, 38(6), pp75-87, 112, 1995.

Keywords: C++, Reuse, Small, Emp, Ind

Abstract: Report on a survey carried out in 1991-92 with 113 respondents from 29 different organisations (28 US, 1 Europe). The main languages of respondents were C, FORTRAN, Pascal, Ada, in that order. Given this and the age of the survey the OO impact is not high. However, there is a comparison of different programming methods with median respondent rankings for perceived value with Booch scoring 3 out of 5 (somewhat valuable) compared to 4 for FORTRAN libraries and X Widgets. Interestingly, there was no significant correlation between language used and amount of reuse, except that PL/1 seemed negatively correlated. Languages without significant impact on reuse were C++, Ada and Smalltalk.

Notes: William Frakes is at frakes@sarvis.cs.vt.edu, last known for Christopher Fox is fox@mutt.cs.jmu.edu.

[200] Frakes, W. B., D. J. Lubinsky, et al., 'Experimental evaluation of a test coverage analyzer for C and C++', J. Systems Software, 16, pp135-139, 1991.

Keywords: C++, Emp, Test, Tool

Abstract: Experiments tested the effectiveness of nvcc, a test coverage analyzer for C and C++. Subjects were professional programmers and systems analysts at AT&T Bell Laboratories. Results indicate that using nvcc will result in a higher level of test coverage for a given testing time, allow testers to reach a given coverage level at least 40% faster, and reduce variability in level of coverage reached by different testers. Use of nvcc did not significantly increase the number of bugs found. All subjects surveyed said they found nvcc to be a useful tool. Results also suggest that the effectiveness of nvcc may be related to users' software engineering experience." Sadly, this paper does not compare effectiveness for C with C++. In fact, the 2 experiments reported on were both academic studies (although the subjects were professionals) and applied only to C code taken from the UNIX system. The experiments are interesting but it is up to the reader to decide how much of it relates to the OO paradigm.

[201] Fugate, C. S. and G. Teologlou. 'Estimating the cost of object oriented programming', in Proc. European Software Cost Modelling Conference. Ivrea, Italy: 1994.

Keywords: Size

Notes: The metrics seem somewhat doubtful due to the apparent poor understanding of OO and opaque counting rules.

[202] Gannon, J. D., E. E. Katz, et al., 'Metrics for Ada packages: an initial study', Communications of the A.C.M., 29(7), pp616-623, 1986.

Keywords: Des, Prod

[203] Gillibrand, D. and K. Liu, 'Quality Metrics for Object-Oriented Design', Journal of Object-Oriented Programming, 10(8), pp56-59, 1998.

Keywords: Qual

Abstract: The authors focus on OO software design, particularly to the issue of quality. There have been some studies on metrics for OO design. The most representative ones are by Chidamber and Kemerer (1991) and Chen and Lu (1992). The article tackles design quality from the angle of the result of an OO design. It addresses some major criteria for a quality OO design; and seeks to map OO metrics to quality factors such as reliability, complexity, and reusability.

[204] Godin, R., H. Mili, et al., 'Design of class hierarchies based on concept (Galois) lattices', Theory and Practice of Object Systems, 4(2), pp117-134, 1998.

Keywords: Tool, Qual

Abstract: Building and maintaining the class hierarchy has been recognized as an important but one of the most difficult activities of object-oriented design. Concept (or Galois) lattices and related structures are presented as a framework for dealing with the design and maintenance of class hierarchies. Because the design of class hierarchies is inherently an iterative and incremental process, we designed incremental algorithms that update existing Galois lattices as the result of adding, removing, or modifying class specifications. A prototype tool incorporating this and other algorithms has been developed as part of the IGLOO project, which is a large object oriented software engineering joint research project involving academic and industrial partners. The tool can generate either the concept lattice or several variant structures incrementally by incorporating new classes one by one. The resulting hierarchies can be interactively explored and refined using a graphical browser. In addition, several metrics are computed to help evaluating the quality of the hierarchies. Experiments are presented to better assess the applicability of the approach.

[205] Gowda, R. G. and L. E. Winslow. 'An approach for deriving object-oriented metrics', in Proc. Natl. Aerospace & Electronics Conference. Dayton, OH: IEEE, 1994.

Keywords: Des

Abstract: The object-oriented approach is gaining wider acceptance in the software engineering community as an alternative to structured design methodologies. The major disadvantage of structured methodologies is the discontinuity between analysis, design, and implementation phases. In object-oriented approach this problem has been taken care of as the same concepts have been extended to all the phases of software development. However, some of the common software engineering tools of structured methodologies, such as metrics, are poorly developed for object oriented designs. Software metrics help analysts, designers, programmers, and managers to comprehend software development processes and assess the system complexity. It will help managers in revising their estimates and plans for systems development. In this paper we propose a set of metrics for object-oriented analysis and design efforts.

Notes: This paper argues that the metrics that can be collected depend upon the type of OO method employed. This is illustrated by examining OMT (Rumbaugh et al.) and responsibility driven design (Wirfs-Brock et al.). The work lacks focus: why are we measuring?

[206] Graham, I., Migrating to Object Technology. Addison-Wesley: 1995.

Keywords: Des, Size, Rev, Test

Abstract: Chapter 10 covers metrics (including the SOMA metrics), estimation and testing.

[207] Graham, I. 'Progress With Object-Oriented Metrics', in Proc. Object Expo Europe. London: 1995.

Keywords: Prod, Size

Abstract: As object-oriented (OO) development practices mature and are more widely adopted in industry and commerce, it becomes apparent that measurement of software products and processes must be taken seriously. Further, it is increasingly obvious to most practitioners that traditional approaches to software metrics work poorly, if at all. There have been a number of suggestions for suites of metrics for genuinely OO development. Some are founded on a theoretical basis, while others are derived entirely empirically. Unfortunately, most of the former contain theoretical errors and the latter are clearly rather arbitrary. In this paper, we report on recent work that has resulted in the correction of some errors and the synthesis of a suite of more practical and theoretically-sound OO metrics. We also report on a recent collaborative initiative in the area of project estimation and on a fairly novel metric with the potential to replace function points and which can be collected automatically.

[208] Graham, I., 'Making Progress in Metrics', Object Magazine, 6(8), pp68-73, 1996.

Keywords: Rev, Size

Abstract: The article focuses on task-point analysis, estimating the basis of the business task points in a requirements definition: the number of atomic tasks the system helps users to do. One of the many benefits is that the estimation is carried out at the requirements-capture stage of the lifecycle-early enough to assist in project justification and estimation. Also, business task points at the requirements-definition stage do not presuppose any particular delivery vehicle or strategy. The article reports on a new industrial collaboration: the International Object-Oriented Metrics Club (IOMeC), which aims to produce an estimating model based on task points. Before defining task points, describing a case study, and giving details of lOMeC the author reviews the state of the art in the field of object-oriented metrics and offers a new synthesis.

Notes: Includes a critique of CK metrics.

[209] Grechenig, T. and S. Biffl. 'A flexible generator for code measuring tools providing reusability for metric descriptions', in Proc. TOULOSE '92. Fifth International Conference. Software Engineering and Its Applications. EC2, Nanterre, France, 1992.

Keywords: Tool, C++, Man

Abstract: Quantitative evaluation of software systems has not proved widely successful in practice. In particular, code metrics have not been accepted by practitioners. Among several other reasons which are enumerated in this paper the authors found that this was largely due to lack of flexibility and usability of code measuring tools. This paper deals with a system that generates software measuring tools. It provides a clear separation of language and metric description, helping to make both components reusable. Languages are defined in EBNF, metrics are defined as C-functions (events) which are triggered during parsing. Most classical code metrics have been implemented for the languages Modula-2, Pascal, Chill, C, object-oriented Pascal and C++. These implementations affirmed the hypotheses of flexibility and usability. Nevertheless, the authors regard quantitative code analysis as only one means of code quality assurance among other activities. Therefore they outline an empirical cycle serving the purpose of matching metrics and project constraints, which in this way articulates the actual practical application of the generator. Software metric analyzing tools can work in practice if they are adapted to the local constraints of the development environment.

[210] Halladay, S. and M. Wiebel, Object-oriented Software Engineering. R&D Publications Inc. (distributed by Prentice Hall): 1993.

Keywords: Des, Size, Rev

Abstract: Chapter 8 covers reuse and planning metrics briefly.

Notes: The book has been favourably reviewed by Brian Henderson-Sellers in Object Oriented Systems, 1 (1) 1994, 89-90.

[211] Hamilton, J. 'Metrics: where things went wrong', in Proc. OOPSLA `93 Workshop on Processes and Metrics for Object Oriented Software Development. Washington DC: 1993.

Keywords: Ind

Abstract: Not necessarily available as a paper. However, see the Workshop Report: [Bilow, 1993]. The following is taken from that report: "Perhaps the most deeply revealing story of the day came from Jerry Hamilton who summed up the misuse of metrics through practical example. Jerry's is the story of 'last minute metrics' and the result that unsubstantiated metrics can have on a project."

[212] Hamza, M., B. Lees, et al. 'The Extension of Software Metrics in Object-Oriented Development', in Proc. Proceedings 3rd International Conference on Software Quality Management. Seville, Spain: 1995.

Keywords: Qual

Abstract: Whilst some traditional software metrics are applicable to object-oriented technology, these need to be supplemented by additional metrics directed at the particular features of object-oriented software. An investigation is described in which, having identified a set of software metrics relating to object-oriented software development, the aim is to apply these metrics using Quality Function Deployment (QFD), supported by Case Based Reasoning (CBR), in different software cases, thus incrementally building up, over time in a case library, a collection of different cases, relating to various functional characteristics of developed software. It is believed that CBR may be effective in establishing the relationships between the criteria and the metrics in new software development cases. Metrics for assessing object-oriented systems are introduced. The combination of QFD and BDR methods in providing support during the formulation of customer requirements and in the assurance of software quality, is explored through a proposed model, establishing a relationship between software quality metrics and the software quality criteria of QFD.

[213] Hanson, E. N., T. M. Harvey, et al., 'Experiences in DBMS implementation using an object-oriented persistent programming languages and a database toolkit', SIGPLAN Notices (OOPSLA'91), 26(11), pp314-328, 1991.

Keywords: C++, Ind, Emp

Abstract: From the text: "It is hard to make a precise comparison, but it appears that a savings of somewhere between 25 to 50% in the amount of code written can be achieved using object-oriented programming in E (or C++) relative to using C to implement a DBMS." Also deals with performance issues.

[214] Harmon, P. and D. A. Taylor, Objects in Action. Commercial Applications of Object-Oriented Technologies. Addison-Wesley: 1993.

Keywords: Ind, Man

Abstract: From the publisher's blurb: "In conjunction with the 1992 Object World conference, Object Management Group (OMG) and ComputerWorld magazine had a contest, challenging companies to submit a short case study of how they had successfully put object-oriented technology to work. There were more than 225 entries, and the judges — two of which were Paul Harmon and David Taylor — selected five winners. The quality of the entries prompted Harmon and Taylor to share these impressive activities with a larger audience, and the top 20 entries form the basis for Objects in Action. "

[215] Harrison, R., Metrics for Object-Oriented Systems. , Dept. of Electronics and Computer Science, University of Southampton, UK, 1995.

[216] Harrison, R. 'An assessment of the impact of Inheritance on the Maintainability of Object-Oriented Systems', in Proc. WESS '97. Bari, Italy: 1997.

Keywords: Maint, Emp

Abstract: In this paper, we describe the empirical evaluation of three object-oriented systems. Results from our analysis together with other recent investigations seem to support the thesis that inheritance is neither widely used nor understood; we discuss why this might be the case. It is also not clear that systems using inheritance will be highly maintainable; further research is badly needed in this area. Empirical evaluation of the use of inheritance is a starting point in determining the rael extent of its use, its benefits and drawbacks, and how it impacts on features of software such as maintainability. We give some suggestions for future directions and approaches to empirical evaluation of the impact of OO features such as inheritance on the quality of systems.

[217] Harrison, R., S. Counsell, et al. 'An overview of object-oriented design metrics', in Proc. Eighth IEEE International Workshop on Software Technology and Engineering Practice incorporating Computer Aided Software Engineering. IEEE Comput. Soc, Los Alamitos, CA, USA, 1997.

Keywords: Rev

Abstract: In this paper, we examine the current state in the field of object-oriented design metrices. We describe three sets of currently available metrics suites, namely, those of Chidamber and Kemerer (1993), Lorenze and Kidd (1994) and Abreu (1995). We consider the important features of each set, and assess the appropriateness and usefulness of each in evaluating the design of object-oriented systems. As a result, we identify problems common to all three sets of metrices, allowing us to suggest possible improvements in this area.

[218] Harrison, R., S. Counsell, et al. 'Coupling metrics for object-oriented design', in Proc. 5th Intl. Metrics Symp. Bethesda, MD: IEEE Computer Society, 1998.

Keywords: Emp, Des

Abstract: We describe and evaluate some recently innovated coupling metrics for object-oriented (OO) design. The Coupling Between Objects (CBO) metric of Chidamber and Kemerer (1991) is evaluated empirically using five OO systems, and compared with an alternative OO design metric called SAS, which measures the number of associations between a class and its peers. The NAS metric is directly collectible from design documents such as the Object Model of OMT. Results from all systems studied indicate a strong relationship between CBO and NAS, suggesting that they are not orthogonal. We hypothesised that coupling would be related to understandability, the number of errors and error density. So relationships were found for any of the systems between class understandability and coupling. Only limited evidence was found to support our hypothesis linking increased coupling to increased error density. The work described in this paper is part of the `Metrics for OO Programming Systems' (MOOPS) project, which aims to evaluate existing OO metrics, and to innovate and evaluate new OO analysis and design metrics, aimed specifically at the early stages of development.

Notes: An empirical analysis of a systems ranging from approximately 2.5 KLOC to 123 KLOC. The dependent variables are software understandability, number of defects and defect density. No strong relationships were found between the proposed metrics and the dependent variables.

[219] Harrison, R., S. J. Counsell, et al. 'Empirical assessment of object-oriented design metrics', in Proc. Empirical Aspects of Software Engineering. Univ. of Keele, UK: 1997.

Keywords: Emp, Prod

[220] Harrison, R., S. J. Counsell, et al., 'An Evaluation of the MOOD Set of Object-Oriented Software Metrics', IEEE Transactions on Software Engineering, 24(6), pp491-496, 1998.

Keywords: Emp, Des

Abstract: This paper describes the results of an investigation into a set of metrics for object-oriented design, called the MOOD metrics. The merits of each of the six MOOD metrics is discussed from a measurement theory viewpoint, taking into account the recognized object-oriented features which they were intended to measure: encapsulation, inheritance, coupling, and polymorphism. Empirical data, collected from three different application domains, is then analyzed using the MOOD metrics, to support this theoretical validation. Results show that (with appropriate changes to remove existing problematic discontinuities) the metrics could be used to provide an overall assessment of a software system, which may be helpful to managers of software development projects. However, further empirical studies are needed before these results can be generalized.

Notes: Looks at the Abreu set of MOOD metrics and uses them to analyse some in house software. Notes little use of inheritance (MIF and AIF).

[221] Harrison, R., S. J. Counsell, et al., 'An investigation into the applicability and validity of object-oriented design metrics', Empirical Software Engineering, 3(3), pp255-273, 1998.

Keywords: Emp

Abstract: We consider empirical evidence in support of a set of object-oriented software metrics. In particular, we look at the object oriented design metrics of Chidamber and Kemerer (1991), and their applicability in different application domains. We briefly describe the metrics, and present our empirical findings, arising from our analysis of systems taken from a number of different application domains. Our investigations have

led us to conclude that a subset of the metrics can be of great value to software developers, maintainers and project managers.

[222] Harrison, R. and R. Nithi. 'An empirical evaluation of object-oriented design metrics', in Proc. OOPSLA'96 - workshop: OO product metrics. 1996.

Keywords: Emp, Prod

Abstract: Paper attempting some empirical validation of the CK metrics. The work is done using 3 versions of the same non-industrial system.

[223] Harrison, R., R. Nithi, et al. 'An empirical study of a software maintenance process', in Proc. 5th Software Quality Conference. University of Abertay, Dundee, UK: 1996.

Keywords: Emp, Maint, C++

Abstract: The paper describes how a process support tool is used to collect metrics about a major upgrade to our own electronic retail system. An incremental prototyping lifecycle is adopted in which each increment is categorised by an effort type and a project component. Effort types are: Acquire, Build, Comprehend and Design and span all phases of development. Project components include data models and process models expressed in an OO modelling language and process algebra respectively, as well as C++ classes and function templates and build components including source files and data files. This categorisation is independent of incremental prototyping and equally applicable to other software lifecycles. The process support tool (PWI) is responsible for ensuring the consistency between the models and the C++ source. It also supports the interaction between multiple developers and multiple metric collectors. The first two releases of the retailing software are available for ftp from oracle.ecs.saton.ac.uk in directory pub/peter. Readers are invited to use the software and apply their own metrics as appropriate.

[224] Harrison, R. and L. G. Samaraweera, 'Using test case metrics to predict code quality and effort', Software Engineering Notes, 21(5), pp78-88, 1996.

Keywords: Test, Qual, Size

Abstract: We report on an investigation into the use of a design metric (the number of test cases) to predict code quality, development and testing time during the production of functional and object-oriented programs. We report on whether a significant difference exists in the number of test cases for equivalent functional and object-oriented programs as well as determining whether these test case metrics are correlated with various development and design metrics for the different paradigms. The results of this investigation suggest that test case metrics could be used both as indicators of code quality and to predict the development and testing effort required for functional and object-oriented programs.

[225] Harrison, R., L. G. Samaraweera, et al., Comparing programming paradigms: an evaluation of functional and object-oriented programs. Internal Report , Dept. of Electronics and Computer Science, University of Southampton, UK, 1994.

Keywords: Emp, C++, Prod

Abstract: Results of the EFOOL project comparing external and internal measures for code developed in C++

and SML.

Notes: The report is available via ftp from: ftp://oracle.ecs.soton.ac.uk/pub/efoop/Papers/report3b.ps. Rachel Harrison's email is rh@ecs.soton.ac.uk.

[226] Harrison, R., L. G. Samaraweera, et al., An evaluation of code metrics for object-oriented programs. Internal Report , Dept. of Electronics and Computer Science, University of Southampton, UK, 1994.

Keywords: Emp

[227] Harrison, R., L. G. Samaraweera, et al., 'An evaluation of Code Metrics for Object-Oriented Programs', Information and Software Technology, 38(7), pp443-450, 1996.

Keywords: Emp, Prod

Abstract: The paper reports on the preliminary results of an investigation into the quality of programs written using different programming paradigms. In particular, the project aims to provide a quantitative analysis of the object-oriented and functional paradigms. We report on the first stage of the project, the evaluation of a number of suggested indicators to determine whether or not they are correlated with the quality of object-oriented programs. Quality is assumed to be measured by the number of known errors encountered and the number of modification requests made during development, testing and maintenance, the times taken to attend to these and a subjective assessment of program complexity. We found that two of the suggested code metrics (the number of non-comment source lines and the number of function declarations) were strongly correlated with these measures of quality.

[228] Hassan, J. A. 'Measuring object oriented systems', in Proc. BCS Specialist Group on Object-Oriented Programming Meeting on Managing Object Technology Projects. IBM South Bank, London: 1993.

Keywords: Size

Notes: slides only

[229] Hatton, L., Safer C: Developing Software for High-integrity and Safety-critical Systems. McGraw-Hill: London, 1994.

Keywords: C++, Emp, Rev, Tool

Abstract: Les Hatton's company Programming Research developed and markets the tool QA C++, which, I am told, implements the MOOSE metrics of [Chidamber, 1993, "MOOSE: Metrics for Object Oriented Software Engineering"]. There is not much specifically about C++ in this book but there are lists of everything and some of these include C++ (e.g. incompatibilities between C and C++, reuse ratios for the QA range of tools).

Notes: PR Ltd is at Glenbrook House, 1/11 Molesy Road, Hersham, Surrey KT12 4RH, UK, tel: +44 (0) 1932 88 80 80, fax: +44 (0) 1932 88 80 81. Les Hatton can be contacted at lesh@oakcomp.demon.co.uk.

[230] Hatton, L., Automated incremental improvement of software product quality: a case history, in Software

Quality Assurance and Measurement: a Worldwide Perspective, N. E. Fenton, R. W. Whitty and Y. Iizuke, Editors, International Thomson Computer Press: London. UK, 1995.

Keywords: C++, Ind, Qual, Reuse

Abstract: Contains some reuse statistics from the development of the QA range of tools (see [Hatton, 1994]), approx. 220K LOC of which about 20% is C++.

[231] Hatton, L., 'Does OO sync with how we think?', IEEE Software, 15(3), pp46-54, 1998.

Keywords: Emp, Man, C++

Notes: Argues that there is little evidence to support the claims made by OO proponents. The paper describes two comparable systems, one in C and one in C++ and reveals that the C++ system contained more defects which took longer to remove. Richard Weiner in a following article suggests that these are problems relating to C++ rather than the paradigm. Clearly more studies are required although it must be stated that C++ is a very common language.

[232] Haynes, P. and B. Henderson-Sellers, 'Bringing OO projects under control: an output-, cash-, and time-driven approach', American Programmer, 10(11), pp23-31, 1997.

Keywords: Man

Abstract: Given the inherent complexity of software development, software measurement personnel face the challenge of translating disparate and often highly technical software measures into simple output, cost and time performance indicators. This article describes how managers and software developers can bring object-oriented (OO) projects under quantitative control in a way that is easily understood. To date, management of the software process remains a hard problem because its complexities and dynamics have been essentially invisible. As a result, myths, folklore and gut feeling have been the primary mechanisms for understanding and managing the software process. Today's high rate of project failures is testimony to the effectiveness of this approach. History has shown that scientific and engineering approaches can be used to understand and control problems of great complexity. Strong evidence exists that they can do the same for software development. However, in software development, it is people whose properties and actions must be controlled. This implies massive cultural change. Given the difficulty of cultural change, strong pressure needs to be applied to effect this change. For this reason, scientific and engineering outcomes must be tightly integrated to economic outcomes. This linkage must be summarized at a high level so decision makers become empowered to make informed decisions in order to effect this change in a way that reflects the underlying reality of the situation. If this is done, economic pressure can drive organizations' software development processes toward maturity.

[233] Haythorn, W., 'What is Object-Oriented Design', Journal of Object Oriented Programming, (March/April), pp67-78, 1994.

Keywords: Des, Reuse, Maint

Abstract: Haythorn states that design guidelines should be driven by high-level goals e.g. encourage reuse, increase maintainability or improve productivity. He argues that the reuse goal does not lead to guidelines for system design because reuse is a component- level concept. Maintainability is proposed as an better alternative goal for OOD as it is a system level concept, in which the pay back is more visible and within the

time scale of projects. In producing guidelines for maintainability the main problems which occur in maintenance must be considered. The most common problems are custom modifications and adding enhancements. These types of problem usually involve adding new variations of existing objects rather than the replacement of whole objects. To localise the effect of this type of change and hence reduce maintenance effort Haythorn states that the use of polymorphism (usually within an inheritance structure) is essential.He defines three types of design: structured design; object-based design; and object-oriented design. Here object-based designs are distinguished from object-oriented designs because they only use abstract data types and object-oriented designs use inheritance and polymorphism. Haythorn evaluates these three approaches using a typical example. As a maintenance metric he estimates the percentage of the total system which would need to be understood to carry out a list of anticipated changes. The results showed that while the object-based design was little better than functional design, the object-oriented design required around half the maintenance effort. The paper states designing in terms of objects apparent in the problem domain produces object-based systems. To produce an object-oriented design classes must be abstracted from problem domain objects in such a way as to protect us from any anticipated changes. This requires some central classes that are characterised by what they hide and not what they are and in which much of the switching logic is replaced by polymorphic calls. Since classes designed to be robust under change must still be useful when the application in which they were designed changes it's role in it's problem domain or when the problem domain itself changes, they must be capable of being used in different environments. This is also the criteria for reusable classes. This means that by designing for maintainability, which has more immediate pay backs and more easily stated design guidelines, we are also designing for reuse.

Notes: One of the main points made for OO is its real world modelling creating classes which do not appear in the problem domain moves the solution away from the real world problem and hence makes it more difficult to understand.

[234] Heitz, M. and B. Labreuille. 'Design and development of distributed software using Hierarchical Object Oriented Design and Ada', in Proc. Ada in Industry. Proceedings of the Ada-Europe Int. Conf. Munich: Cambridge University Press, Cambridge, England, 1988.

Keywords: Ind, Emp

Abstract: "This paper reports on an Ada pilot project (Jan86 to Sept87) which was conducted for the European Space Agency (ESA) by Cisi-Ingenerie as main contractor and Carlo Gavazzi Space as subcontractor. The main objectives of this study were to provide information on issues of using the Ada technology for the design and implementation of large distributed systems in the context of the Columbus space station program by developing a prototype of an on-board Data Management System (DMS). Results and lessons learnt by applying a virtual node approach together with Hierarchical Object Oriented Design (HOOD) may contribute to a better understanding and management of the use of Ada technology and provide alternative approaches to current practice in the field of large distributed system development. Experimental data gathered over a development of 30 man-months which yielded a 15000 Ada source line system, are given." This data is not much more, however, than the distribution of person-hours between different project phases.

[235] Henderson, R. and B. Zorn, 'A comparison of object-oriented programming in four modern languages', Software Practice and Experience, 24(11), pp1077-1096, 1994.

Keywords: C++, Rev

Abstract: Compares Oberon-2, Modula-3, Sather and Self, for development of a DBMS. Execution times,

program size and compile times are compared, with C++ providing a benchmark.

Notes: Robert Henderson is at robh@cs.indiana.edu, Benjamin Zorn is at zorn@cs.colorado.edu.

[236] Henderson-Sellers, B. 'Some metrics for object-oriented software engineering', in Proc. TOOLS 6. Prentice-Hall, 1991.

Keywords: Prod

Notes: Brian Henderson-Sellers is at brian@saturn.csse.swin.edu.au.

[237] Henderson-Sellers, B. 'Managing and measuring object-oriented information systems development', in Proc. Workshop on Object-Oriented Software Engineering Practice. Denver, CO: 1992.

Keywords: Man

[238] Henderson-Sellers, B., 'The economics of reusing library classes', Journal of Object-Oriented Programming, 6(4), pp43-50, 1993.

Keywords: Des, Man, Reuse

Abstract: Management of a software development project using object-oriented technology requires new insights and procedures; in particular, appropriate metrics that accurately reflect the costs and benefits of class reuse are needed. An economics ROI model is developed and evaluated using a simulation modeling technique. It is shown that for typical unit costs, developing and reusing library classes can be economically justifiable in many cases.

Notes: Builds a simple return on investment (ROI) model of the cost of reuse (= cost of reuse + cost of reuse with modification + cost of new development). Some simulations are run which suggest "class reuse can be beneficial after a small number of projects although the unit costs still need more precise evaluation before hard-and-fast guidelines can be recommended. See also [Kang, 1989], [Kain, 1994].

[239] Henderson-Sellers, B. 'Identifying internal and external characteristics of classes likely to be useful as structural complexity metrics', in Proc. International Conference on Object Oriented Information Systems (OOIS'94). London: Springer-Verlag, London, 1994.

Keywords: Des, Prod

Abstract: Metrics appropriate to object-oriented information systems development are urgently required. As part of an ongoing evaluation of existing OO metrics and the development and validation of new ones, here we systematically consider the various perspectives of an object-oriented system: inside a class, external at the class level, system level, system level relationships and inheritance coupling.

[240] Henderson-Sellers, B., 'Workshop report : pragmatic and theoretical directions on object-oriented software metrics', OOPS Messenger, 5(4), pp78-80, 1994.

Keywords: Rev

[241] Henderson-Sellers, B., 'OO metrics programme', Object Magazine, (October), pp73-79,95, 1995.

Keywords: Man, Theory

Abstract: Object-oriented information systems are becoming increasingly popular in industrial software development environments. Object technology (OT) offers support to deliver products to market more quickly and provide higher-quality products with lower maintenance costs. Managing any development project requires that adequate measurements be taken and used as feedback to construct better strategies and techniques for future projects, initially in the same domain and, after further, more extensive validation, in different domains. As expertise in managing object-oriented (OO) projects grows, such a body of OO metrics knowledge will become increasingly usable across the industry. The paper discusses the important role of object oriented metrics.

Notes: Henderson-Sellers suggests a number of responsibilities for metrics research:1. To clearly define the population and characteristics of the software we wish to measure.2. To devise appropriate measures for these software characteristics together with instruments to measure them.These provide a sound basis for scientific method: data collection and the seeking of patterns (local, empirical, and bottom-up) and, concurrently, the derivation of theories that might have more global applicability (top-down, goal-focused, and external).

Management's use of metrics tie in closely with Capability Maturity Model levels (CMM).

The problem with the GQM approach is that the set of metrics available to help achieve a specific goal, or answer a specific question, may be empty. Thus a complementary activity is that of identifying a large number of 'potentially useful' metrics, independently of specific goals or questions.

The 5 CMM levels reflect not only an organisations level of process maturity but also the type and extent to which a metrics programme might be implementable, sustainable and useful.level 2 - some project metrics but no interchange of information with other parts of the organisation.level 3 - metric are collected for use as feedback to allow the process to be controlled on a quantitative basis.level 5 - metric gathered on process to allow feedback to change the process itself.

A clear distinction is drawn between objective measures which assess internal characteristics, and stochastic measures which assess (in principle) external characteristics. In order to predict external characteristics using measures of internal characteristics a prognostic model (theoretically derived but empirically validated) is required to link the internal and external characteristics. All too often internal characteristics are used as direct surrogates for external characteristics without any intervening model, theory, or identified causality.

Metrics that require subjective assessment are open to question. Metrics with subjective weightings that use Likert scales where mappings from that scale to a numeric scale itself is fuzzy have no scientific validity and should be avoided if at all possible.

There is an interface between the characteristic and a measure of it. This idea of transforming from a real-world scale (an empirical relational system) to a measurement scale as defined by a formal relational system is part of measurement theory.

...tolerance limits are prescribed, and individual components assessed against these standards. Excessive product rejections suggest the process producing them is at fault.

Another, often overlooked, use of metrics is the objective assessment of various competing methodologies, techniques, organisational structures, or work patterns. (Sharble and Cohen).

[242] Henderson-Sellers, B. 'Managing an object-oriented metrics programme', in Proc. Object Expo Europe - Java Expo. SIGS Conferences, Newdigate, UK, 1996.

Keywords: Man

Abstract: Management of any production process is simplified if some measures of progress towards a quality product are collected and analyzed. In introducing a measurement programme for object-oriented software development, a widely recommended framework is the "goal/question/metric" paradigm which relates management goals to technical metrics collection in the context of the SEI maturity level. Common themes underlying successful adoption and management of an OO metrics programme are highlighted including consideration of appropriate measures.

[243] Henderson-Sellers, B., Object-Oriented Metrics: measures of complexity. Prentice Hall: Hemel Hempstead, UK, 1996.

Keywords: Rev

Abstract: Modern and comprehensive treatment. Replaces [Lorenz, 1994] as the standard text book on OO metrics, although the latter may be preferable for the engineer or manager who wants a quick, pro-forma approach to measurement. Review by Martin West: Software Testing, Verification and Reliability, vol. 6 (2/3), 1996

Notes: SBN 0-1323-9872-9

[244] Henderson-Sellers, B. 'Building a metrics programme', in Proc. Object Expo Europe/Java Expo. SIGS Conferences, Newdigate, UK, 1997.

Keywords: Man

Abstract: Management of any production process is simplified if some measures of progress towards a quality product are collected and analyzed. In introducing a measurement programme for object-oriented software development, a widely recommended framework is the "goal/question/metric" paradigm which relates management goals to technical metrics collection in the context of the SEI maturity level. Common themes underlying successful adoption and management of an OO metrics programme are highlighted, including consideration of appropriate measures.

[245] Henderson-Sellers, B., 'Generalization of object-oriented components for reuse', Journal of Object Oriented Programming, 9(2), pp19-31, 1997.

Keywords: Reuse

[246] Henderson-Sellers, B., L. Constantine, et al., 'Coupling and Cohesion (Towards a Valid Metrics Suite for Object-Oriented Analysis and Design)', Object-Oriented Systems, 3(3), pp143-158, 1996.

Keywords: Prod, Theory

Abstract: The best known OO metrics are the suite of six proposed by MIT researchers. Of these six, three have problems in their definitions, one seriously (LCOM or lack of cohesion of methods). Here, this suite of six metrics is evaluated from a mathematical point of view and errors in the definition of CBO (coupling between objects) and LCOM removed. In addition, a totally new formation for the concept of "lack of cohesion" at the method level is proposed. Illustrative examples are used throughout.

[247] Henderson-Sellers, B. and J. Edwards, BOOKTWO of Object-Oriented Knowledge: the Working Object. Prentice Hall: Sydney, Australia, 1994.

Keywords: Des, Qual, Rev

Abstract: Chapter 10 (pp. 461-527) of Brian Henderson-Sellers and Julian Edwards book is the most extensive introduction to software metrics in any OO book I have seen except Lorenz and Kidd, 1994.

[248] Henderson-Sellers, B., S. Moser, et al. 'A proposed multi-dimensional framework for object-oriented metrics', in Proc. 1st Australian Software Metrics Conf. 1993.

Keywords: Prod

[249] Henderson-Sellers, B., D. Tegarden, et al. 'Tutorial: Object-Oriented Metrics', in Proc. TOOLS-Pacific. Sidney, Australia: 1992.

Keywords: Rev

[250] Henderson-Sellers, B., D. Tegarden, et al. 'Tutorial Notes: Metrics for Object-Oriented Software', in Proc. OOPSLA 94. 1994.

Keywords: Rev, Theory

Abstract: Annotation from C. Gibbon

Henderson-Seller's tutorial that walked through the traditional and object- oriented metrics. Attention was paid to the processes and products of software development with a number of metrics scattered throughout. This tutorial focused on the theoretical aspects of metric development.

[251] Henry, S. and M. Humphrey. 'A controlled experiment to evaluate maintainability of object-oriented software', in Proc. IEEE Conf. on Softw. Maint. IEEE Computer Society Press, 1990.

Keywords: Emp, Maint

[252] Henry, S. and J. Lewis, 'Integrating metrics into a large-scale software development environment', J. of Systems & Software, 13(2), pp89-95, 1990.

Keywords: Man

[253] Henry, S. M. and M. Humphrey, Comparison of an object-oriented programming language to a procedural language for effectiveness in program maintenance. Tech. Report No. TR 88-49, Virginia Polytechnic Inst., Dept of Computer Science, 1988.

Keywords: Emp, Maint

Notes: Perhaps an early precursor to [Henry, 1993, "Object-oriented vs. procedural programming languages: effectiveness in program maintenance"]? Sallie Henry is at henry@cs.vt.edu, Mark Lattanzi is at lattanzi@cs.vt.edu.

[254] Henry, S. M. and M. Humphrey, 'Object-oriented vs. procedural programming languages: effectiveness in program maintenance', Journal of Object-Oriented Programming, 6(3), pp41-49, 1993.

Keywords: Emp, Maint

Abstract: Tests the hypothesis that systems designed and implemented in an object-oriented manner are easier to maintain than those using structured design techniques ('easier' meaning less effort to do the maintenance job, in terms of time taken or number of code changes made). The experimental design divided 20 students with little experience of OO into two groups A and B. Group A performed maintenance tasks on C programs and then on Objective-C programs; B did the reverse. The results tended to support the hypothesis.

[255] Henry, S. M. and M. Lettanzi. 'Measurement of software maintenance and reliability in the object oriented paradigm', in Proc. OOPSLA `93 Workshop on Processes and Metrics for Object Oriented Software Development. Washington DC: 1993.

Keywords: Des, Emp, Maint

Abstract: Not necessarily available as a paper. However, see the Workshop Report: [Bilow, 1993]. The following is taken from that report: "The paper describes the results of three studies. One, a study of maintenance difficulty in procedural versus OO software. Two, a relationship between reuse, productivity, and OO techniques. Three, a modification and application of the MOOSE (C&K) metrics for the purpose of predicting maintainability."

[256] Henry, S. M. and W. Li. 'Metrics for object-oriented systems', in Proc. OOPSLA'92 Workshop: Metrics for Object-Oriented Software Development. Vancouver, Canada: 1992.

Keywords: Des, Prod

Notes: See Roberts' report on this workshop [Roberts, 1992].

[257] Henry, S. M. and W. Li. 'Maintenance Metrics for the Object Oriented Paradigm', in Proc. First International Software Metrics Symposium. Baltimore, MD: IEEE Computer Science Press, 1993.

Keywords: Maint, Prod, Emp

Abstract: Annotation form C. Gibbon.

Henry and Li present maintenance metrics for the OO paradigm. They build upon Chidamber's and Kemerer's work and add a few metrics of their own. The metrics target Classic Ada design and source code which is initially parsed by a metric analyser implemented using the UNIX meta-tools yacc and lex with embedded C. The resultant intermediate metric language is acted upon their proposed metrics to produce statistical data which is correlated back to actual data gleaned from the software projects that originally supplied the source code. Interesting use of the two-phase process to first assemble the important objective data in a metric language before assessing it with the actual metrics.

[258] Hericko, M., I. Rozman, et al. 'Tools for OO metrics collection', in Proc. International Conference on Software Quality, ICSQ '97. Drustvo Ekonomistov, Maribor, Slovenia: 1997.

Keywords: Tool, Emp, Prod

Abstract: Our common goal is to make the software development process (not only object-oriented software) an engineering activity. For that, we need the ability to assess the quality of both the development process and the resulting products. We need product as well as process metrics, since successful control requires some means of measurement. However, to become useful, metrics must be collected, analyzed and validated. This paper presents some metrics suitable for object-oriented (OO) software development and tools that automate OO metrics data collection. Some findings based on the collected empirical data are also presented.

[259] Hericko, M., I. Rozman, et al. 'OO metrics data gathering environment', in Proc. Technology of Object-Oriented Languages. TOOLS 24. IEEE Comput. Soc, Los Alamitos, CA, USA, 1998.

Keywords: Tool, Emp

Abstract: Object technology has been recognized as an enabling factor and it is largely introduced into MIS departments. However, the benefits and improvements related to object technology are not obvious and could not be realized and achieved without appropriate evaluation criteria and metrics. The paper presents some evaluation criteria, measures and metrics, suitable for object oriented software development. Basic concepts of the OOMetDaGa Environment that provides automatic support for metrics data gathering are described and some empirical data presented.

[260] Hericko, M., I. Rozman, et al. 'Integration of strategic, tactical and technical OO measurement', in Proc. Software Quality Management VI. Quality Improvement Issues. Springer-Verlag London, London, UK, 1998.

Keywords: Theory, Man

Abstract: For measurement to become cost effective and efficient it should be directed by business goals. Since our goal when introducing object technology is to build better software it is necessary to perform technical OO measurement and relate it not only to tactical but also to strategic goals. We present some concepts of an environment that might help us to integrate and provide compliance between different aspects of OO measurement.

[261] Hiekotter, V., B. Helling, et al., 'Design metrics: an aid to their automatic collection', Information & Software Technology, 32(1), pp79-87, 1990.

Keywords: Des, Tool

[262] Hitz, M. 'Measuring reuse attributes in object-oriented systems', in Proc. OOIS'95. Dublin City University: Springer-Verlag, 1995.

Keywords: Des, Emp, Reuse

Abstract: We demonstrate that measuring reuse in object oriented systems is not as straight forward as it might seem. On the basis of a small example application, we show that object oriented reuse metrics tend to overestimate the "real" reuse in an application and that this problem can partly be overcome by carefully selecting an appropriate definition of the "size" attribute used in many proposed metrics. We also emphasize that it is necessary to distinguish between different flavors of "reuse" in order to achieve consistent measurements.

Notes: This paper is available via ftp: ftp.ifs.univie.ac.at, directory pub/Martin.Hitz, file OOIS95.ps.Z, and on WWW: http://www.pri.univie.ac.at/~hitz/publ.html. Martin Hitz is at hitz@ifs.univie.ac.at.

[263] Hitz, M. and B. Montazeri. 'Measuring coupling and cohesion in object-oriented systems', in Proc. Intl. Symposium on Applied Corporate Computing. Monterrey, Mexico: 1995.

Keywords: Des, Prod

Abstract: As the role that software metrics in general, and coupling in particular, play with respect to maintainability of software products is widely accepted, the paper evaluates current approaches for handling coupling and/or cohesion in object-oriented systems. 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 re-stated by Li and Henry. As a result, we present a graph theoretic improved version of this metric.

[264] Hitz, M. and B. Montazeri. 'Measuring product attributes of object-oriented systems', in Proc. 5th European Software Engineering Conference (ESEC `95). Barcelona, Spain: Springer Verlag 1995, 1995.

Keywords: Prod, Qual

Abstract: The role of internal product attributes for software measures is analyzed. Attributes are classified as 'fundamental', 'auxiliary' and 'useless' with respect to their relevance for controlling software quality. The impact of inappropriate attributes on the usefulness of resulting metrics is discussed with emphasis on the object-oriented paradigm. We demonstrate that some of the obvious shortcomings of proposed metrics are caused by inconsiderate attribute selections. In the course of this discussion which recurs to commonly accepted frameworks in measure theory, both well-known attributes and new proposals are treated.

[265] Hitz, M. and B. Montazeri, 'Chidamber & Kemerer's metrics suite: a measurement theory perspective', IEEE Trans. on Softw. Eng, 22(4), pp267-271, 1996.

Keywords: Theory, Prod, Des

Abstract: The metrics suite for object-oriented design put forward by Chidamber and Kemerer (1994) is partly evaluated by applying principles of measurement theory. Using the object coupling measure (CBO) as an example, it is shown that failing to establish a sound empirical relation system can lead to deficiencies of software metrics. Similarly, for the object-oriented cohesion measure (LCOM) it is pointed out that the issue of empirically testing the representation condition must not be ignored, even if other validation principles are carefully obeyed. As a by-product, an alternative formulation for LCOM is proposed.

[266] Hitz, M. and B. Montazeri, 'Measuring Coupling in Object-Oriented Systems', Object Currents, 1(4), 1996.

Keywords: Prod, Qual

Abstract: "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 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."

Notes: Object Currents is an on-line journal at http://www.sigs.com/objectcurrents/.

[267] Hoffman, D. and P. Strooper, 'The testgraph methodology: automated testing of collection classes', Journal of Object-Oriented Programming, (Nov.-Dec.), 1995.

Keywords: C++, Emp, Test

Abstract: Shows "how testgraphs provide an intuitively appealing method for defining automatically and executing test cases". Some data on size of test drivers and oracles relative to class size are given.

[268] Hopkins, T., Complexity metrics for quality assessment of object-oriented design, in Software Quality Management II, vol. 2: Building Quality into Software, P. M. Ross, C. A. Brebbia, G. Staples and J. Stapleton, Editors, Computational Mechanics Press: 1994.

Keywords: Prod, Reuse

Abstract: The paper considers the use of interface complexity metrics for the quantitative analysis of the quality of software design performed using object-oriented development methods. The techniques considered can be applied before coding is started, as part of the design review process, or when coding is complete. The use of complexity metrics for reusability assessment is also considered.

Notes: Proposes some simple syntactic measures of interface complexity with the aim of addressing robustness (ease of change) and reusibility. Trevor Hopkins is at Manchester University, Oxford Rd, Manchester, M13 9PL, UK, Main tel: (0161) 273-7121.

[269] Hopkins, T. P., 'Do we need object-oriented design metrics?', Hotline on Object-Oriented Technology,

2(8), pp16-17, 1991.

Keywords: Des

[270] Horvilleur, C. and G. Horvilleur. 'Documenting reusable components: an engineering approach', in Proc. Technology of Object-Oriented Languages and Systems TOOLS 5. Proceedings of the Fifth International Conference. Prentice Hall, Engelwood Cliffs, NJ, USA; 1991; viii+485 pp. 1991.

Keywords: Reuse

Abstract: We analyze the possibility of documenting reusable software components, in a manner similar to the one used for their hardware counterparts. We emphasize the importance of measures in order to be able to select the components according to design constraints. On the software side we decided to use Eiffel due to its strong emphasis on reusable software components, software engineering, and documentation. We believe that most of our results can also be generalized to other object oriented programming languages as well. Our concern is to show that a software component can be understood and used, without looking at its source code.

[271] Hsia, P., A. Gupta, et al. 'A study of the effect of architecture on maintainability of object-oriented systems', in Proc. Intl. Conf. on Softw. Maintenance (ICSM'95). Nice, France: IEEE, 1995.

Keywords: Des, Emp, Maint

[272] Hudli, R. V., C. L. Hoskins, et al. 'Software Metrics for Object-Oriented Design', in Proc. IEEE International Conference on Computer Design, VLSI in Computers and Processors. Los Alamitos, CA, USA: IEEE, 1994.

Keywords: Prod, Des

Abstract: In this paper, we discuss software metrics for object-oriented programs. Two kinds of metrics are defined to evaluate the design and implementation. One is class-based, that evaluates design of classes. The second type measures the class design structure of the program. Metrics are defined to evaluate key features of object-oriented design, like encapsulation, inheritance, polymorphism, specialisation of classes, etc. The metrics can "quantify" the design, so that the programmer can evaluate the design.

[273] Huemer, C., G. Kappel, et al., 'Migration in object-oriented database systems - a practical approach', Software Practice and Experience, 25(10), pp1065-1096, 1995.

Keywords: Emp

Abstract: Provides statistics for the migration of an electronic planning board system from ONTOS to ObjectStore. The ObjectStore version, at 39.3 KLOC, was approx. 86% of the size of the ONTOS version. May be useful as a yardstick.

Notes: Heumer is at ch@ifs.univie.ac.at, Kappel is at gerti@ifs.uni-linz.ac.at, Vieweg is at sv@ifs.univie.ac.at.

[274] Huitt, R. 'Metrics for object-oriented software development, Workshop Position Paper', in Proc.

OOPSLA'92 Workshop: Metrics for Object-Oriented Software Development. Vancouver, Canada: 1992.

Notes: See Roberts' report on this workshop [Roberts, 1992].

[275] Humphrey, W., A Discipline for Software Engineering. Vol. ISBN 0-201-54610-8. Addison-Wesley: Reading, MA, 1995.

Keywords: Size, Rev

Abstract: Watts Humphrey's book on personal software process (PSP) improvement. Chapters 5 and 6 present the PROBE method for estimating software size based on object size.

[276] Humphrey, W. S., 'Estimating with Objects Parts I-XI', Object Currents/Object Magazine Online, , 1996.

Keywords: Size

Abstract: A series of articles based on Watts Humphrey's PROBE method for deriving metrics for estimating size and thus effort and using them for planning.

Notes: Parts I-VII can be found at http://www.sigs.com/objectcurrents/. Parts VIII-XI can be found at http://www.sigs.com/omo/. The latter does not give a list of back issues, so search on Watts Humphrey for a list of articles.

[277] IEE, IEE Colloquium on 'Object-oriented development'. No. Digest no. 007, IEE, 1993.

Keywords: Emp, Ind

Abstract: Contains a paper on numbers from two OO developments.

Notes: I don't know who are the authors. Obtainable from Institution of Electrical Engineers, Savoy Place, London, WC2R 0BL UK, tel: +44 (0) 171 240 1871, fax: +44 (0) 171 497 3633.

[278] Iivari, J., Object-oriented information systems analysis: A comparison of six object-oriented analysis methods, in Methods and Associated Tools for the Information Systems Life Cycle, A. A. a. O. Verrijn-Stuart, T.W., Editor, North-Holland: 1994.

Keywords: Des

Abstract: This paper analyses six prominent object-oriented analysis methods using a two-dimensional framework. The first dimension distinguishes three major levels of modelling for an information system: 1) the organizational level, which describes the organizational context of the system, 2) the conceptual/infological level, which includes the model for the universe of discourse underlying the system, the implementation-independent specification of the system and the user interface, and 3) the datalogical/technical level, which defines the implementation-dependent solution for the system. The second dimension distinguishes the structure (data), function (process) and behaviour (control) of the system. The paper analyses whether objects are interpreted as structure, function or behaviour abstractions in the six methods, identifies possible object categories suggested by the method and compares the distinction between

object-oriented analysis and design. It interprets the concepts and notations of the six methods by mapping them according onto the two-dimensional framework and investigates the process of the object-oriented analysis in terms of navigation in the two-dimensional analysis space.

[279] Iivari, J., 'Object-orientation as structural, functional and behavioural modelling: a comparison of six methods for object-oriented analysis', Information and Software Technology, 37(3), pp155-164, 1995.

Keywords: Rev, Des

Abstract: Similar type of study to [Eckert, 1994] and [Sutcliffe, 1991]. Contains 51 refs.

Notes: Juhani Iivari is at jiivari@cs.jyu.fi.

[280] Jacobson, I., M. Christerson, et al., Object-Oriented Software Engineering: A Use Case Driven Approach. ACM Press/Addison-Wesley: Reading, MA, 1992.

Keywords: Rev

Abstract: Chapter 15, Section 7 deals with metrics.

[281] Jensen, R. L. and J. W. Bartley, 'Parametric estimation of programming effort: an object-oriented model', J. Systems and Software, 15(2), pp107-114, 1991.

Keywords: Emp, Size

Abstract: Looks at16 data base projects developed by a group of 5 programmers at Evans and Sutherland Computer Corp. Compares linear and non-linear cost models for these projects and also compares the results with results for function points (from different data sets). The non-linear model performed best. It was found that, in both the linear and non-linear case, a model with one independent variable (no. of objects) performed just as well as models with more variables added.

[282] Johnson, M. A., 'A case study of tracking software development using quality metrics', Software Quality Journal, 4(1), pp15-31, 1995.

Keywords: Man, Qual

[283] Jones, C., 'Backfiring: converting lines of code to function points', IEEE Computer, 28(11), pp87-88, 1995.

Keywords: Size

Abstract: Provides a table of values of ratios of logical source-code statements to function points for various languages. C++ has the values: Low = 30 FP per LOC, Mean = 53, High = 125. Ada83 is 60, 71, 80; Ada 9X is 28, 49, 110; Smalltalk is 15, 21, 40. Jones gives no value for Objective-C in the paper but this is one of a great many other languages on which they collect data.

[284] Jones, C., The economics of object-oriented software. Technical Report , Software Productivity Research, Inc., 1997.

Keywords: Man, Emp

Notes: An MS Word copy may be downloaded http://dec.bournemouth.ac.uk/ESERG/downloads/Capers-economics.rtf

[285] Jones, C., Strengths and weaknesses of software metrics. Technical Report , Software Productivity Research, Inc., 1997.

Keywords: Rev, Man

Notes: An MS Word copy may be downloaded http://dec.bournemouth.ac.uk/ESERG/downloads/Capers-strength.rtf

[286] Jones, J. 'How Logica Projects Measure Up', in Proc. European COCOMO Users Group Meeting. City University, London: 1992.

Keywords: Emp, Size, Ind

Notes: slides only

[287] Judge, T. R. and N. S. Mistry. 'Metrics for estimation', in Proc. Software Quality Management VI. Quality Improvement Issues. Springer-Verlag London, London, UK, 1998.

Keywords: Man, Emp

Abstract: The Metrics in Object Oriented Developments (MOOD) project 21443 is focused on the introduction of metrics to aid estimation on object oriented (OO) projects at Parallax. This is in line with meeting Parallax Solutions' requirement to improve its estimating processes and the requirements of a Process Improvement Experiment (PIE) as defined by the European Systems and Software Initiative (ESSI). Improvement is to be achieved by: the sound application of project metrics to 4 baseline projects; improvement of the whole metric gathering lifecycle; development of metrics that aid the estimation process. This will lead to the business benefit of greater confidence in delivering OO developments on time to the satisfaction of the customer. The project will initially involve a period of study, primarily to review information and material relating to estimation and metrics. The PIE will then enter a cycle of metric development and constant process improvement. This process improvement will be applied on 4 selected OO projects within Parallax. All projects undertaken by Parallax are developed in accordance with the Parallax Delivery Management System (DMS). The estimation process defined in the DMS will be updated to include the recommendations of the project. The PIE will be an iterative experiment constantly applying and reviewing the process and applying changes. Conclusions will then be drawn and reports quantifying the improvements will be completed and presented. The paper presents the findings of the project so far in terms of metrics identified for estimation.

[288] Kaczmarek, J. and M. Kucharski. 'Application of object-oriented metrics for Java programs', in Proc. 10th European Software Control & Metrics Conference. Herstmonceux, England: Shaker Publishing, 1999.

Keywords: Java, Size, Emp

Notes: Describes the results of a static analysis of some Java code.

[289] Kain, J. B., 'Measuring the ROI of reuse', Object Magazine, 4(3), pp48-54, 1994.

Keywords: Man

[290] Kalakota, R. 'The role of complexity in object-oriented systems development', in Proc. 26th Hawaii International Conference on System Sciences. Hawaii: IEEE Computer Society Press, 1993.

Keywords: Des, Prod

Abstract: The authors discuss the underlying principles of the object-oriented paradigm and their impact on software complexity. In order to evaluate the effectiveness of object-oriented methodology it is important to understand and evaluate its impact on software quality and programmer productivity. The authors propose a model where the impact of software complexity on abstract constructs such as software quality and productivity can be studied in object-oriented software development. It is concluded that the underlying concepts of object-oriented computing are sound and reduce complexity if applied correctly.

Notes: Claims that traditional metrics do not readily apply to aspects of the object-oriented paradigm: classes, inheritance, encapsulation and message passing.[RW]

[291] Kamiya, T., S. Kusumoto, et al., 'Empirical evaluation of reuse sensitiveness of complexity metrics', Information and Software Technology, 41(5), pp297-305, 1999.

Keywords: Size, Emp

Abstract: Measuring software products and processes is essential for improving software productivity and quality. In order to evaluate the complexity of object-oriented software, several complexity metrics have been proposed, among them, Chidamber and Kemerer's (1994) metrics are the most well-known for object-oriented software. Their metrics evaluate the complexity of the classes in terms of internal, inheritance, and coupling complexity. Though the reused classes of the class library usually have better quality than the newly-developed ones, their metrics deal with inheritance and coupling complexity in the same way. We first propose a revision of the Chidamber and Kemerer's metrics which can be applied to software which had been constructed by reusing software components. Then, we give an analysis of data collected from the development of object-oriented software using a GUI framework. We compare the original metrics with the revised ones by evaluating the accuracy of estimating the effort to fix faults and show the validity and usefulness of the revised metrics.

[292] Kang, B. K. and J. M. Bieman. 'Inheritance tree shapes and reuse', in Proc. Proceedings. Fourth International Software Metrics Symposium. IEEE Comput. Soc, 1997.

Keywords: Emp, Des, Reuse

Abstract: The shapes of forests of inheritance trees can affect the amount of code reuse in an object-oriented system. Designers can benefit from knowing how structuring decisions affect reuse, so that they can make more optimal decisions. We show that a set of objective measures can classify forests of inheritance trees into

a set of five shape classes. These shape classes determine bounds on reuse measures based on the notion of code savings. The reuse measures impart an ordering on the shape classes that demonstrates that some shapes have more capacity to support reuse through inheritance. An initial empirical study shows that the application of the measures and demonstrates that real inheritance forests can be objectively and automatically classified into one of the five shape classes.

[293] Kang, K. C. and L. S. Levy, 'Software methodology in the harsh light of economics', Information and Software Technology, 31(5), pp239-250, 1989.

Keywords: Man

Abstract: Economic modelling for cost-benefit analysis of software development methods. Includes a section specifically devoted to OO.

[294] Karlsson, E. A., ed. Software Reuse: a Holistic Approach. J. Wiley: Chichester, 1995.

Keywords: Prod, Reuse, Size, Rev

Abstract: Book describing the work of the ESPRIT project REBOOT (REuse Based on Object-Oriented Techniques). Chapter 4 covers measurement of process and product aspects of reuse as well as cost-estimation issues. Listed as one of 101 Key Results of the ESPRIT program, see web site http://www2.cordis.lu/esprit/src/results/pages/infotec/inftec5.htm. Web page for this project, with links to newletters, ftp site etc: http://www.sema.es/projects/SER/reboot.html*/

Notes: ISBN 0-471-95819-0

[295] Karunanithi, S. and J. M. Bieman. 'Candidate reuse metrics for object oriented and Ada software', in Proc. Proc IEEE-CS Int. Software Metrics Symp. Baltimore, MD: IEEE, 1993.

Keywords: Des, Reuse

Abstract: This paper introduces a method for deriving candidate reuse metrics. Bieman and Karunanithi present a set of measurable reuse attributes and a metric suite which quantify these attributes for object-oriented systems. What is novel about their approach is that they introduce the idea of perspectives for reuse. Different reuse attributes are visible when reuse is examined from different perspectives: these include client, server and system. A client is a new system or system component, whereby reuse analysis focuses upon on how a new class reuses existing library classes or other classes. A server is the library or a particular library component, whereby reuse analysis focuses on how a server is being reused by all of the client classes in the system. Finally the system perspective is a view of reuse in the overall system, including clients and servers. The system perspective characterises overall reuse of library classes in the new system. The reuse metrics presented from all perspectives are primitive, but Bieman et al. record a tabular form that allows analysts to tailor their metrics use for a wide variety of goals. Furthermore, they announced at the time of print the current development of a prototypical tool to generate reuse measures and metric tables from Ada programs. Good source for metrics within an object-oriented setting.

Notes: Email bieman@cs.colostate.edu.

[296] Karunanithi, S. and J. M. Bieman, Measuring Software Reuse in Object Oriented Systems and Ada

Software. No. TR CS-93-125, Colorado State University, 1993.

Keywords: Des

Abstract: This is an earlier version of Bieman and Karunanithi's JSS paper [Bieman, 1994, "Measurement of language supported reuse in object oriented and object based software"].

[297] Kauffman, R. and R. Kumar, Modeling estimation expertise in object based CASE environments. , Stern School of Business , New York University, 1993.

Keywords: Size

Notes: See also [Banker, 1991, "Output measurement metrics in an object-oriented computer aided software engineering (CASE) environment: critique, evaluation and proposal"]

[298] Kazman, R., L. Bass, et al., An architectural analysis case study: internet information systems. Internal Paper No. 15213. 2, Carnegie Mellon University, 1995.

Keywords: Des, Qual

Abstract: An extension of [Kazman, 1994] whereby a refinement of the previous analysis of user interface construction systems brings into contention task scenarios. While the emphasis is still on a method for evaluating a system at the architectural level for various non-functional qualities, a requirement of the method is that the non-functional qualities be manifested as task scenarios rather than in the abstract. Hence, modifiable could be interpreted as the ability to `add foo() to the interface', or `amend foo()', etc. A comparison of the WWW, WAIS and Prospero is given and the results defined herein. [CG]

[299] Kazman, R., L. Bass, et al. 'SAAM: A method for analysing the properties of software architectures', in Proc. 16th Intl. Conf. on Softw. Eng. Sorrento, Italy: IEEE Computer Press, 1994.

Keywords: Des, Qual

Abstract: This paper sets about proposing a five-step method for analysing software architectures called SAAM. It presents its own notation for describing architectures, thus providing a common language in which to communicate. Upon opening this channel of understanding amongst disparate architectures, software engineers may proceed to evaluate the quality of them, furthermore to compare and contrast them. Their acknowledge that their work is far from fruition, they have past the first hurdle. That is to analyse, compare and rank architectures. Subsequent work will be geared towards utilising metrics to more precisely evaluate quality attributes in terms of architectures. [CG]

[300] Keyes, J., 'Code trapped between legacy, object worlds', Software Magazine, 12(8), 1992.

Keywords: Man, Emp, Ind

Abstract: "Interest in object technology is high, but IS groups are unable to abandon the investment in legacy systems. Instead, they are trying tools that allow existing code to be 'wrapped'. COBOL proponents are pursuing object-oriented extensions. First Union National Bank used an object interface to a graphical user

interface (GUI) front end." She cites a survey which gives the following percentages for languages used for maintenance (re-engineering): COBOL 65 (51); 4GLs 6 (16); C 4 (7); OO 4 (7); C++ 1 (9); Ada 1 (3).

[301] Keyes, J., 'New metrics needed for new generation', Software Magazine, 12(6), pp42-56, 1992.

Keywords: Man, Qual

Abstract: Jessica Keyes' Software Magazine articles are a good blend of survey data, industrial views and technology. This one contains a short interview with Chris Kemerer and presents his and Chidamber's 6 metrics [Chidamber, 1991] in the context of measurement for quality. Incidentally, she reports on a Quality Assurance Institute survey which says that more than 60% of quality improvement teams do not use metrics to help them improve their processes.

[302] Kim, E. M., O. B. Chang, et al. 'Analysis of metrics for object-oriented program complexity', in Proc. Eighteenth Annual International Computer Software and Applications Conference (COMPSAC 94). IEEE Comput. Soc. Press, Los Alamitos, CA, USA, 1994.

Keywords: Prod, Rev

Abstract: We present a new framework for analyzing the scope of metrics to evaluate complexity of object-oriented programs. In this framework, we examine in detail the metrics from the viewpoint of three key aspects in object-oriented paradigm: syntax complexity, inheritance complexity and interaction complexity. For each key aspect, we expand it to five attributes, which can be calculated qualitatively. Then, we apply our framework to conventional metrics for evaluating complexity of object-oriented programs. The metrics include the ones proposed by S.R. Chidamber and C.F. Kemerer (1991), R.C. Sharble and S.S. Cohen (1993), W. Li and S. Henry (1993), and E. Kim (1993). Finally, we present a new metric which satisfies almost all attributes of the proposed framework.

[303] Kim, E. M., S. H. Jeon, et al., 'A program complexity metric and its evaluation tool for C++ programs', Journal of KISS, 3(6), pp656-665, 1997.

Keywords: Prod, C++, Emp

Abstract: Several metrics have been proposed to evaluate the complexity of object-oriented software products. However, they do not evaluate the main characteristics of object-oriented programs sufficiently, and a concrete procedure to compute their values has not been given. Therefore, it is difficult to use these metrics for evaluating practical software products. In order to analyze the complexity of object-oriented programs, we propose a new metric for computing the program complexity of an object-oriented program. In the metric, we examine the program complexity from three viewpoints in the object-oriented paradigm: syntax, inheritance and interaction. Then, we introduce 15 attributes to evaluate the three viewpoints quantitatively. In this paper, we present heuristics to compute the actual values of the attributes for C++ programs. Then, we analytically evaluate the new metric with regard to Weyuker's (1988) measurement principles. As a result, it is found that our metric satisfies the essential properties which any measure must have. Finally, we develop a tool to compute the values of the attributes automatically and apply it to certain C++ programs.

[304] Kim, E. M., S. Kusumoto, et al. 'Heuristics for computing attribute values of C++ program complexity metrics', in Proc. The Twentieth Annual International Computer Software and Applications Conference (COMPSAC '96). IEEE Comput. Soc. Press, Los Alamitos, CA, USA, 1996.

Keywords: Tool, Prod, Theory

Abstract: We proposed new metrics for computing the program complexity of object oriented programs (E.M. Kim et al., 1994). In these metrics, we examined program complexity from three dimensional viewpoints in object oriented paradigm: syntax dimension, inheritance dimension and interaction dimension. We have defined attributes to evaluate three viewpoints quantitatively. We present some heuristics for computing actual values of the attributes, for which we have given only definitions in a previous paper. Then, we analytically evaluate the new metrics with regard to E.J. Weyuker's (1988) measurement principles. As a result, it is found that our metrics satisfy essential properties which any measure must have. Finally, we develop the tool to compute the values of the attributes automatically.

[305] Kim, K., Y. Shin, et al. 'Complexity measures for object-oriented program based on the entropy', in Proc. 1995 Asia Pacific Software Engineering Conference. IEEE Comput. Soc. Press, Los Alamitos, CA, 1995.

Keywords: Prod, C++, Emp

Abstract: Software metrics are widely advocated as fundamental elements of an engineering approach to planning and controlling software development. They are especially important in object-oriented programming. We propose a new software complexity model which consists of class complexity, inter-object complexity, and the total complexity for the object-oriented program. We measure the complexities based on the entropy concept. The class complexity for a class measures the information flows in a class based on the information passing relationship among member data and member functions. The inter-object complexity for a program measures the information flows between objects. The total complexity for a program is measured by the class complexity and the inter-object complexity. We evaluate the proposed metrics using the complexity properties proposed by Weyuker (1988). Experimental results of C++ classes show the effectiveness of the proposed metrics. We assert that the class complexity and the inter-object complexity are correlated to other metrics for object-oriented concepts.

[306] Kiran, G. A., S. Haripriya, et al. 'Effect of object orientation on maintainability of software', in Proc. International Conference on Software Maintenance. IEEE Comput. Soc, Los Alamitos, CA, USA, 1997.

Keywords: Maint, Emp

Abstract: Maintenance is the set of activities performed after the installation of software. It is well-known that, over the life-time of the software, the maintenance costs can far exceed the development costs. In this paper, we describe an experimental study on the effect of object orientation on maintenance. In particular, we focus on how object orientation fares in maintainability when compared to software designed using function-oriented approaches. For the experiment, a testbed was prepared which consisted of three problems, for each of which the requirement specification, a C implementation and a C++ implementation of an object-oriented design were available. Various maintenance exercises were performed on the the two versions of the projects and different metrics were collected. In these experiments, object-oriented software generally fared better for maintainability.

[307] Kirsopp, C., M. Shepperd, et al., An empirical study into the use of measurement to support OO design evaluation. No. TR99-01, Empirical Software Engineering Group, Bournemouth University, 1999.

Keywords: Emp, Qual, Java, Tool

Abstract: This paper describes a case study into using measurement to aid design evaluation. The study was carried-out as an assignment by final year B.Sc. students from an I.T. course. Approximately half of these were part-time students working full-time in industry and the others were full-time students who had already undertaken a one-year industrial placement. After some preparatory tuition, the subjects were given a small system (15 classes) written in Java and a tool to enable them to apply a wide variety of metrics to this system. They were then asked to use measurement results and design heuristics to help them critique the design of the system.

The main results from this work are that: - measurement was found to be a useful aid to design evaluation; - following the study, most subjects said that they would now be more inclined to use measurement than they were previously; - support is needed for measurement selection as well as measurement collection; - there were significant differences in the way the task was carried out between the full-time students and the industrial subjects

Notes: This report may be downloaded from : http://dec.bournemouth.ac.uk/ESERG/Technical_Reports/TR99-01/TR99-01.ps

[308] Kokol, P., V. Zumer, et al., 'PROMIS: A Software Metrics Tool Generator', ACM SIGPLAN Notices, 30(5), pp37-42, 1995.

Keywords: Tool

[309] Kolewe, R., 'Metrics in object-oriented design and programming', Software Development, (October), pp53-62, 1993.

Keywords: Des, Prod

Abstract: Ralph Kolewe is at rkolewe@eridani.com.

[310] Korson, T. and J. D. McGregor, 'Technical criteria for the specification and evaluation of object-oriented libraries', Software Engineering Journal, 7(3), pp85-94, 1992.

Keywords: Des, Qual,

Abstract: This paper suggests a number of criteria for object oriented class libraries. These criteria are categorised by their support for a set of desirable attributes. The attributes given are: completeness, consistency, ease of learning, ease of use, efficiency, extendibility, integrability, intuitiveness, robustness and support.The criteria used to support these attributes are:1 Completeness - should provide complete general model for the concepts the library claims to support.2 Abstractions - the library should be designed around a few key abstractions.3 Standard - the design of the library should model standard knowledge in the domain.4 Inheritance structure - the library use inheritance to model gen/spec relationships.5 Purity - the library should be designed as networks of classes with no free-standing data or functions.6 Coupling - the library classes should be loosely coupled.7 Exceptions - a consistent and easily understood approach to errors and other exceptions should be provided.

8 Partial functions - for every partial function, there should be an inspector function available to check the preconditions of the partial function.9 Integrity of abstraction - It should not be possible for a library user to violate the abstraction represented in a library class.10 Complete interface - classes in the library should conform to a minimum set of standards that are enforced throughout the library.11 Efficiency - the implementation should be the most efficient available within the stated time and space constraints.12 Consistency - the definitions and naming of items in the library should be consistent.13 Generics - the library should provide generic classes where possible.14 Full implementation - the user should be aware of the degree of completeness of the implementation of the classes in the library.15 Organisation - documentation should be organised in a manner that reflects the structure of the library.16 Overview - documentation should be provided that that presents an overview of the library including both content and structure.17 Orientation - the library should provide documentation for each level of user.18 Indexes - documentation for each library should have a minimum of three access methods: alphabetic, hierarchical, and keyword.19 Formal specification - the documentation should provide formal specification for each of the components in the library.20 Accessing tools - libraries should be accompanied by tools that assist the user in finding and viewing classes.21 Integrating tools - libraries should be accompanied by tools that allow the user to add new classes to the library.22 Support - commercial libraries should be supported.23 Upgrades - receiving updates fro object-oriented libraries will be crucial.

[311] KPMG, Object Technology Survey Results. , KPMG Management Consulting, 1994.

Keywords: C++, Ind, Man, Small, Emp

Abstract: A survey of 3000 European companies with a very good response of 718. Survey covers: object technology in the current IT environment; understanding of object technology, perceived benefits of object technology; adoption of object technology. Some findings: 74% of respondents think C++ is important or very important for their company's future, compared to about 50% for C and only 16% for Smalltalk. Companies with high involvement in object technology seem to spend about the same amount of time on each stage of the life cycle as those with low involvement, except for maintenance where high involvement companies spend 17% of their time as opposed to low involvement companies (23%). (But I suppose object technology is too new for many projects to have spent much time in maintenance.) Lots of good facts and pictures for making the case to management for switching to OO! .

Notes: Contact Simon Fellows or Neale Whyatt, KPMG, 8 Salisbury Square, London EC4Y 8BB, Tel: +44 (0) 171 236 8000, Fax: +44 (0) 171 311 8520.

[312] Kraemer, T. F., 'Product Development Using Object-oriented Software', Hewlett Packard Journal, (August), pp87-100, 1989.

Keywords: Ind

Abstract: The paper discusses the application of OO technology at Hewlett Packard. It provides a short history

and a diagram of OO language evolution (biased to HP). It also provides a clear introduction to OO issues such as classes, polymorphism, messages etc.. It discusses design issues in the VISTA product an electronic testing product. There are some particularly insightful comments about memory management, performance and object granularity.

Notes: Identifies metrics that were to be collected during OO development but provides no data or analysis.

[313] Kristen, G., Object Orientation. The KISS Method: From Information Architecture to Information System. Addison-Wesley: Wokingham, UK, 1994.

Keywords: Rev, Theory

Abstract: Chapter 7 of Gerald Kristen's book introduces measurement theory as an important concept underlying certain types of application. The book does not deal with software metrics but for those who want to take a serious approach to metrics, this may well be an OO-friendly way into the subject.

[314] Kung, D., J. Gao, et al., 'Class firewall, test order and regression testing of object-oriented programs', J. Object-Oriented Programming, 8(2), pp51-65, 1995.

Keywords: C++, Emp, Test

Abstract: Similar in subject matter to [Kung, 1995, "Developing an object-oriented software testing and maintenance environment"] but with a more detailed empirical study of changes to classes in InterView library.

[315] Kung, D., J. Gao, et al., 'Developing an object-oriented software testing and maintenance environment', Commun. ACM, 38(10), pp75-87, 1995.

Keywords: C++, Emp, Test, Maint

Abstract: Describes a methodology developed by University of Texas at Arlington and Fujitsu Network Transmission Systems Inc. Contains interesting empirical data for test effort in unit, integration and regression testing for a class library, the InterView library.

Notes: David Kung is at kung@homer.uta.edu, Jerry Gao is at gao@cse.uta.edu, Pei Hsia is at hsia@cse.uta.edu, Young-Si Kim is at yskim@tdx.etri.re.kr, Young-Kee Song is at yksong@tdx.etri.re.kr.

[316] Lahire, P. and J. M. Jugant. 'Lessons learned with Eiffel 3: the K2 project', in Proc. TOOLS 17. Prentice Hall, New York, 1995.

Keywords: Ind, Emp, Reuse

Abstract: K2 is agriculture training software used by the United Nations. This report gives lots of data on size, productivity, reuse etc. from the development of K2 in Eiffel. E.g. LOC per class varied between 12 and 1458 (average 106), productivity was 27 classes/month, but 51 per month including reuse. The main conclusion is that reuse through use of non-vendor libraries was actually occurring.

Notes: Philippe Lahire is at lahire@hibiscus.unice.fr, Jean-Marc Jugant is at jmj@tigre.unice.fr.

[317] Lake, A. 'Use of factor analysis to develop OOP software complexity metrics', in Proc. 6th Annual Oregon Workshop on Software Metrics. Silver Falls, Oregon: 1994.

Keywords: Emp, Prod

[318] Lake, A. and C. Cook. 'A software complexity measure for C++', in Proc. 4th Annual Oregon Workshop on Software Metrics. Silver Falls, Oregon: 1992.

Keywords: C++, Prod

[319] LaLonde, W. and J. Pugh, 'Gathering metric information using metalevel facilities', Journal of Object-Oriented Programming, (March/April), pp33-37, 1994.

Keywords: Small, Size

Abstract: Definition of metrics on the level of the Smalltalk (V for Windows) system, library, and class.

[320] Lamping, J. 'Typing the Specialization Interface', in Proc. OOPSLA 93. Addison-Wesley, 1993.

Keywords: Des

Abstract: A class in OOP has 2 interfaces: a client interface (for messaging - using objects) and a specialization interface (for subclassing - extending classes). Type systems have 2 functions: documentation and checking. This paper extends general type systems to show some dependency information to the potential class specialiser. The paper uses 2 ongoing examples, sets and buttons.They distinguish between classes, protocols and types. A protocol is what is available at an interface, a class is the implementation and a type is a partial formal description of a protocol. If type information is extended then the potential is able to recognise when a weaker protocol may be used. They discuss Layering in a similar way to Bar-David as a design tactic which their approach supports.This may well be a useful documentation heuristic even without the tool support.

Notes: The suggestion of adding interdependency information to class specifications is an interesting one, and would have implications for metrication as well as type checking. However, the method put forward for achieving this though extended type checking appears a little complex and clumsy.

[321] Laranjeira, L., 'Software size estimation of object-oriented systems', Software Development, 1(2), pp53-62, 1993.

Keywords: Size, Man

[322] Laranjeira, L. A., 'Software size estimation of object-oriented systems', IEEE Trans. Software Eng, 16(5), pp510-522, 1990.

Keywords: Size, Man

Abstract: Provides a new algorithmic model for cost estimation. From the conclusion: "The object-oriented paradigm plays an important role in this process since it embeds a strong correspondence between specifications and implementation. This characteristic makes it easier to relate an object functions, sometimes called methods, and data to the amount of code necessary to implement it."

[323] Lee, R. Y., J. P. Kelsh, et al. 'Special metrics for object-oriented software design', in Proc. IASTED/ISMM International Conference Modelling and Simulation. IASTED-ACTA Press, Anaheim, CA, USA, 1996.

Keywords: Prod, Theory

Abstract: The object-oriented approach is becoming popular in the software development community as an alternative to structured analysis and design methodologies. Object-oriented software metrics can provide a quantitative means to control the software development process and the quality of software products. The need for object-oriented software metrics is now fully recognized by the software development community and is included in ISO 9000-3 standards. The purpose of this paper is to investigate special metrics for object-oriented software design and to provide their definitions and descriptions. It also discusses software metric evaluation criteria. Finally, further study on object-oriented software metrics is presented.

[324] Lee, Y. S., B. S. Liang, et al. 'Some complexity metrics for object-oriented programs based on information flow', in Proc. Computer System and Software Engineering 1993, 7th Annual European Computer Conference, (CompEuro'93). Paris, France: 1993.

Keywords: Prod, Size

Abstract: "This paper presents a set of complexity metrics for object-oriented systems based on information flows models. These metrics may be used to measure methods, classes, class hierarchies, and programs in an object-oriented system. The attributes to be measured are the interactive coupling among entities and internal complexity of each individual entity. The proposed set of metrics is examined using Weyuker's meta-metrics." [axioms -MJS]

Notes: Yen-Sung Lee and Feng-Jian Wang can be contacted c/o Bin-Shiang Liang at jack@ooserv2.csie.nctu.edu.tw and bsliang@csie.nctu.edu.tw WWW: http://ooserv2.csie.nctu.edu.tw/~jack.

[325] Lee, Y. S., B. S. Liang, et al., 'Some complexity metrics for object-oriented programs based on information flow: a study of C++ programs', Journal of Information and Software Engineering, 1994(10), pp21-50, 1994.

Keywords: C++, Prod, Size

Abstract: Some metrics attempt to quantify the qualitative software quality. A software complexity measure is one used to capture the programming difficulties during development and predict the maintainability and testability of the software. This paper presents a set of complexity metrics for object-oriented systems based on information flows models and evaluated by means of Weyuker's meta-metrics [axioms - MJS] for their validity. The entities measured by this set of metrics consist of methods, classes, class hierarchies, and programs in an object-oriented system. The attributes of an entity considered are the interactive coupling (external complexity) among entities and the length (internal complexity) of each individual entity. This set of metrics is applied to C++ programs.

[326] Lee, Y. S., B. S. Liang, et al. 'Measuring the coupling and cohesion of an object-oriented program based on information flow', in Proc. International Conference on Software Quality 1995, (ICSQ'95). Maribor, Slovenia: 1995.

Keywords: C++, Prod, Des

Abstract: "Many design guidelines for object-oriented programs make use of coupling and cohesion as indexes to help construct good design. To make these guidelines practical and quantitative, a set of well defined coupling and cohesion metrics is needed. However, there were few cohesion and coupling metrics presented in the literature, let alone those for object-oriented programs whose underlying programming languages or environments are more complicated. In this paper, we propose a set of coupling and cohesion metrics for object-oriented programs based on information flow. Two example C++ programs are used to illustrate the application of the metrics. Besides, our metrics are evaluated by applying Weyuker's meta-metrics. [axioms - MJS]"

[327] Lewerentz, C. and F. Simon. 'A product metrics tool integrated into a software development environment', in Proc. European Software Measurement Conference. FESMA 98. Technologisch Instituut Vzw, Antwerpen, Germany: 1998.

Keywords: Tool

Abstract: The goal of the project Crocodile is to provide concepts and tools for an effective usage of quantitative product measurement to support and facilitate design and code reviews. Our application field is the realm of object oriented programs and, particularly, reusable frameworks. The main concepts are measurement tool integration into existing software development environments, using existing tool sets and integration mechanisms; mechanisms to define flexible product quality models based on a factor-criteria-metrics approach; the use of meaningful measurement contexts isolating or combining product components to be reviewed; effective filtering and presentation of measurement data. Our current implementation platform for a tool providing these concepts is TakeFive's SNiFF+, an industrial strength integrated C++/Java programming environment. Crocodile provides comprehensive static analysis features like those implemented, for example, in Audit-C/C++ by SemaGroup and it can be fully integrated into an existing development environment.

[328] Lewis, J. A. 'Quantified Object-Oriented Development: Conflict and Resolution', in Proc. 4th Software Quality Conference. Dundee, UK: University of Abertay, Dundee, UK, 1995.

Keywords: Prod

Abstract: As investigations of the object-oriented paradigm mature, so does our understanding of the unique complexities introduced by object-oriented concepts. Metrics can be used to guide development and testing activities, but the application of complexity metrics to the object-oriented paradigm is still in its infancy. The metrics proposed to date are not as insightful as they could be, and ignore several of the characteristics which add complexity to an object-oriented system. This paper presents a metrics suite which is inclusive in its attention to the varying components of the paradigm.

[329] Lewis, J. A., S. Henry, et al., 'An empirical study of object-oriented paradigm and software reuse', ACM SIGPLAN Notices, 26(11), pp184-196, 1991.

Keywords: C++, Des, Emp, Reuse

Abstract: From the paper: "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 no, and (4) the object-oriented paradigm has a particular affinity to reuse."

Notes: In Paepcke, A. (ed.), Proc. OOPSLA '91 Conference on Object-Oriented Programming Systems, Languages and Applications, Phoenix, Arizona

[330] Li, P., J. Kennedy, et al. 'Assessing inheritance for the multiple descendant redefinition problem in OO systems', in Proc. OOIS'97. 1997 International Conference on Object Oriented Information Systems. Springer-Verlag London, London, UK, 1998.

Keywords: Prod, Emp

Abstract: Current use of inheritance has illustrated that the introduction of conceptual inconsistencies is possible in a class hierarchy. This paper discusses the reasons why complete method redefinition infringes the essence of inheritance. A redefinition metric set is proposed and practical experiments demonstrate that the results obtained permit the detection of inheritance design problems. Appropriate design decisions are suggested.

[331] Li, P., J. Kennedy, et al. 'Mechanisms for interpretation of OO systems design metrics', in Proc. Technology of Object-Oriented Languages. TOOLS 24. IEEE Comput. Soc, Los Alamitos, CA, USA, 1998.

Keywords: Prod, Man

Abstract: A major criticism of metrics for object oriented systems design has been their deficiencies in generating meaningful feedback information. The paper proposes a data interpretation method based on visualisation of results obtained from the method redefinition metric set. The method encompasses an "alarmer" technique for identifying suspected design problems occurring under certain conditions. We demonstrate how the method provides a mechanism for metric result interpretation, design problem identification and design decision deduction.

[332] Li, W., Applying Software Maintenance Metrics in the Object-Oriented Software Development Life Cycle. Ph.D. Thesis , Virginia Polytechnic Inst. and State Univ., 1992.

Keywords: Des, Emp, Man, Maint

Abstract: This includes the definition of some software metrics for object-oriented systems (see also the Li & Henry paper) and their use for two software systems in Ada with an empirical evaluation of maintenance.

Notes: Suggested contact is Sallie Henry at: henry@cs.vt.edu.

[333] Li, W., 'Another metric suite for object-oriented programming', Journal of Systems and Software, 44(2), pp155-162, 1998.

Keywords: Prod, Rev

Abstract: Chidamber and Kemerer (C&K) proposed six metrics for object-oriented programming. Discussions about the metrics were also reported. Recently, Kitchenham and her colleagues proposed a framework to validate software metrics. This paper evaluates C&K metrics by using Kitchenham's metric-evaluation framework and finds deficiencies in some of the C&K metrics. In order to remedy the deficiencies, this paper proposes another metric suite for object-oriented programming. The new metric suite, also six in number, includes number of ancestor classes (NAG), number of local methods (NLM), class method complexity (CMC), number of descendent classes (NDC), coupling through abstract data type (CTA), and coupling through message passing (CTM).

[334] Li, W. and H. Delugach. 'Software metrics and application domain complexity', in Proc. Asia Pacific Software Engineering Conference and International Computer Science Conference. IEEE Comput. Soc, Los Alamitos, CA, USA, 1997.

Keywords: Prod

Abstract: Software product metrics have been studied as a means to measure the complexity of software artifacts. Most software product metrics focus on capturing the complexity exhibited by the program. This paper suggests that there are two types of complexity in software artifacts: the structural complexity and the application domain complexity. The structural complexity is expressed in the program structure. The application-domain complexity is inherited from an application domain. Traditional software metrics are effective in measuring the structural complexity of software artifacts. However these metrics are not effective in measuring application-domain complexity.

[335] Li, W. and S. M. Henry. 'Maintenance metrics for the object oriented paradigm', in Proc. 1st Intl. Software Metrics Symposium. Baltimore, MD: IEEE Computer Society, 1993.

Keywords: Prod, Maint, Emp

Abstract: Software metrics have been studied in the procedural paradigm as a quantitative means of assessing the software development process as well as the quality of software products. Several studies have validated that various metrics are useful indicators of maintenance effort in the procedural paradigm. However, software metrics have rarely been studied in the object oriented paradigm. Very few metrics have been proposed to measure object oriented systems, and the proposed ones have not been validated. This research concentrates on several object oriented software metrics and the validation of these metrics with maintenance effort in two commercial systems.

Notes: Describes, in brief, some empirical results from using some of the Chidamber and Kemerer metrics.

[336] Li, W. and S. M. Henry, 'Object-oriented metrics that predict maintainability', J. Systems and Software, 23(2), pp111-122, 1993.

Keywords: Emp, Maint

Abstract: Describes a study in which 5 of the metrics from [Chidamber, 1991] and some others (no. of send statements defined, no. of ADT's defined, no. of local methods defined) were used on 2 commercial systems developed in Classic-Ada. They found strong relationships between the metrics and maintenance effort. Maintenance effort could be predicted from combinations of the metrics and these predictions were cross-

validated successfully against other parts of the systems.

[337] Li, W. and S. M. Henry, 'An empirical study of maintenance activities in two object-oriented systems', Journal of Software Maintenance: Research & Practice, 2(2), pp131-147, 1995.

Keywords: Des, Ind, Man

Abstract: An observation of the maintenance of UIMS (User Interface System) and QUES (Quality Evaluation System), two commercial systems developed in Classic-Ada (a version of Ada supporting object-orientation: encapsulation, inheritance etc). Conclusions: (a) classes at all inheritance levels are likely to be affected by all types of maintenance (corrective, perfective and adaptive); (b) a higher proportion of classes in higher inheritance levels are likely to be affected by maintenance in later software releases; (c) perfective and corrective maintenance dominate in an object-oriented system; adaptive maintenance is scarce; (d) perfective maintenance dominates in first release; corrective dominates subsequently.

[338] Li, W., S. M. Henry, et al., 'Measuring object-oriented design', J. Object-oriented Programming, (July/August), 1995.

Keywords: Des, Maint

Abstract: "Software metrics are sometimes applied to source code and validated with maintenance data. Many metrics attempt to quantify the quality of a software product; however, measuring source code often occurs too late in the software lifecycle. Several research projects have indicated that metrics, when applied to designs, can predict maintainability. The conclusion is that maintenance effort can be predicted from metrics collected at design time.

[339] Liddiard, J., 'Achieving testability when using Ada packaging and data hiding methods', Ada User, 14(1), pp27-32, 1993.

Keywords: Test

[340] Lim, W. C., 'Effects of reuse on quality, productivity and economics', IEEE Software, 11(September), 1994.

Keywords: Emp, Reuse

Abstract: Apparently gives some evidence for the benefits of reuse.

[341] Lindvall, M. and M. Runesson. 'The visibility of maintenance in object models: an empirical study', in Proc. International Conference on Software Maintenance. IEEE Comput. Soc, Los Alamitos, CA, USA, 1998.

Keywords: C++, Emp, Maint, Prod

Abstract: This empirical study analyzes changes in C++ source code which occurred between two releases of an industrial software product and compares them with entities and relations available in object-oriented modeling techniques. The comparison offers increased understanding of what changes can and cannot be

described using such object models. The goals were to investigate if the object model in this particular project is either abstract and stable or detailed and sensitive to change, and whether or not changes made to the C++ source code are visible in the object model. Four metrics for characterization of change are formally defined and used, namely correctness, completeness, compliance, and visibility factor. The major finding is that even though many of the classes are changed, the majority of these changes turn out to be invisible in the object model. That is, changes made on the source code level are of a finer granularity than available in common object modeling concepts. This may explain why object models seem to be of little use in release-oriented development.

[342] Linthicum, D. S., 'In Search of the Elusive OO Metric', Object Magazine, 6(6), pp64-66, 1996.

Keywords: Man, Reuse

Abstract: Estimating software development projects in the dynamic world of object-oriented (OO) technology is quickly becoming a black art. The easy-to-predict structured waterfall model of yore is on its way out. Unstructured interactive application development is in. These days, OO tools change at such a rapid pace that developers never can build software the same way from one project to the next. To complicate an already difficult situation, there are no widely accepted metrics to estimate the special circumstances of OO development. Thus, many managers put metrics aside and rely upon experience and gut instinct, which only adds risk to the development project. Many managers may find themselves with no choice as to the use of metrics. SEI's Capability Maturity Model (CMM) mandates metrics for companies that want to achieve a status of level three, or higher. This is the level required for many commercial development organizations to obtain additional business from the government and some of the Fortune 100. Therefore, the correct use of metrics in your organization could effect your bottom line. Reuse, the battle cry of OO development for years, is another issue that needs to be addressed. Now that many systems exist, management demands methods of measurement to determine how well developers actually reuse objects, and if development for reuse actually shows a return on the investment.

Notes: Underlines the need for measures and prediction systems specific to object-oriented software.

[343] Liu, C., S. Goetze, et al., 'What contributes to successful object-oriented learning?', ACM SIGPLAN Notices, 27(10), pp77-86, 1992.

Keywords: C++, Emp, Small

Abstract: Annotation from [Webster, 1994]: "Reports an informal, but quite large, study of people attending OO short courses. Prior programming in C turned out to be a positive indicator of success, as did technical inquisitiveness and recent programming experience. The argument that people with no programming experience pick up OO programming quicker than those with a lot of non-OO experience is not supported.

Notes: In (Paepcke, A., ed.) Proc. OOPSLA'92.

[344] Liu, C. P., B. S. Liang, et al. 'A validation of software complexity metrics for object-oriented programs', in Proc. International Computer Symposium 1994, (ICS'94). Taiwan, R.O.C.: 1994.

Keywords: C++, Emp, Prod, Size

Abstract: "Object-Oriented Programming (OOP) is a new programming concept and technique entering the mainstream of software development rapidly. Claimed advantages of OOP include higher reusability and

maintainability. Complexity was commonly used as an attribute for assessing the resources spent and predicting maintainability and reliability of a program. This paper presents a validation process in which an experimental project was analysed for sixteen software metrics. The experiment was conducted to calculate the complexity and development cost of methods and classes in C++ language. The validation process uses four validity criteria, each has its own statistical analysis model. The results show that three complexity metrics based on information flow can reflect the complexity of object-oriented software by the validity criteria."

Notes: Chang-Peng Liu, Yen-Sung Lee and Feng-Jian Wang can be contacted c/o Bin-Shiang Liang at jack@ooserv2.csie.nctu.edu.tw and bsliang@csie.nctu.edu.tw WWW: http://ooserv2.csie.nctu.edu.tw/~jack.

[345] Lo, B. W. N. and S. Haifeng. 'A preliminary testability model for object-oriented software', in Proc. 1998 International Conference Software Engineering: Education and Practice. IEEE Comput. Soc, Los Alamitos, CA, USA, 1998.

Keywords: Test

Abstract: In software quality assurance, two approaches have been used to improve the effectiveness of fault detection. One attempts to find more efficient testing strategies; the other tries to use the design characteristics of the software itself to increase the probability of a fault revealing itself if it does exist. The latter which combines the best feature of fault prevention and fault detection, is also known as the testability approach to software quality assurance. This paper examines the factors that affect software testability in object-oriented software and proposes a preliminary framework for the evaluation of software testability metrics. The ultimate aim is to formulate a set of guidelines in object-oriented design to improve software quality by increasing their testability.

[346] Lorenz, M., Object-Oriented Software Development: a Practical Guide. Vol. ISBN 0-13-72692-8. Prentice Hall: Englewood Cliffs, N.J., 1993.

Keywords: C++, Des, Small, Rev

Abstract: Appendix I, pp. 183-192, of Mark Lorenz's book is on metrics and there are also scattered references throughout the book. See also [Lorenz, 1994]. A comparative review of this and 8 other books is give by Louis Agosta in ACM Computing Reviews, Feb. 1995, rev. no. 9502-0058.

[347] Lorenz, M. and J. Kidd. 'O-O metrics position paper', in Proc. OOPSLA `93 Workshop on Processes and Metrics for Object Oriented Software Development. Washington DC: 1993.

Keywords: Des, Man

Abstract: Not necessarily available as a paper. However, see the Workshop Report: [Bilow, 1993]. The following is taken from that report: "Mark Lorenz and Jeff Kidd came to the workshop with metrics taken from their up and coming book on the subject. They made two very important points. First, they make a large distinction between what they term 'Project Metrics' and 'Design Metrics'. Project metrics include such items as schedule, staffing estimating, and nearness to completion. Design metrics, on the other hand include such items as method 'size', class size, use of inheritance, cohesion, etc. More important than the presentation of Mark's metrics was his statement that metrics should not 'drive design' but, rather, should be used to pinpoint anomalies. Some may disagree with this premise but it does remind us of how easy it is to misuse measures."

[348] Lorenz, M. and J. Kidd, Object-Oriented Software Metrics. Object-Oriented Series, Prentice Hall: Englewood Cliffs, N.J., 1994.

Keywords: C++, Des, Man, Small, Rev

Notes: A review by R. Whitty of this book appears in Software Testing, Verification and Reliability, 4 (4) 1994, 255-256. A review by M.M.Tanik is given in ACM Computing Reviews, April 1995, rev. no. 9504-0213. Mark Lorenz and Jeff Kidd are at: 71214.3120@compuserve.com.

[349] Lounis, H. and W. L. Melo. 'Identifying Coupling in Modular Systems', in Proc. 7th Intl. Conf. on Software Technology. Curitiba, Brazil: 1997.

Keywords: Prod

Notes: Defines an extensive set of coupling measures for modular software systems.

[350] Lounis, H., H. A. Sahraoui, et al., Identifying and Measuring Coupling in OO systems. Technical Report No. CRIM-97/11-82, CRIM, 1997.

Keywords: Prod

Notes: The ISBN is 2-921316-83-8.

[351] Love, T., Object Lessons: Lessons Learned in Object-Oriented Development Projects. Vol. ISBN 0-9627477-3-4. SIGS Books Inc.: New York, 1993.

Keywords: Qual, Rev

Abstract: Chapter 11 of Tom Love's book is a metrics based introduction to quality assurance in the OO domain.

[352] Lytz, R., 'Software metrics for the Boeing 777: a case study', Software Quality Journal, 4(1), pp1-13, 1995.

Keywords: Man, Ind

Notes: The Boeing programme is instructive in that benefits were derived rapidly - three months after programme inception. Lytz notes that these (project) metrics complemented metrics already in place at team level.

[353] Major, M. L. and J. D. McGregor. 'The application of function point analysis (FPA) to object-oriented software development', in Proc. OTC '96. Object Technology Centers. Comsoft, Collegedale, TN, USA, 1996.

Keywords: Size

Abstract: Function Point Analysis (FPA) was developed in 1979 by Allen Albrecht. This method of project estimation has been perfected and utilized throughout the software development industry. The use of FPA in the software development process is primarily concerned with estimation of product size or functionality. This method can be broken down into three stages. The first stage primarily deals with the classification and counting of user functions. The user functions are factors that affect all applications being developed. Five user functions were identified as being external input types, external output types, local internal file types, external interface file types, and external inquiry types. The second stage deals with adjustment of system size based on application or processing complexity. Each of the 14 identified areas of complexity is assessed a weight depending on the degree of influence that each has on the overall system. Then the 14 degrees of influence are added together to come up with a total complexity adjustment factor. The final stage in FPA is the actual calculation including the numbers found with the above stages. The use of FPA to accurately estimate the effort required for an object-oriented development project needs to be further examined with respect to some key issues. Reuse in the object-oriented environment, projects utilizing case tools, the earliest possible estimation with what is available at that time, the complexity of object-oriented systems, frameworks, and the use of iterative development process all represent issues facing the object-oriented programmer or developer.

[354] Mancl, D. and W. Havanas. 'A study of the impact of C++ on software maintenance', in Proc. IEEE Conf. on Software Maintenance. IEEE Computer Society Press, 1990.

Keywords: C++, Emp, Maint

Abstract: Provides some empirical evidence that easier maintenance can be achieved through OO.

[355] Marchesi, M. 'OOA metrics for the Unified Modeling Language', in Proc. Second Euromicro Conference on Software Maintenance and Reengineering. IEEE Comput. Soc, Los Alamitos, CA, USA, 1998.

Keywords: Prod, Des, Emp

Abstract: UML is the emerging standard for expressing OOA/OOD models. New metrics for object oriented analysis models are introduced, and existing ones are adapted to the entities and concepts of UML. In particular, these metrics concern UML use case diagrams and class diagrams used during the OOA phase. The proposed metrics are intended to allow an early estimate of development efforts, implementation time and cost of the system under development, and to measure its object orientedness and quality since the beginning of the analysis phase. The proposed metric suite is described in detail, and its relations with proposed metrics found in the literature are highlighted. Some measurements on three software projects are given.

[356] Martin, R., 1994. Object-oriented design quality metrics : an analysis of dependencies [online], Available from: http://www.oma.com/Offerings/catalog.html[24 June 1996].

Keywords: Prod, Des

Abstract: Mainly drawn from his experience with the OO project, Martin presents a set of metrics to determine the quality of a design based upon the inter-dependencies between Booch's Class Categories. Notably, he considers the dependencies between subsystems. An interesting paper, but the metrics were not validated and simply provide a theoretical background upon which one may extend. Could prove useful when looking into the modularity aspect of design. [CG]

Notes: Also available from http://www.oma.com/Publications/publications.html.

[357] Martin, R. 'OO design quality metrics - an analysis of dependencies (Position Paper)', in Proc. Workshop on Pragmatic and Theoretical Directions in Object-Oriented Software Metrics, OOPSLA'94. 1994.

Keywords: Des, Qual, Tool

Abstract: Robert Martin posted the following description on the internet, April '95: "The metrics described in this paper measure the conformance of a design to a pattern of dependency and abstraction which the author feels is a 'good' pattern. Experience has shown that certain dependencies are good and others are bad. This pattern reflects that experience. However, a metric is not a god; it is merely a measurement against an arbitrary standard. It is certainly possible that the standard chosen in this paper is appropriate only for certain applications and is not appropriate for others. It may also be that there are far better metrics that can be used to measure the quality of a design. Thus, I would deeply regret it if anybody suddenly decided that all their designs must unconditionally be conformant to 'The Martin Metrics'. I hope that designers will experiment with them, find out what is good and what is bad about them, and then communicate their findings to the rest of us".

Notes: Kevin Anderson tells me that the paper has now been updated with some shell scripts for evaluating the metrics. Robert Martin is happy to provide people with copies of the paper and can be contacted at Object Mentor Assoc., Green Oaks, IL 60048, USA, tel.: +708 918 - 1004, fax: +708 918 - 1023, email: rmartin@rcmcon.com. See also [Bilow, 1995].

[358] Martin, R., Designing object oriented C++ applications using the Booch method. Vol. ISBN 0-13-203837-4. Prentice Hall: Englewood Cliffs, New Jersey, 1995.

Keywords: C++, Rev, Des, Prod

Abstract: Chapter 3 covers dependency metrics: the following description came to me from Sacha Kuijs of SW-EASY, the Netherlands, via Martin West: "It includes metrics such as: * relational cohesion (average number of internal relationships per class); * afferent coupling (number of classes from other categories that depend upon the classes within the subject category); * efferent coupling (number of classes in other categories that the classes in the subject category depend upon); * instability (ratio of efferent coupling to total coupling). It seems a good way to get an idea about code quality. The book says that it should not be a problem to automate these calculations if you have a program that parses C++ programs or Booch diagrams". See also [Martin, 1994, "OO design quality metrics - an analysis of dependencies (Position Paper)"]; Chapters 5-7 give a case study: a building security system; Appendix A provides some C++ coding standards.

[359] Martin, R. C., 'Large-scale stability', C++ Report, 9(2), pp54-60, 1997.

Keywords: C++, Qual, Prod

Abstract: The author looks back at his previous articles and proceeds forward with a discussion of the principles used in the structure of large C++ applications. These principles are most appropriate for applications that exceed 50000 lines of C++ and require a team of engineers to write. The article describes a set of principles and metrics that can be used to measure the quality of an object-oriented design in terms of the interdependence between the packages of that design. Designs which are highly interdependent tend to be rigid, non-reusable and hard to maintain. Yet interdependence is necessary if the packages of the design are to

collaborate. Thus, some forms of dependency must be desirable, and other forms must be undesirable. The article proposes a design pattern in which all the dependencies are of the desirable form. Finally, the article describes a set of metrics that measure the conformance of a design to the desirable pattern. The principles and metrics discussed in the article have to do with stability.

[360] Maus, A. 'Entropy as a complexity and optimal module size in an object-oriented program', in Proc. Algorithms, Software, Architecture, Information Processing. IFIP 12th World Congress. Elsevier Science Publishers, 1992.

Keywords: Prod

Notes: Information-theoretic view. It is not really clear what the attribute "complexity" means. The approach also makes many assumptions e.g. uniform distribution of lexical elements etc.. The work on the optimal number of structures / procedures for a program is entirely syntactic, i.e. it ignores the meaning of the code. At present there is no empirical support for this work.

[361] Mayrand, J., F. Guay, et al. 'Inheritance graph assessment using metrics', in Proc. 3rd International Software Metrics Symposium. IEEE Comput. Soc. Press, Los Alamitos, CA, USA, 1996.

Keywords: Emp, Qual

Abstract: Presents a new method integrated in Bell Canada`s software acquisition process to assess software. This paper is focused on the assessment of the understandability of the inheritance graph of object-oriented software. The method is based on metrics and on the graphical illustration of the inheritance graph. A technique to decompose the inheritance graph of an object-oriented program into sub-graphs using metrics is described. Metrics are also used to identify complex sub-graphs. On the selected graphs, a technique to improve the understandability of the graphical illustration representing the inheritance graph is also described. This technique is based on extracting the main tree on the inheritance graph. A C++ case study containing 1080 classes is presented, on which this assessment method was applied.

[362] McCabe, T. J., L. A. Dreyer, et al., 'Testing an object-oriented application', Journal of the Quality Assurance Institute, (October), pp21-27, 1994.

Keywords: Des, Test

Abstract: Claims that traditional control flow analysis still has a role in o-o testing and complexity measurement. Also lists some new metrics for o-o systems: inheritance metrics, encapsulation metrics, polymorphism metrics and quality metrics.

[363] McCabe, T. J. and A. H. Watson, 'Combining comprehension and testing in object-oriented development', Object Magazine, 4(1), pp63-64, 1994.

Keywords: Qual, Test

Abstract: Although we tend to take comprehension for granted and spend time designing test strategies, comprehension and test effort combine to increase confidence in our software. The typical cohesive object-oriented lifecycle provides an opportunity for synergy between these two traditionally separate processes. Automated tools for visualization and metrics that include such features as class browsing, structure charts

with bound and collapsed classes, class resolution, and safety provide an environment in which to maximize the reward and minimize the risk inherent in the abstractions of the object paradigm. While many traditional comprehension and testing strategies apply to object-oriented systems, specific object-oriented support is vital. In the absence of strong empirical results and experience, a careful examination of fundamental software considerations and reward vs. risk considerations can help us select effective strategies to apply to our object-oriented projects.

[364] McClure, S., Object tools - Smalltalk market accelerates. , International Data Corporation, 1995.

Keywords: Man, Small

Notes: I haven't seen this but see [Shan, 1995]. Available by contacting info@stic.org.

[365] McGregor, J., 'Managing metrics in an iterative environment', Object Magazine, (October), pp65-71, 1995.

Keywords: Prod, Theory, Man

Abstract: I describe a technique, termed the iterative incremental metric model, that combines continuous refinement of estimates during a single iteration through the project lifecycle with the management of the multiple values calculated for each metric during every iteration of the project. I discuss a few basic assumptions about metrics and the process model being used. Techniques for comparing values within and across iterations are presented and, finally, the management of these values is discussed. Two metrics being developed for use in object-oriented projects are briefly described as an example of the refinement approach.

[366] McGregor, J. D. and S. Srinivas. 'A measure of testing effort', in Proc. Second USENIX Conference on Object-Oriented Technologies and Systems (COOTS). USENIX Assoc, Berkeley, CA, USA, 1996.

Keywords: Size, Test

Abstract: Accurate estimates of the time and resources needed for a project are difficult to achieve. Numerous metrics have been proposed and a few have proved reliable in making these estimates. With the increased emphasis on quality and testing, estimates of the amount of effort required to test a product are a necessary part of any complete project estimate. Estimates of the effort to test object-oriented components and systems are particularly important because these components are often added to repositories to be used many times. The amount of effort required to test the component is related to its complexity. We consider several measures of method and class complexity and relate them to testability. The main focus of this research is to estimate the effort that is needed to test a class, as early as possible in the development process. We investigate the testability of a method in a class and indirectly estimate the effort that is needed to test a class. We define a concept, termed the visibility component of a method. It is a measure of the accessibility of the information that must be inspected to evaluate the correctness of the execution of a method. We show that the testability of the method is a function of its visibility component.

[367] Melo, W. L., L. C. Briand, et al., Measuring the impact of reuse on quality and productivity in object-oriented systems. Technical Report No. CS-TR-3395, University of Maryland, Dept of Computer Science, 1995.

Keywords: C++, Emp, Qual

Abstract: "This paper presents the results of a study conducted at the University of Maryland in which we assessed the impact of reuse on quality and productivity in OO systems. Reuse is assumed to be a very effective strategy for software industry to build high-quality software. However, there is currently very little empirical information about what we can expect from reuse in terms of productivity and quality gains. This also applies to OO development which is supposed to facilitate reuse. Our experiment is one step towards a better understanding of the benefits of reuse in an OO framework, considering currently available technology. Data was collected, for four months, on the development of eight medium-size management information systems with equivalent requirements. All eight projects were developed using the Waterfall Software Engineering Life Cycle Model, an Object-Oriented (OO) design method and the C++ programming language. This study indicates significant benefits from reuse in terms of reduced defect density and rework as well as increased productivity."

Notes: Available by ftp: ftp.cs.umd.edu:pub/sel/papers/CS-TR-3395.ps.Z. Walcélio can be contacted at: wmelo@crim.ca.

[368] Metsker, S. J., 'Object weights and measures', Object Magazine, 6(2), pp83-95, 1996.

Abstract: Applications calculate measures and convert units with case by case and ad hoc methods, which are prone to error, hard to maintain, and difficult to communicate to other applications. This can be eliminated by adding a measurement subsystem to your object model.

[369] Meyer, B., 'The role of object-oriented metrics', IEEE Computer, 31(11), pp123-125, 1998.

Keywords: Man

Abstract: Perhaps the most common concern of project managers who use or who are about to use object technology is for more measurement tools. There is, in fact, an extensive literature on software metrics, including much that pertains to object-oriented development, but surprisingly little of it is of direct use to actual projects. The author presents a classification of software metrics and five basic rules for their application.

Notes: This short note makes a number of observations concerning the need for, and uses of, metrics for measuring OO systems. In particular, Meyer stresses the importance of theory since there exist and infinite number of possible metrics not all of which are useful. He also discusses the need, at least in the long term, to be able to link internal measures to external ones.

[370] Milankovic-Atkinson, M. and E. Georgiadou. 'Metrics for reuse of object-oriented software', in Proc. Software Quality Management IV. Improving Quality. Mech. Eng. Publications, London, UK, 1996.

Keywords: Reuse, Rev

Abstract: Improved productivity in object-oriented software development is expected from software reuse. Object-oriented specific metrics can be used for the establishment of design rules to improve the quality of object-oriented software, primarily to enable better reuse. It is proposed to collect and analyse three categories of metrics namely syntax based, execution based and reuse class based metrics. A brief survey of existing metrics is presented and an extended class definition is proposed providing the facility to capture the metrics automatically, as an integral part of the development process. Expected benefits will subsequently be quantified in terms of the re-engineering ( rho /sub oo/) and reusability ( rho /sub u/) factors respectively.

[371] Milankovic-Atkinson, M. and E. Georgiadou. 'Object-oriented software development with reuse', in Proc. Sixth International Conference on Software Quality Management. Springer-Verlag London, London, UK, 1998.

Keywords: Reuse,Tool

Abstract: Improved productivity in object-oriented technology results from the reuse of software. Development with reuse in mind brings design and implementation closer. This requires a software tool to support both top-down development, from the specification of classes as icons in the graphical representation of the Object Model to code generation, and bottom-up development, from components in the source code to their class representations as icons of the Object Model. To make this possible the tools need to be fully integrated into the development environment. This paper discusses facilities offered by a number of tools and our experience of using the CASE tool Together/C++ and animator Look! as well as the Borland C++ 4.5 for Windows development environment. Initially we provide a brief discussion of different approaches for software reuse such as MOOSE, development through formal specification (VDM) and Eiffel. We report of lessons learned through the reuse of existing software components in C++ from generally available proprietary public domain or shareware. We discuss issues of understandability and complexity particular to object-oriented systems and the usefulness of animators such as Look!. Static analysis of object-oriented code cannot deal with ambiguities caused by polymorphic routine calls, e.g. tracing remote functional dependencies. Animators can facilitate understanding of the additional complexities. With the improved understanding of object-oriented metrics and their usefulness in predicting effort and cost of software reuse we propose that a selection of design and performance metrics could be collected and maintained as part of the software components as an integral part of the development process towards continuous quality improvement through reuse.

[372] Mili, H., F. Mili, et al., 'Reusing software: issues and research directions', IEEE Trans. on Softw. Eng., 21(6), pp528-562, 1995.

Keywords: Reuse, Rev

Abstract: Not specifically about metrics but a very comprehensive analysis with 163 refs.

[373] Miller, B. K., H. Pei, et al. 'Object-oriented architecture measures', in Proc. 32nd Annual Hawaii International Conference on Systems Sciences. IEEE Comput. Soc, Los Alamitos, CA, USA, 1999.

Keywords: Prod, Qual

Abstract: Early elimination of poor design architecture allows software to be constructed that is more extendible, flexible, maintainable, and thus less expensive. Currently, there exist few object-oriented design architecture measures to aid in this task. Many contemporary object oriented software measures fail to address the intrinsic components of the object-oriented paradigm: hierarchy, inheritance, identity, polymorphism, and encapsulation. By focusing upon the intrinsic components of the object-oriented paradigm, it is hoped a better set of measurements can be created which help to distinguish between those architectures that follow object-oriented principles and those that do not. This research proposes four new software measures that attempt to measure the strength of these intrinsic concepts in an object-oriented design. These measurements are derived from available principles of object-oriented design which are relatively new to research.

[374] Miller, G., M. Woof, et al., Project MOOD: Business structure. Technical Report No. PS-MOOD-CS-000003, Parallax Solutions Limited, 1996.

[375] Miller, G., M. Woof, et al., Project MOOD: Requirements capturing approach. Technical Report No. PS-MOOD-CS-000002, Parallax Solutions Limited, 1996.

[376] Miller, G., M. Woof, et al., Project MOOD: Survey results. No. PS-MOOD-CS-000005, Parallax Solutions Limited, 1996.

Keywords: Emp

[377] Mingins, C. 'Designing software metrics (Tutorial presentation abstract )', in Proc. TOOLS 17. Prentice Hall , New York, 1995.

Keywords: Des, Rev

Abstract: This tutorial examines the problems inherent in measuring software, and presents a method for designing, constructing and validating metrics by taking a simple example through the following process: Establishing a goal ... Listing the criteria ... Constructing an informal model ... Transforming this to a formal model ... Empirically evaluating the model."

Notes: Slides etc from TOOLS at <tools@tools.com> or see web page http://www.tools.com. Christine Mingins is at mingins@fcit.monash.edu.au.

[378] Mingins, C., B. Durnota, et al. 'Collecting Software Metrics Data for the Eiffel Class Hierarchy', in Proc. TOOLS. 1993.

Keywords: Tool, Prod

Abstract: Annotation from C. Gibbon.

A few metrics are discussed but the emphasis here is on the software tools procured and developed to collect data about classes and inheritance hierarchies. Their metrics include method calls, cluster analysis to obtain coherence metrics and reuse metrics enacted upon class hierarchies. They reference theirs and other papers specifically geared towards software measurement.

[379] Misic, V. B. and S. Moser. 'From formal metamodels to metrics: an object-oriented approach', in Proc. Technology of Object-Oriented Languages. TOOLS 24. IEEE Comput. Soc, Los Alamitos, CA, USA, 1998.

Keywords: Theory, Size

Abstract: Classical system development techniques often cannot cope with the ever increasing size and complexity of modern software systems. Promising ways to overcome this are formal methods and metamodels, which should provide precision and provable consistency of system specifications, as well as the better understanding of the software development process through modeling the process itself. In this paper a generic metamodel of object-oriented systems is specified using the Z formal notation. The metamodel is, then, applied towards derivation of complexity metrics, including the well-known function point measure and

a recently introduced generic measure, the System Meter. Both applications demonstrate the genericity of the approach.

[380] Misic, V. B., D. Tesic, et al. 'Downsizing the estimation of software quality: a small object-oriented case study', in Proc. Technology of Object-Oriented Languages. TOOLS 27. IEEE Comput. Soc, Los Alamitos, CA, USA, 1998.

Keywords: Qual

Abstract: It would be beneficial if the quality of a software system could be estimated early in its lifecycle. Although many estimation methods exist, it is questionable whether the experiences gained in large software projects can successfully be transferred to small scale software development. The paper presents results obtained from a number of projects developed in a small company with limited resources. The projects were analyzed in order to find out metrics which would be suitable for early estimation of quality. A number of possible models were evaluated and discussed.

[381] Misic, V. B. and D. N. Tesic, 'Estimation of effort and complexity: an object-oriented case study', Journal of Systems and Software, 41(2), pp133-143, 1998.

Keywords: Size

Abstract: The metrication of object-oriented software systems is still an underdeveloped part within the domain of the object paradigm. An empirical investigation aimed at finding appropriate measures and establishing simple, yet usable and cost-effective models for the estimation and control of object-oriented system projects, was undertaken on a set of object-oriented projects implemented in a stable environment. First, the measures available were screened for possible correlations; then, models that were suitable for estimation were derived and discussed. Effort was found to correlate well with the total number of classes and the total number of methods, both of which are known at the end of the design phase. A number of other models for estimation of the source code complexity were also defined.

[382] Mitchell, J., J. E. Urban, et al., 'The effect of abstract data types on program development', IEEE Computer, 20(August), pp85-88, 1987.

Keywords: Des, Emp

Abstract: "An experiment demonstrated that using unsupported abstract data types increases program development time for novice programmers in an Ada environment". The amount of code produced was found to be not significantly different between the experimental and control groups but productivity decreased by 33% and code was 20% slower (significant at 1% level). They refer to quality of code when obviously they only measuring size and some aspects of structural complexity.

[383] Monarchi, D. E. and G. I. Puhr, 'A Research Typology for Object-Oriented Analysis and Design', Communications of the ACM, 35(9), pp35-47, 1992.

Keywords: Rev

Abstract: Annotation from [Webster, 1994]: "This paper develops a framework for the comparison of OOA and OOD approaches. OO approaches are divided into those that describe a process; those that describe a

notation; and those which offer a notation with a process. The critical components in OOAD are: problem domain analysis; solution domain design; representations and complexity management. These components are expanded into further subdivisions in the paper. The methods, 23 of them, are grouped into the three headings are presented in a table cross-referenced against the four critical components. More ticks in the boxes means the method is more complete. Booch, Coad and Yourdon and Rumbaugh do best. An analysis method only has ticks in the analysis boxes. The paper may serve as an introduction to a range of OO methods."

[384] Moreau, D. R. and W. D. Dominick, 'Object-oriented graphical information systems: research plan and evaluation metrics', Journal of Systems and Software, 10, pp23-28, 1989.

Keywords: Emp

Abstract: Programmer productivity is not related to size.

[385] Moreau, D. R. and W. D. Dominick, 'A programming environment evaluation methodology for object-oriented systems: part II - test case application', Journal of Object-Oriented Programming, 3(3), pp23-32, 1990.

Keywords: C++, Emp

Abstract: Presents an application of the programming environment evaluation methodology developed in [Moreau, 1990, "A programming environment evaluation methodology for object-oriented systems: part I - the methodology"] to a specific application domain and set of application development environments: compares C and C++ graphics applications. Concludes that C++ is significantly different from C for this application (often 50% of the development time).

[386] Moreau, D. R. and W. D. Dominick, 'A programming environment evaluation methodology for object-oriented systems: part I - the methodology', Journal of Object-Oriented Programming, 3(3), pp38-52, 1990.

Keywords: C++, Emp

[387] Morisio, M. 'Issues in defining and applying a measurement plan to an object oriented process', in Proc. 4th Software Quality Conference. Dundee, Scotland: University of Abertay, Dundee, UK, 1995.

Keywords: Man, Qual

Abstract: This paper reports on how the software process in the ESSI AEFTA application experiment has been measured. Measurement is considered as a full scale project consisting of (1) modelling the software process, (2) defining goals for the project, (3) formalizing goals in process measures defined on the process model, (4) designing the technological support for measures (procedures and tools, repository), (5) implementing the technological support, (6) implementing the measurement process, (7) assessing the measurement process, modifying it, if needed. The object oriented (OO) approach has been applied in 1, 4 and 5. The process model is defined using OMT; process measures are defined using a query language to express queries on OMT object models; the repository for measures is obtained by automatic translation of the OMT process model into a set of persistent C++ classes; process measures are manually translated in C++ functions members of the persistent classes. The advantages of applying the OO approach are discussed: sharing of tools, training, know-how and mindset with the rest of the project; ease in changing measures to adapt to changes in the process, thus possibility of applying an evolutionary incremental lifecycle to the measurement

process; lower effort in the implementation of the technological support for measurement.

Notes: Similar to [Morisio, 1995, "Measuring reuse in an object-oriented process"] only a bit older.

[388] Morisio, M. 'Measuring reuse in an object-oriented process', in Proc. 8th Intl. Conf. on Software Engineering and its Applications. Paris-La-Defense: 1995.

Keywords: Reuse

Abstract: Proceedings available from the organisers: EC2, Paris-La-Defense Cedex, Jeanclaude.Rault@&utopia.fnet.fr.

[389] Morisio, M. 'A methodology to measure the software process', in Proc. Annual Oregon Workshop on Software Metrics. Silver Falls, Oregon: 1995.

Keywords: Man, Qual

Abstract: "This paper proposes a method to measure the software process that is based on a model of the software process. Object oriented concepts and techniques are used to build the model and measures are defined as an extension of the model. The 7-step measurement approach is as given in [Aarsten, 1996]. The paper presents the method and a case study on which it has been applied.

Notes: Maurizio Morisio is at morisio@polito.it.

[390] Morris, K. L., Metrics for Object-Oriented Software Development Environments. Masters Thesis , M.I.T., 1988.

Keywords: Prod

Notes: Massachusetts Institute Of Technology, 50 Memorial Drive, Cambridge, Massachusetts 02139 USA, tel: +44 1 617 253 2971.

[391] Morschel, I., Applying object-oriented metrics to enhance software quality, in Theorie und Praxis der Softwaremessung, R. Dumke and H. Zuse, Editors, Deutscher Universitaetsverlag: Wiesbaden, Germany, 1994.

Keywords: Des, Small, Qual

[392] Morschel, I. and C. Ebert. 'Applying metrics for quality analysis and improvement of object-oriented software', in Proc. 3rd International Conference on Achieving Quality in Software. Chapman and Hall, 1996.

Keywords: Prod, Small, Tool

Abstract: Software metrics are playing an important role in analysing and improving the quality of software work products during their development. Measuring the aspects of software complexity for object-oriented software strongly helps to improve the quality of such systems during their development, while especially focusing on reusability, reliability and maintainability. It is widely accepted that more widespread use of

object-oriented techniques can only come about when there are tool systems that provide development support beyond visualizing code. Distinct complexity metrics have been developed and integrated in a Smalltalk development support system called SmallMetric. Thus, we achieve a basis for software analysis (metrics) and development support (critique) of Smalltalk systems. The main concepts of the environment including the underlying metrics are explained, its use and operation is discussed, and some results of the implementation and its application to several projects are given with examples.

Notes: ISBN 0-412-63900-9Ebert is at Alcatel SEL AG, EBERTC@btmaa.bel.alcatel.be.

[393] Moser, S., 'Metamodels for object-oriented systems: a proposition of metamodels describing object-oriented systems at consecutive levels of abstraction', Software Concepts and Tools, 16(2), pp63-80, 1995.

Keywords: Size, Theory

Abstract: Metamodelling is a rather modern approach to software engineering. Its roots go back to philosophical work on ontology by Bunge (1977) and on general systems theory by Mesarovic and Takahara (1975). Metamodels formally show the structure of models, e.g., software or other higher level descriptions of systems. They play the same role as entity/relationship models or object models for application domains, yet for the domain of software development itself. The practical purposes of metamodels thus are analogous to those of domain object models: they are a sound starting point for the analysis of the domain's processes, i.e., software processes, and for implementing automated tools that support those processes. This article presents the five layers of system models (or system descriptions). Some selected parts of the layer's metamodels are then presented and commented. One of the many practical uses of metamodelling is finally demonstrated by the derivation of a measure of system size for estimating the development effort.

[394] Moser, S., B. Henderson-Sellers, et al. 'Measuring object-oriented business models', in Proc. Technology of Object-Oriented Languages and Systems, TOOLS 25. IEEE Comput. Soc, Los Alamitos, CA, USA, 1998.

Keywords: Size

Abstract: Early and accurate measurement of software products is an essential prerequisite for successful estimation and control of software development projects. Existing measurement techniques, however are inadequate in the context of newly emerging object oriented modelling approaches. The paper proposes a new measure, the System Meter, which is simple and intuitive, formally sound, takes reuse explicitly into account and can be easily automated. Empirical studies have shown that the System Meter is a better effort predictor than the well known Function Points.

[395] Moser, S. and V. B. Misic. 'Measuring class coupling and cohesion: a formal metamodel approach', in Proc. Asia Pacific Software Engineering Conference and International Computer Science Conference ;. IEEE Comput. Soc, Los Alamitos, CA, USA, 1997.

Keywords: Prod, Theory

Abstract: Metamodeling, object-orientation and formal methods are three promising ways to cope with the increasing size and complexity of today's software systems. Furthermore, effective control of development projects requires the use of versatile metrics for software size and complexity. We present a generic formal object-oriented metamodel (GM), specifically tailored for modeling object-oriented software systems, and use

it as the foundation for defining two basic measures of structural quality: coupling and cohesion. Even though these two notions are generic, we restrict ourselves to defining them at the class level, which is probably the most useful for object-oriented systems. The metrics have a generic formal definition, which makes them simple, intuitive, and amenable to automated measurement.

[396] Moser, S. and O. Nierstrasz, 'The Effects of Object-Oriented Frameworks on Developer Productivity', IEEE Computer, 29(9), pp45-51, 1996.

Keywords: Man, Prod, Tool

Abstract: Cost and time estimation are difficult problems in software development projects. Software metrics tackle this problem by assuming a statistical correlation between the size of a software project and the amount of effort typically required to realize it. To be useful in estimating cost, a size metric must take into account the inherent complexity of the system. Such metrics have been applied with varying degrees of success, but the nature of software development has been changing, and some of the assumptions behind the established cost-estimation techniques are slowly being invalidated. The System Meter (SM) is a new software sizing approach based on the notion of system description. System descriptions encompass all kinds of software artifacts, from requirement documents to final code. For each kind or level of artifacts, there is a corresponding flavor of SM. In our studies we used the first operational flavor, the SM at the preliminary analysis level, or Pre-SM. In contrast to the well-known Function Point (FP) metric, which is measurable after the more detailed but costly phase of domain analysis only, the SM explicitly takes OO concepts into account. It also distinguishes between components to be developed and those to be reused, thus reflecting the idea of incremental functionality. We present results of a field study of 36 projects developed using object technology. We measured both FP and the Pre-SM method in all 36 projects and compared their correlation to the development effort.

Notes: Visit Simon Moser's homepage at: http://iamwww.unibe.ch/~moser for downloading UNIX-compressed postscript files.

[397] Moses, J. 'Re-usability and extendability in object-oriented and object-based design', in Proc. Software Quality Management II. Building Quality into Software. Comp. Mech. Publications, Southampton, UK, 1994.

Keywords: Maint, Reuse

Abstract: The paper considers the object-oriented paradigm's ability to produce reusable and extendable software. In so doing it identifies the strengths and weaknesses of the paradigm, with respect to reusability, and compares these with those of a several representative object-based methods. Further, consideration is given to the main method of achieving reusability in the object-oriented paradigm, i.e. the inheritance hierarchy. The impact inheritance can have on the maintainability of the software components produced is considered using an information flow complexity metric. The paper concludes that although the object-oriented paradigm assists in producing reusable and extendable software it must be well supported by software tools; and, careful control and management of the development of components for reuse must be undertaken, if a reasonable level of maintainability is also to be achieved.

[398] Nakanishi, K. and T. Arano. 'A metric for evaluating effectiveness of object-oriented interface abstraction for promoting software reuse', in Proc. Object Technologies for Advanced Software. Second JSSST International Symposium ISOTAS'96. Springer-Verlag, Berlin, Germany, 1996.

Keywords: Reuse, Prod

Abstract: A metric is proposed for measuring the effectiveness of object oriented interface abstraction for controlling the reuse of software in individual object oriented programs. Object oriented languages permit flexible design of software component interfaces through class, inheritance, and polymorphism. To reliably measure the effectiveness of the effort spent on abstraction on software reuse, we need to estimate the effectiveness program by program. The proposed method measures the effort and effectiveness, and derives from the relation between them a metric for evaluating how effectively interface abstraction promotes software reuse in individual object oriented programs. Application to different versions of class library InterViews shows that the results of the metric measurement agree with the analysis of the user manuals in that the metric value decreases immediately after refinement of class hierarchy and increases in the stage of functional extension after refinement of the class hierarchy.

[399] Nakanishi, K., T. Arano, et al. 'A metric for evaluating class library interfaces and its application to library upgrades', in Proc. Intl. Conf. on Softw. Maintenance (ICSM'95). Nice, France: IEEE, 1995.

Keywords: Des, Prod

Abstract: The proposed metric for evaluating class library interfaces measures the balance between generalization and specialization. The key idea of the proposed metric is the fact that polymorphic operations satisfy Zipf's law, which is known as an approximating equation for the frequency of words in natural language. The metric shows the global property of an entire class library, independent of size (making it possible to compare class libraries of different sizes and different versions), and to avoid the problems associated with using the depth of the inheritance graph as the metric. The results of application of this metric to two upgrades of the InterViews C++ class library agree with the results of manual analysis on three points: the metric value for the groups whose interfaces are generalized are larger than the metric value of other groups which are not as generalized, the metric value increases when a class interface is generalized by creating abstract classes, and the metric value decreases when new specialized-functional extension classes are added to the class library.

[400] Nakanishi, K., T. Arano, et al. 'Understandability of class libraries and Zipf's law', in Proc. Technology of Object-Oriented Languages and Systems Tools 12. Prentice Hall, Englewood Cliffs, NJ, USA, 1993.

Keywords: Prod

Abstract: This paper applies Zipf's law to class libraries. Zipf's law is established law in linguistics that is associated with the principle of least effort needed to read a text. Zipf's law states the statistical properties of natural language regard to the frequency of word occurrence. The first experiment confirms that Zipf's law can be applied to class libraries. The second experiment clearly shows that class hierarchy affects one parameter of Zipf's law. Based on the results of these experiments, this paper discusses the relationship between the parameters of Zipf's law and the usage of inheritance. The problems associated with using Zipf's law as a software metric are discussed for evaluating the understandability of class libraries.

[401] Neal, R. D. 'The applicability of proposed object-oriented metrics to developer feedback in time to impact development', in Proc. Advances in Concurrent Engineering, CE 96. Third ISPE International Conference on Concurrent Engineering Research: Research and Applications. Technomic Publishing, Lancaster, PA, USA, 1996.

Keywords: Prod, Theory

Abstract: This paper looks closely at each of the software metrics generated by the McCabe Object-Oriented Tool/sup TM/ and its ability to convey timely information to developers. The metrics are examined for meaningfulness in terms of the scale assignable to the metric by the rules of measurement theory and the software dimension being measured. Recommendations are made as to the proper use of each metric and its ability to influence development at an early stage.

[402] Neal, R. D. 'Modeling the object-oriented space through validated measures', in Proc. 1997 IEEE Aerospace Conference. Proceedings. IEEE, New York, NY, USA, 1997.

Keywords: Theory

Abstract: In order to truly understand software and the software development process, software measurement must be better understood. A beginning step toward a better understanding of software measurement is the categorization of the measurements by some meaningful taxonomy. The most meaningful taxonomy would capture the basic nature of the object-oriented (O-O) space. The interesting characteristics of object-oriented software offer a starting point for such a categorization of measures. A taxonomy has been developed based upon fourteen characteristics of object-oriented software gathered from the literature. This taxonomy allows us to easily see gaps and redundancies in the O-O measures. The taxonomy also clearly differentiates among taxa so that there is no ambiguity as to the taxon to which a measure belongs. The taxonomy has been populated with thirty-two measures that have been validated in the narrow sense of Fenton (1991) using measurement theory with Zuse's (1996) augmentation.

[403] Neal, R. D. 'A taxonomy of object-oriented measures', in Proc. Software Quality Engineering. Comput. Mech. Publications, Southampton, UK, 1997.

Keywords: Theory

Abstract: Software and software development are extremely complex. We should not expect to measure something so complex with one, two, or even a dozen measures. Measures have to be developed to allow us to view software from many perspectives. To facilitate this process, this paper builds on taxonomies proposed by Abreu et al. (1995) and Tegarden et al. (1995) that not only allow us to classify measures but also help us model the object-oriented space. In this paper, a metric is any proposed measurement (not necessarily validated); a measure is a validated metric, i.e., all measures are metrics but not all metrics are measures.

[404] Nesi, P., 'Managing OO projects better', IEEE Software, 15(4), pp50-60, 1998.

Keywords: Man, Emp

Abstract: "Nesi reveals that estimation of effort is key to managing OO development projects, then documents a few rules of thumb for doing this. One lesson he's learned from using these rules is that estimates for a whole project are not reliable if estimates for subcomponents are simply added up. As the project size increases, so does the overhead for communication and general interaction. Nesi goes beyond effort metrics and recommends that you collect metrics throughout the project and use them for continuous revalidation of assumptions and project performance. If we accept that ''what you can't measure, you can't manage,'' this is good advice."

[405] Nesi, P. and M. Campanai, 'Metric Framework for Object-Oriented Real-Time Systems Specification Languages', Journal of Systems and Software, 34, pp43-65, 1996.

Keywords: Tool, Reuse, Test

Abstract: A framework for maintaining control of and analyzing object-oriented system specifications of real-time systems by using a set of metrics covering technical, cognitive, and process-oriented views is presented. The indicators defined can be used for monitoring the evolution of system quality and for effort prediction. The use of metrics for the estimation of reusability, verifiability, and testability is analyzed. The metric framework is integrated in a CASE tool named TOOMS, which is based on TROL, a dual object-oriented language with both descriptive and operational capabilities. TOOMS allows one to describe the system at different levels of structural abstractions and at different levels of specification detail, such as many other languages and models for real-time systems (e.g., OSDL, ObjectTime, ObjectChart). According to this, the metrics proposed are capable of producing estimations at each level of system specification, thus allowing incremental specification/metrication. The metric framework must be regarded as a support for controlling the process of software development in order to guarantee the final quality.

[406] Nesi, P. and T. Querci, 'Effort Estimation and Prediction of Object-Oriented Systems', Journal of Systems and Software, 42(1), pp89-102, 1998.

Keywords: Size, Man

Abstract: Due to the growing diffusion of the object-oriented paradigm (OOP) and the need of maintaining under control the process of software development, industries are looking for metrics capable of producing satisfactory effort estimations and predictions. These metrics have to produce results with a known confidence since the early phases of the software life-cycle in order to establish a process of prediction and correction of costs. To this end, specific metrics are needed in order to maintain under control object-oriented system development. In this paper, new complexity and size metrics for effort evaluation and prediction are presented and compared with respect to the most important metrics proposed for the same purpose in the literature. The validation of the most important of these metrics is also reported.

[407] ObjectSoftware_Inc, 'ObjectDetail - a tool to measure object metrics and error densities in an application', (May), 1995.

Keywords: Tool, Prod

[408] Offut, A. J. and A. Irvine. 'Testing object-oriented software using the category-partition method', in Proc. TOOLS 17. Prentice Hall, New York, 1995.

Keywords: Emp, Test

Abstract: Faults were injected into a C++ system and were then located using category partition testing. The aim was to see if this traditional testing technique remained appropriate for OO. From the conclusions: "This paper presents empirical data that show that the category-partition testing technique can be effective at finding faults in object-oriented software. We see no evidence that existing testing techniques are ineffective for testing object-oriented software, and conclude that new techniques may not be needed."

Notes: A. Jefferson Offutt is at ofut@isse.gmu.edu.

[409] Oivo, M., 'Incremental resource estimation with real-time feedback from measurement',

Microprocessing-&-Microprogramming, 38(1-5), pp281-289, 1993.

Keywords: Size

Abstract: The quality and usability of software project estimation models can be substantially improved by integrating metrics in the software development process to provide feedback in real-time. Active metrics can be used to adjust and improve the initial estimates by including data from the early phases of software development. A method is proposed for incrementally proceeding from a priori project estimation and modelling to measuring the project and product during development to provide real-time feedback and refinement to the initial estimation. This method enables the estimates to be incrementally developed and to use them to control and guide project execution in real-time. A hierarchical system or project decomposition can be used to implement distributed estimation models which include a constraint propagation network. These techniques are based on an extended object-oriented modelling technique for software engineering elements.

[410] Ojha, N. and J. D. McGregor, Object oriented metrics for early system characterization: a CRC card based approach. Technical report No. TR 94-107, Clemson University, 1994.

Keywords: Size, Des

Notes: Contact: Department of Computer Science, Clemson University,Clemson, SC 29634-1906. John D. McGregor is at johnmc@cs.clemson.edu. An abstract of the TR is available by anon ftp: ftp://ftp.cs.clemson.edu/techreports/94-107.ps.Z.

[411] Ong, C. L. and W. T. Tsai, 'Class and object extraction from imperative code', Journal of Object-Oriented Programming, 6(1), pp58-60, 62-68, 1993.

Keywords: Emp, Tool

Abstract: The article studies class and object extraction from existing systems for translation to a class-based or object-oriented language. The effects of functional decomposition and object-oriented design on the resulting code are examined. Heuristics and algorithms to extract instance variables of objects from imperative code are presented. Data flow analysis is used to analyze variable usage in a program; the results are used to extract methods. The languages Fortran 77 and C++ are widely used in the implementation stage of the object-oriented and the imperative paradigms. A prototype extractor was developed that automatically extracts classes and objects from code written in Fortran 77 and translates them into class-based code in C++. In an experiment with an 18 KLOC Fortran application, the prototype identified 6 KLOC of code as potential components of classes. Further analysis showed that much of the extracted code was repeated, and if the software is reengineered in an object-oriented version much redundancy can be eliminated. The prototype is also useful for the task of program understanding. (46 Refs.).

[412] Ott, L. M. and J. M. Bieman. 'Effects of Software Changes on Module Cohesion', in Proc. Intl. Conference on Software Maintenance. IEEE, 1992.

Keywords: Prod

[413] Pai, W. C. and C. C. Wang, 'A formal approach to object-oriented software testing and complexity measurement with Z', International Journal of Computers & Applications, 20(3), pp147-158, 1998.

Keywords: Theory, Test, Prod

Abstract: In the software industry, formal specification aids precision. One popular formal specification language is Z. In this paper, the authors focus on the testing criteria and metrics evaluation of an inheritance hierarchy and propose an algorithm, which is proved to be consistent and sound, to decompose an inheritance hierarchy into basic elements named URI (unit repeated inheritance). Z notation is used to model the inheritance hierarchy and describe an ILT (inheritance level technique) method based on URIs as a guide to detect software errors hidden behind the inheritance hierarchy and measure the software complexity of the inheritance hierarchy. The measurement of inheritance metrics and two testing criteria thus can be formed based on the proposed mechanism.

[414] Pant, Y., B. Henderson-Sellers, et al., 'Generalization of Object-Oriented Components for Reuse: Measurement of Effort and Size Change', JOOP, 9(2), pp19-41, 1996.

Keywords: Size, Reuse

Abstract: Generalization of object-oriented (OO) components requires additional effort beyond that required to develop classes for a specific application. In a pilot experiment, we have applied a number of metrics, including the new S/C metric to test a number of statistical research hypotheses related to (1) the correlation between different traditional metrics for o-o programs, (2) software development and generalization effort, and (3) the change in size of classes as a result of generalization. The results indicate that (1) the new S/C measure is different from the measures lines of code, tokens, statement counts, and cyclomatic complexity; (2) on average, the cost of generalization is 55% that of the original development; and (3) there are two opposing forces that affect size upon generalization: completion of abstractions, which tends to increase size, and developing inheritance structures, which generally decreases size.

[415] Pant, Y. R., J. M. Verner, et al. 'S/C: a software size/complexity measure', in Proc. 1st IFIP/SQI International Conference on Software Quality and Productivity (ICSQP'94). Hong Kong: 1994.

Keywords: Size, Prod

[416] Park, S., E. S. Hong, et al., 'Metrics measuring cohesion and coupling in object-oriented programs', Journal of KISS, 25(12), pp1779-1787, 1998.

Keywords: Prod

Abstract: As object-oriented (OO) programming and methodology are becoming more popular, measuring the quality of OO design becomes important since it determines high-level quality factors such as maintainability and reusability. Traditional software metrics and evaluation criteria for procedural programs are, however, unsuitable to measure the quality of OO design. We suggest new metrics measuring cohesion and coupling, which play an important role in the OO concept. So far, there has been much research on OO cohesion and coupling metrics, but they have generally suffered from several problems such as low discrimination. Thus, we provide more discriminating metrics which are two cohesion metrics and three coupling metrics. Our metrics can provide the ability of comparing inheritance trees as well as classes.

[417] Paul, R., C. L. Chee, et al. 'Data models for metrics-based project management systems', in Proc. The Twentieth Annual International Computer Software and Applications Conference (COMPSAC '96). IEEE

Comput. Soc. Press, Los Alamitos, CA, USA, 1996.

Keywords: Man

Abstract: A metrics based project management system (MPMS) integrates software metrics data, management queries based on the software metrics data, as well as their responses in a single location. Given the variations in projects, queries, metrics and physical databases to be used, MPMSes should be flexible from a user point of view, and also generic from a designer point of view. Two important steps in the design of an MPMS involve the determination of typical queries that may be posed by users, as well as the selection of the physical database for storing metrics and other project related knowledge. The paper discusses the relative advantages and drawbacks of three selected physical database models, namely the relational data model, object oriented data model, and graph data model, based on a variety of classes of metrics based queries. We conclude that the choice of data model varies according to the class of queries, and has strong implications on the ease and efficiency with which metrics based queries may be posed and executed.

[418] Paul, R., Y. Shinagawa, et al. 'Object-oriented framework for metrics guided risk management', in Proc. The Twentieth Annual International Computer Software and Applications Conference (COMPSAC '96). IEEE Comput. Soc. Press, Los Alamitos, CA, USA, 1996.

Keywords: Man, Qual

Abstract: We present a framework for managing large software projects using metrics. The collection and analysis of metrics data serve as a consistent mechanism for risk identification and quality management. The crux of this mechanism is the temporal modeling of metrics data. We present a comprehensive set of temporal operators which serve as the building block for the formal specification of users' views of risk and quality. The notion of temporal inheritance can be used to define an object oriented query language.

[419] Paul, R. A., T. L. Kunii, et al. 'Object-oriented evolutionary database design for software metrics data', in Proc. Twenty-First Annual International Computer Software and Applications Conference (COMPSAC'97). IEEE Comput. Soc, Los Alamitos, CA, USA, 1997.

Keywords: Man, Theory

Abstract: The authors present an approach to manage evolutionary changes that take place over time in an object-oriented software metrics database schema. The framework is based on the entity-relation (E-R) model and uses a recursive graph structure, known as R-graph, to support the views of software quality and risk. The fundamental mechanism for abstracting views is the introduction of two semantic operators for the R-graph. These operators are proposed based on graph-based predicates and Petri-net based predicate formalism for view abstraction.

[420] Paul, S. and A. Prakash, 'A query algebra for program databases', IEEE Transactions on Software Engineering, 22(3), pp202-217, 1996.

Keywords: Theory, Tool

Abstract: Querying source code is an essential aspect of a variety of software engineering tasks such as program understanding, reverse engineering, program structure analysis and program flow analysis. In this paper, we present and demonstrate the use of an algebraic source code query technique that blends expressive power with query compactness. The query framework of Source Code Algebra (SCA) permits users to

express complex source code queries and views as algebraic expressions. Queries are expressed on an extensible, object-oriented database that stores program source code. The SCA algebraic approach offers multiple benefits such as an applicative query language, high expressive power, seamless handling of structural and flow information, clean formalism and potential for query optimization. We present a case study where SCA expressions are used to query a program in terms of program organization, resource flow, control flow, metrics and syntactic structure. Our experience with an SCA-based prototype query processor indicates that an algebraic approach to source code queries combines the benefits of expressive power and compact query formulation.

[421] Pereira, C. E. and P. Darscht. 'Using object-orientation in real-time applications: an experience report or (1 application+5 approaches=1 comparison)', in Proc. Technology of Object-Oriented Languages and Systems, TOOLS 13. Prentice Hall, Hemel Hempstead, UK, 1994.

Keywords: Emp

Abstract: This paper presents some results we have obtained applying object-oriented concepts to the development of real-time applications. It also compares these results with those obtained applying methods based on the functional decomposition. For the sake of restricting the paper`s length, two aspects will mainly be focused on: a) The degree of seamlessness achieved by using object-oriented methods along all the development process of a real-time system; b) A comparison among five versions of the software for real-time process control, monitoring and diagnosis of a package routing system, tending to determinate the impact of an object-oriented programming language applied to implement software for real-time systems. Software quality metrics have been used in order to quantify attributes of the resulting software and to allow a better judgement of the strengths and weaknesses of the approaches.

[422] Perry, D. E. and G. E. Kaiser, 'Adequate testing and object-oriented programming', Journal of Object-Oriented Programming, 2(5), pp13-19, 1990.

Keywords: Test

Abstract: Discusses the applicability of Elaine Weyuker's testing axioms ("Axiomatizing software test data adequacy", IEEE Trans. Software Eng., 12 (12) 1986, 1128-1138.) to the OO paradigm. They conclude that inheritance may be a cause of problems in testing.

Notes: Dewayne Perry is at AT&T Bell Labs, Murray Hill, NJ 07974; Gail Kaiser is at Columbia University, NY 10027.

[423] Pfleeger, S., R. Jeffery, et al., 'Status Report on Software Measurement', IEEE Software, 14(2), pp33-43, 1997.

Keywords: Theory, Man

Abstract: The most successful metrics programs are ones in which researcher, practitioner and customer work hand in hand to meet goals and solve problems. But such collaboration is rare. The authors explore the gaps between these groups and point toward ways to bridge them.

[424] Pfleeger, S. L. and J. Palmer. 'Software estimation for object-oriented systems', in Proc. International Function Point Users Group Fall Conference. San Antonio, TX: 1990.

Keywords: Size

[425] Philip, T. and R. Ramsundar, 'A reengineering framework for small scale software', SIGSOFT Software Engineering Notes, 20(5), pp51-55, 1995.

Keywords: Reuse, Maint, Emp

Abstract: Reengineering software is approached in different ways, even though the basic process remains the same: reverse engineering followed by forward engineering. Tools are available to aid during reverse engineering and reengineering. The paper presents a framework we used to reengineer a small scale software system from a partial structured implementation to an object oriented implementation. The framework uses function matrix to organize the extracted abstractions, algorithm tables, and data dictionary during its initial phase. Components for the target system object model are retrieved from the matrices and the dictionary. An empirical reuse metric was applied to the matrix to identify reusable parts. Application of this framework is also discussed.

[426] Pintado, X., The affinity browser, in Object-Oriented Software Composition, O. Nierstrasz and D. Tsichritzis, Editors, Prentice Hall: 1995.

Keywords: Reuse, Tool

Abstract: "Large numbers of classes, complex inheritance and containment graphs, and diverse patterns of dynamic interaction all contribute to difficulties in understanding, reusing, debugging, and tuning large object-oriented systems. These difficulties may have a significant impact on the usefulness of such systems. Tools that help in understanding the contents and behaviour of an object-oriented environment should play a major role in reducing such difficulties. Such tools allow for the exploration of different aspects of a software environment such as inheritance structures, part-of relationships, etc. However, object-oriented systems differ in many respects from traditional database systems, and in particular, conventional querying mechanisms used in databases show poor performance when used for the exploration of objectoriented environments. This chapter defines the requirements for effective exploration mechanisms in the realm of object-oriented environments. We propose an approach to browsing based on the notion of affinity that satisfies such requirements. Our tool, the affinity browser, provides a visual representation of object relationships presented in terms of affinity. Objects that appear closer in the visual representation are more strongly related than objects lying farther apart. So, the intensity of a relationship is translated into distance in the visual representation that provides the support for user navigation. We provide many examples of metrics defined over the objects of an environment to illustrate how object relationships can be translated in terms of affinity so that they can be used for the exploration of an environment."

[427] Pittman, M., 'Lessons learned in managing object-oriented development', IEEE Software, 10(January), pp43-53, 1993.

Keywords: Man, Size

Abstract: Contains a discussion of planning and estimation which focuses on COCOMO, for which he gives some slightly adjusted cost drivers.

Notes: Matthew Pittman is at Pittman Consulting Ltd, pittman@cix.compulink.co.uk.

[428] Poels, G. 'Towards a size measurement framework for object-oriented specifications', in Proc. European Software Measurement Conference. FESMA 98. Technologisch Instituut Vzw, Antwerpen, Germany, 1998.

Keywords: Size, Theory

Abstract: A size measurement framework is presented for object-oriented specifications. The measurement of size sub-attributes of object-oriented specifications has not received the same attention as the measurement of the structure of object-oriented systems, in particular object-oriented designs. To the best of our knowledge, fundamental questions such as what is the size of object-oriented specifications and how does one measure the size of object-oriented specifications have not been satisfactorily answered. Apart from the size measurement framework we present a formal size measure definition approach based on the mathematical definition of distance. It is shown that size subattributes can be defined in terms of distances between measurement objects and that metrics can be used to measure size.

[429] Poels, G. and G. Dedene. 'Formal measurement in object-oriented software', in Proc. Object Technology '96. Christchurch College Oxford: 1996.

Keywords: Theory

[430] Ponder, C. and B. Bush, 'Polymorphism considered harmful', ACM SIGPLAN Notices, 27(6), pp76-79, 1992.

Keywords: Des, Small

[431] Ponder, C. and B. Bush, 'Polymorphism considered harmful', ACM SIGSOFT Software Engineering Notes, 19(3), pp35-37, 1994.

Keywords: Des, Small

Abstract: Presumably the same as [Ponder, 1992]? They compare the abuse of polymorphism to abuse of the GOTO. In support, they give data from a Smalltalk 80 compiler on number of defs. of procedures, number of types responding to a proc. name, and number of procs. of a given size.

[432] Poulin, J. S., 'Fueling software reuse with metrics', Object Magazine, 7(7), pp42-46, 1997.

Keywords: Reuse, Man

Abstract: Software reuse has become a widely-accepted way to reduce costs, shorten cycle times and improve quality in large-scale enterprises. Unfortunately, very few object-oriented programs have a method to actually quantify and realistically estimate the results that they have achieved. To do this, the program must have objective, easy-to-acquire and easy-to-understand metrics. Object-orientation (OO) brings many opportunities for clarifying design, modeling real-world problems and reducing the costs of maintenance. The concepts and language features of OO also make it easier to reuse objects in more than one application. OO practitioners cite reuse as one of the principle advantages of OO. Most people involved in software development intuitively agree that reuse has many benefits. Consequently, software developers derive a good part of their motivation to reuse from an expectation of financial reward. For reuse to occur, however, someone has to organize, plan

for and develop the assets, software and people for others to reuse. Business decisions drive reuse. Even though most people might intuitively believe that reuse will eventually yield financial advantages, few have enough conviction to risk their current budget for the benefit of others. Because OO facilitates reuse, reuse metrics can help build a decisive business case for OO investments. Using simple models and basic assumptions, reuse metrics make an exceptional technology insertion tool. We have developed a pragmatic approach to OO reuse metrics and use the metrics in many organizations as part of very successful reuse programs.

[433] Poulin, J. S. and D. D. Brown. 'Measurement-driven quality improvement in the MVS/ESA operating system', in Proc. Proceedings of the Second International Software Metrics Symposium (Cat. No.94TH06478). IEEE Comput. Soc. Press, Los Alamitos, CA, USA; 1994; ix+106 pp. 1994.

Keywords: Man, Emp, Qual

Abstract: Achieving gains in software quality requires both the use of software metrics and the desire to make measurement-driven process improvements. This paper describes the experiences, changes, and kinds of metrics used to drive quantifiable results in a very large and complex software system. Developers on the IBM Multiple Virtual Storage (MVS) operating system track, respond and initiate better ways of controlling the software development process through the use of metric-based defect models, orthogonal defect classification (ODC), and object-oriented techniques. Constant attention to progress with respect to the measurements and working toward goals based on the metrics show that measurement-driven process improvement can lead to noticeably better products.

[434] Price, M. W. and S. A. Demurjian Sr. 'Analyzing and measuring reusability in object-oriented designs', in Proc. OOPSLA 97. Atlanta, GA, USA: ACM, 1997.

Keywords: Reuse, Emp,C++

Abstract: We present a,technique to analyze and measure the reusability of object-oriented (OO) designs. The metrics can be incorporated into a design/development environment, so that reusability measurements, analysis, and improvements can be part of "business as usual" for an organization. Design reusability measurements also enable early identification of poor reuse potential, when it is still possible to modify/refine the design. The essential components of our approach are two reuse-specific characterisations of classes and hierarchies, and a set of metrics which objectively measures the dependencies among design components based on those reuse-specific characterizations.

Notes: Published in ACM Sigplan Notices 32 (10)

[435] Pritchett, W. W., 'Applying object-oriented metrics to Ada 95', Ada Letters, 16(5), pp48-58, 1996.

Abstract: Ada 95 adds many new and notable features to the Ada 83 standard. The additions include such aspects as object-oriented programming, hierarchical libraries and protected objects. The enhancements to the language may have a profound impact on the way developers design software in Ada. Consequently, the way in which the new software designs are assessed needs to be addressed. Recent studies suggest traditional functionally-oriented metrics are not applicable to object-oriented software. As a result, new measures are being proposed that may be applicable to object-oriented design. Some of these metrics have been validated on small- to medium-sized projects written in C++ and Smalltalk. This paper demonstrates how to apply these metrics to Ada 95.

[436] Qui, F., R. Foley, et al. 'A model for assessment module selection in product certification', in Proc. Software Quality Management International Conference. Edinburgh: Computational Mechanics Publications, 1994.

Keywords: Tool

[437] Rains, E., 'Function points in an Ada object-oriented design?', OOPS Messenger, 2(4), pp23-25, 1991.

Keywords: Size

[438] Rajaraman, C. and M. R. Lyu. 'Reliability and maintainability related software coupling metrics in C++ programs', in Proc. 3rd Intl. Symposium on Software Reliability Engineering. IEEE Computer Press, 1992.

Keywords: C++, Prod, Emp, Maint

Abstract: A description is given of some difficulties that one encounters in the testing and maintenance of C++ programs, which may result in program unreliability. Inheritance and polymorphism are key concepts in object-oriented programming (OOP), and are essential for achieving reusability and extendibility, but they also make programs more difficult to understand. The authors show by arguments and by some empirical evidence that widely used complexity metrics like lines of code, cyclomatic complexity, and Software Science's metrics may not be appropriate to measure the complexity of C++ programs and those written in other object-oriented languages, since they do not address concepts like inheritance and encapsulation, apart from having other weaknesses. Some measures using a notion from the world of functional decomposition-coupling, are defined for C++ programs. Two of them-CC and AMC-and equivalent ones for the three widely used complexity metrics (for comparison) are computed for five C++ programs. Preliminary results show that the coupling measures correlate better with difficulty of testing and maintenance than the three widely used complexity metrics.

Notes: Almost identical to TOOLS 92 paper.

[439] Rajaraman, C. and M. R. Lyu. 'Some coupling measures for C++ programs', in Proc. 8th Intl. Conf. Technology of Object-Oriented Languages and Systems. Santa Barbara: Prentice Hall, 1992.

Keywords: C++, Emp, Prod

Abstract: There is a great deal of "hype" about the object-oriented paradigm offering all the solutions to the problems of software engineering. Goals of software engineering like reliability, maintainability, and reusability are said to be more easily achieved using this paradigm, than with traditional ones based on functional decomposition. In order to monitor whether these goals are indeed being achieved, appropriate measures are necessary. Widely used complexity metrics like lines of code, cyclomatic complexity, and Software Science's metrics may not be appropriate. Since they do not address object-oriented concepts like inheritance and encapsulation, apart from having other weaknesses. We consider one attribute of object-oriented software-coupling-and define some measures based in measurement theory. Though these measures have been defined primarily for C++. They could be extended to other object-oriented languages. We then computed the measures for five large (by university standards) C++ software, and studied their correlation with the difficulty of maintenance as perceived by the developers of the software. Our preliminary results show that our coupling measures correlate better with difficulty of maintenance than the three widely used complexity metrics.

Notes: Preliminary study of 4 metrics for C++ class metrics and perceived maintenance difficulty for 5 moderate sized systems. Their coupling metrics outperformed the traditional metrics of v(G), Halstead and LOC but not significantly.

[440] Rajaraman, C. and M. R. Lyu. 'A study of coupling in C++ programs', in Proc. Technology of Object-Oriented Languages and Systems (TOOLS8). Prentice Hall International, 1993.

Keywords: C++, Des, Emp

[441] Ramakrishnan, S. and T. Menzies. 'An ongoing OO software engineering measurement experiment', in Proc. 1996 International Conference Software Engineering: Education and Practice. IEEE Comput. Soc. Press, Los Alamitos, CA, USA, 1996.

Keywords: Small, Emp

Abstract: This paper reports on an ongoing software measurement experiment which has been set up to monitor and evaluate team based student projects building object-oriented software. In this experiment, students are building the same system, in two languages (Eiffel and Smalltalk). Our process, called the Software Assessment Through Ongoing Profile Sheets (SATOPS) is being used in a project management framework to provide: a more objective feedback to improve students' learning; a method for measuring their understanding for grading purposes; and an instrument for making software engineering metrics measurements. We argue that SATOPS is the basis for reproducible software engineering experiments in a university environment.

[442] Rawlings, R. 'Some numbers from two object-oriented developments', in Proc. IEE Colloquium on Object Oriented Development. London: IEE, 1993.

Keywords: Emp, Ind

[443] Reinold, K. 'Processes and metrics for object-oriented software development', in Proc. OOPSLA `93 Workshop on Processes and Metrics for Object Oriented Software Development. Washington DC: 1993.

Keywords: Size, Man

Abstract: Not necessarily available as a paper. However, see the Workshop Report: [Bilow, 1993]. The following is taken from that report: "Kathy Reinold brought to us the perspective of a software manager tasked with moving from a procedural world to an object oriented one. She presented charts illustrating her contention that Function Point Analysis and "object counting" have the ability to product reliable KLOC estimates, even in OO projects."

[444] Reyes, L. and D. Carver. 'Predicting object reuse using metrics', in Proc. SEKE '98. Tenth International Conference on Software Engineering and Knowledge Engineering. Knowledge Syst. Inst, Skokie, IL, USA: 1998.

Keywords: Reuse, Emp

Abstract: In this paper, we investigate whether reusable classes can be characterized by object-oriented (OO) software metrics. One class-level reuse measure for the OO paradigm is defined: inter-application reuse by extension. We conducted a study in which stepwise regression was used to derive a prediction model incorporating 20 metrics as the independent variables and the reuse measure as the dependent variable. We also tested whether the mean metric values between reusable and non-reusable classes are the same. Results suggest that reuse can be predicted using a subset of the 20 metrics. This prediction model was empirically validated.

[445] Riel, A. J. 'Introduction to object-oriented design through real world examples', in Proc. OOP '94/C++ World. SIGS Publications, New York, NY, USA, 1994.

Keywords: Des

Abstract: We needed a new paradigm for the development of software which better manages the essential complexity of the applications we are currently building. The answer to this need is the object-oriented paradigm. We needed new formal methodologies for the development of software which focused on the object-oriented paradigm, many of these were published. We need new metrics and heuristics for object-oriented analysis and design: we now have forty of them, all but two being qualitative. We want quantitative metrics for object-oriented design. They do not exist yet but will be manufactured to satisfy demand. The same real world examples used to illustrate the key constructs of the paradigm can also be used to translate the expert's subconscious list of heuristics into a very conscience list of complexity and productivity metrics. The author has collected and/or created a list of forty such analysis and design heuristics/metrics which can be used to detect potential design flaws before they are integrated into an application. These metrics and their use in the object-oriented analysis and design process are reviewed.

[446] Rising, L. 'An information hiding metric', in Proc. OOPSLA `93 Workshop on Processes and Metrics for Object Oriented Software Development. Washington DC: 1993.

Keywords: Des, Ind, Prod

Abstract: Not necessarily available as a paper. However, see the Workshop Report: [Bilow, 1993]. The following is taken from that report: "Another quite interesting bit of work came from Linda Rising at Honeywell. She has been working on measures of information hiding in Object-Based languages and brought the ADA perspective to the group."

Notes: Linda is at AG Communication Systems, risingl@agcs.com.

[447] Rising, L., OO Design Heuristics. Internal Company Document , AG Communication Systems, 1994.

Keywords: Des

Abstract: Annotation from C. Gibbon.

This set of notes was prepared by Rising for an internal seminar on OO design heuristics. It borrows material mainly from Riel, Coplien and Meyers define what is, and is not, a design heuristic. A very good starting point for anyone wanting to incorporate design heuristics into their software development process.

[448] Rising, L. and F. W. Calliss. 'An experiment investigating the effect of information hiding on

maintainability', in Proc. Phoenix Conference on Computers and Communication. 1993.

Keywords: Des, Emp

Abstract: An experiment was conducted to investigate the effects of different levels of information hiding on maintainability. Two versions of an Ada program where created. Each version contained a set of modules with good information hiding and a set with poor information hiding. Subjects were given one of two versions of an Ada program and two modifications to perform. One modification was performed on the well-designed set of modules and one on the poorly-designed set. The results show that sections of the programs with good information hiding do not suffer structural decay as a result of the modification and that sections with poor information hiding are improved in approximately two-thirds of the new versions. These results are especially notable considering that the programmers were, for the most part, unfamiliar with Ada and object-oriented design.

Notes: More detailed description of the experimental work reported in [Rising, 1994, "An information-hiding metric"].

[449] Rising, L. S. and F. W. Calliss, 'An information-hiding metric', J. Systems and Software, (26), pp211-220, 1994.

Keywords: Des, Emp, Ind

Abstract: Linda Rising writes: "This paper describes a high-level design metric for modular programming languages like Ada. In these programming languages, there are two important components of a module: an interface and an implementation. The metric examines entities that can appear in the interface and by counting the number of "design decisions" shows that those modules with more than one design decision are likely to undergo "significant change" during their development/maintenance. Significant change is defined as a change in the interface entities. This kind of change sets up a ripple effect throughout the system, since all dependent modules must, at a minimum, be recompiled. Some example of design decisions are (these are described in an earlier paper by the same authors, Problems in Determining Package Cohesion and Coupling, Software - Practice and Experience, 22 (7) 1992, 553-571): (1) one private type; no variables; any number of constants; all subprograms operate on the private type; (2) one visible structured type; one or two additional simple types in the same type family as the structured type; (3) no variables; no types; any number of constants; all subprograms operate on the same type or have no parameters; (4) a collection of constants only; (5) one variable; any number of constants; any number of subprograms. The metric was validated subjectively (by asking the opinion of experts), experimentally (a maintenance assignment given to groups of student programmers), and in a case study of a very large Ada program developed for the military. The single most important factor in determining significant change after the number of design decisions was the presence of a visible (global) variable.".

[450] Roberts, T. 'Workshop report - metrics for object-oriented software development', in Proc. OOPSLA'92. ACM, 1992.

Keywords: Rev

Notes: Reprinted in ACM SIGPLAN Notices 28(2) pp97-100, 1993 . Typical of early work, highlighting the lack of clarity of what attributes are being measured, for what purpose and a lack of empirical analysis.

[451] Rocacher, D., Metrics definitions for Smalltalk. No. Project 1257, MUSE, Workpackage WP9A,

ESPRIT, 1988.

Keywords: Small

Notes: This work was done at the French company CRIL: Direction Régionale Ouest, 12 Av. Henri Fréville, 35200 Rennes, France. Tel: +44 33 99 41 74 44, fax: +44 33 99 50 03 65. Official contact for MUSE: Brameur Ltd, Clark House, Kings Road, Fleet, HANTS GU13 9AD, UK. Tel: 01252 812 252, fax: 01252 815 702.

[452] Rocacher, D., Smalltalk Measure Analysis Manual. No. Project 1257, MUSE, Workpackage WP9A, ESPRIT, 1989.

Keywords: Small

[453] Rosenberg, L. H. and S. B. Sheppard. 'Metrics in software process assessment, quality assurance and risk assessment', in Proc. 2nd Intl. Software Metrics Symposium. London, England: IEEE Computer Society Press, Los Alamitos, CA, USA, 1994.

Keywords: C++, Ind, Qual

Abstract: An interesting paper comparing developments in Ada, C, C++ and FORTRAN (actually only data from the last two are given in the paper). C++ data includes a plot of effort logged, during each phase of the waterfall life-cycle, against all possible phases. Thus during requirements/spec. there is no coding but a small amount of debug/test; during coding there is no requirements/spec activity but a small amount of design and a larger amount of debug/test, etc. There is also a comparison of total changes against total changes due to coding errors. Some of the C++ code was a rewrite of old FORTRAN code. Traditional complexity metrics were applied to the FORTRAN to identify those parts most in need of rewrite.

[454] Rossi, M. and S. Brinkkemper. 'Metrics in method engineering', in Proc. Advanced Information Systems Engineering. Proceedings of the 7th International Conference CAiSE*95. 1995.

Keywords: Des, Prod

Abstract: This paper contains metrics on the complexity of techniques, including several OO modelling techniques. Sjaak Brinkkemper is at Twente University sjbr@cs.utwente.nl.

Notes: Lecture Notes in Computer Science, Springer Verlag, Berlin, 1995

[455] Rubin, H., E. Youdon, et al., Industry Canada Worldwide Benchmark Project. Survey Report , Rubin Systems Inc., 1995.

Keywords: Man, Emp, Ind

Abstract: The Worldwide Benchmark Project, carried out for Industry Canada in 1994/95, conducted a survey with 227 respondents, mostly US, Canada and 'England/Europe'. The survey is supplemented here with Rubin's 1994 Industry Watch Study (360 companies), Yourdon's 1994 India Survey (125 responses) and a survey of 'Low-wage outsourcing' (42 responses). The report covers issues such as work breakdown (new development is roughly 50%; migration and maintenance split about 20%/30%); life-cycle effort distributions

(coding and system test split about 30%/20%); new development productivity (generally around 100 FP per professional personyear). The Language Usage results, which might have had OO interest, are too hard to read in the reduced, monochrome copy mailed out. Visual Basic and Ada (presumably 83) are included but C++ and Smalltalk are excluded. In the Tool and Technique Usage section, OO is used by about 62% of all respondents, with a further 30% targeting OO. The figures of code reuse and design reuse are slightly higher and slightly lower, respectively. Metrics are used by about 55%; project management tools by about 85%.

Notes: Rubin Systems Inc., 5 Winterbottom Lane, Pound Ridge, NY 10576, USA. E-mail: 71031.377@compuserve.com

[456] Rubin, H. A. 'Software process maturity: measuring its impact on productivity and quality', in Proc. First International Software Metrics Symposium. IEEE Comput. Soc. Press, Los Alamitos, CA, USA, 1993.

Keywords: Man

Abstract: With the current worldwide focus on improvement in software process, there is clearly a need for an understanding of its impact on software engineering productivity and quality. The paper documents an attempt to provide an empirical metrics 'view' of such initiatives based on data collected in a worldwide benchmarking effort conducted between March, 1991 and December, 1991. Surprisingly, of the more than 300 organizations that participated, fewer than 1 in 5 had any quantifiable performance data available prior to the start of this study. However, those that had embarked on significant process improvement efforts and were actively using metrics were able to demonstrate substantial grains in productivity and quality. In addition, insights derived from this large scale data analysis provide a framework for determining which metrics should be included in a standard software engineering measurement 'dashboard'.

[457] Rubin, K. S. 'Advanced project management', in Proc. OOP'97. SIGS Conferences, Bergisch Gladbach, Germany, 1997.

Keywords: Man, Emp

Abstract: The paper discusses advanced project management techniques as applied to object technology projects. Development of the ParcPlace MethodWorks product is used as the case study for the discussion. The MethodWorks project is examined in the context of several project management areas, which include marketing requirements, planning and control, team structure, software development environment, reuse, quality assurance, and measurement.

[458] Samadzadeh, M. H. and S. J. Khan. 'Stability, coupling, and cohesion of object-oriented software systems', in Proc. 22nd Annual 1994 ACM Computer Science Conference. ACM, New York, NY, USA, 1994.

Keywords: Prod

Abstract: An important goal of the object-oriented approach is to enhance the reusability, extendibility, and maintainability of a system after its development, i.e., during the maintenance phase. There is a need to have a stream-lined design process for object-oriented systems. One way to achieve this goal is to develop and use connectivity and stability metrics and incorporate them into object-oriented design techniques. An object-oriented design could then be tested for coupling and cohesion factors and a system structure could be proposed with optimum structural interactions as well as improved encapsulation and stability. In this paper, the concepts of coupling, cohesion, and stability, as they pertain to object-oriented designs, are investigated.

The original definitions of coupling, cohesion, and stability are modified and refined to account for the notions that are particular to the object-oriented paradigm (e.g., inheritance, encapsulation, and message passing). The results of the work reported in this paper can be used for object-oriented system evaluation.

[459] Samaraweera, L. G. and R. Harrison, 'Evaluation of the functional and object-oriented programming paradigms: a replicated experiment', Software Engineering Notes, 23(4), pp38-43, 1998.

Keywords: C++, Des, Emp

Abstract: The importance of replication of software engineering experimentation to validate experimental results, (considered normal practice in other scientific domains) has often been overlooked. The paper presents the results of an internal replication of a case study which quantitatively investigates and compares the quality of code produced in a functional programming language, SML, with that produced in an object oriented language, C++. Several relationships were identified between the process metrics and product metrics. In particular, several `design time' metrics were found to be related to features of the development process and the delivered code. Thus, it may be possible to use these design time metrics for prediction purposes. Further analysis involved investigating the effects of software size and code reuse on `error density', and the differences between the two paradigms in terms of programmer productivity and code understandability. This research leads the authors to believe that replication (both internal and external) is an important part of software engineering experimentation.

[460] Sarirete, A. and J. Vaucher. 'Similarity measures for the object model', in Proc. Object-Oriented Technology, ECOOP'97 Workshops Proceedings. Springer-Verlag, Berlin, Germany, 1998.

Keywords: Theory, Reuse

Abstract: In order to improve the design and understanding of class libraries, researchers have proposed automatic class hierarchy redesign methods (E. Casis, 1992; R. Godin and H. Mili, 1993; N. Anquetil, 1996). Generally, the restructuring process is done within a single library and is based on syntactic matching of class signatures derived from visible class attributes. The paper deals with another kind of matching, semantic or conceptual matching, and a similarity measure for object based systems is proposed. This measure is based on the semantic relations between the words which identify concepts in the object model. Wordnet, a widely available computer thesaurus has been used to provide semantic relations between terms. The similarity measure is applied to class libraries by combining it with other metrics based on the structure of the objects. The similarity measure and its derived metrics are used to improve the reusability process in object based libraries.

[461] Schach, S. R., 'The Cohesion and Coupling of Objects', JOOP, 8(1), pp48-50, 1996.

Keywords: Des, Prod

Abstract: When the object-oriented (O-O) paradigm is used to develop software, O-O metrics are needed to monitor and hence control the process. A variety of different metrics have been suggested, in particular, a number of attempts have been made to extend the classical (module-based) metrics of cohesion and coupling to the O-O paradigm. Unfortunately, the majority of treatments of cohesion and coupling of objects are unnecessarily complex. The authors show that the cohesion and coupling of objects can be greatly simplified by reducing the issue to classical (module-based) cohesion and coupling, together with one type of O-O coupling. The main results of this article are as follows. First, there is no difference between the cohesion of an object and classical cohesion, i.e., the cohesion of a module. Accordingly, it does not make much sense to

put forward taxonomies of object cohesion, since they reduce to the well-known taxonomies of classical cohesion. Second, in all but one instance, the coupling between two objects can be expressed in terms of classical coupling, i.e., the coupling between two modules. Third, there is, however, one form of coupling that is specific to objects; the authors call this inheritance coupling. Fourth, inheritance coupling is totally different in character from the classical forms of coupling. It is shown how the issues of cohesion and coupling of objects may be enormously simplified. The article concludes with a discussion of the results.

[462] Schwanke, R. W. 'An intelligent tool for re-engineering software modularity', in Proc. Proceedings of the 13th International Conference on Software Engineering (ICSE '13). IEEE, 1991.

Keywords: des

[463] Shan, Y. P., 'Smalltalk on the rise', Commun. ACM, 38(10), pp103-104, 1995.

Keywords: Man, Small

Abstract: Summarises information from [McClure, 1995]. For example, the Smalltalk software tools market is reported to have had a value of $56 million in 1994, a 60% increase in growth over 1993 .

[464] Sharble, R. C. and S. S. Cohen, 'The Object-Oriented Brewery: A Comparison of Two Object-Oriented Development Methods', ACM SIGSOFT Software Engineering Notes, 18(2), pp60-73, 1993.

Keywords: Des, Emp, Man

Abstract: Annotation from [Webster, 1994]: A very interesting paper which compares two quite different OO methods by applying them to the same problem and tries to use some metrics on the resultant code to make an evaluation. The methods compared are Boeing's own Shlaer Mellor style data driven approach and a CRC inspired responsibility driven approach. They use the metrics of Chidamber and Kemerer along with a few of their own. The results indicate that the responsibility based approach tends to make for better coupled systems. This is an argument in favour of the Coad idea of pushing functionality to low levels and breaking the real world mapping."The responsibility-driven method was shown to produce a design which was much less complex than that produced by the data-driven method. In particular, the responsibility-driven design exhibited much greater cohesion of classes and much less coupling between them. Also, the responsibility-driven method produced a better organized inheritance hierarchy, with greater potential to reduce redundancy."

[465] Sheetz, S. D., D. P. Tegarden, et al., 'A group support systems approach to cognitive mapping', Journal of Management Information Systems, 11(1), pp31-57, 1994.

Keywords: Des, Emp

Abstract: "Cognitive maps are valuable tools for understanding individual and group perceptions. But developing such maps is a resource-intensive activity. To reduce required resources, group support system (GSS) technology is proposed as an aid in uncovering cognitive maps. A GSS session was used to develop a cognitive map of users of object-oriented (OO) techniques perceptions of OO system complexity. Seven participants identified concepts and categories, categorized the concepts, rated category importance, and defined relationships between categories. The data collected and analyses performed provide the basis for a cognitive map of the participants' perceptions of OO system complexity. A comparison with similar

individual cognitive mapping results supports further investigation of using the GSS approach for identifying perceptions of complexity."

[466] Sheetz, S. D., D. P. Tegarden, et al. 'Measuring object-oriented system complexity', in Proc. Workshop on Information Technologies and Systems WITS'91. 1991.

Keywords: Des, Prod

Abstract: "This paper addresses Object-Oriented (OO) system complexity at the application, object, method, and variable level. At each level measures are proposed to account for the cohesion and coupling aspects of the system. OO system complexity at each level is presented as a function of the measurable characteristics such as fan-in, fan-out, number of I/O variables, fan-up, fan-down, and polymorphism. Each measure is defined with adherence to the principles that measures must be intuitive and that they must be applicable to all phases of the OO development cycle." Steven Sheetz is at sheetz_s@gold.colorado.edu; David Monarchi is at monarchi_d@cubldr.colorado.edu. See also [Tegarden, 1992, "The effectiveness of traditional metrics for object-oriented systems"].

[467] Shepperd, M. J. and D. C. Ince, 'A critique of three metrics', J. Systems and Software, 26(3), pp197-210, 1994.

Keywords: Theory

Abstract: Kevin Anderson writes: "An incisive examination of well-known traditional metrics, they mention [Chidamber, 1991] and Rajaraman & Lyu (citing some TOOLS USA 92 paper, not [Rajaraman, 1993]) as examples of on-going metrics works which neglect the modelling considerations necessary for rigorous metrics.

[468] Sherif, J. S. and P. Sanderson, 'Metrics for object-oriented software projects', Journal of Systems and Software, 44(2), pp147-154, 1998.

Keywords: C++, Emp

Abstract: This paper puts forward an analysis of two software projects developed at the Jet Propulsion Laboratory (JPL). The two projects are the micro generic controller (UGC) and the sequence generator (SEQGEN). Both projects use the object-oriented paradigm and the C++ programming language. Object-oriented metrics and other measures are implemented to analyze and compare the two projects.

[469] Shih, T. K., C. M. Chung, et al. 'Decomposition of multiple inheritance DAGs for object-oriented software measurement', in Proc. Software Quality Engineering. Comput. Mech. Publications, Southampton, UK, 1997.

Keywords: Theory, Qual

Abstract: Software metrics are widely used to measure software complexity and assure software quality. However, research in the field of the software complexity measurement of a class hierarchy yet to be carefully studied. We introduce a novel factor named unit repeated inheritance (URI) and an important method named inheritance level technique (ILT) method 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 has a close relation 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.

[470] Shih, T. K., C. M. Chung, et al. 'Decomposition of Inheritance Hierarchy DAGS for Object-Oriented Software Metrics', in Proc. International Conference and Workshop on Engineering of Computer Based Systems. Monterey, CA, USA: IEEE Computer Society Press, 1997.

Keywords: Theory,Prod

Abstract: 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.

[471] Shih, T. K., Y. C. Lin, et al., 'An object-oriented design complexity metric based on inheritance relationships', International Journal of Software Engineering and Knowledge Engineering, 8(4), pp541-566, 1998.

Keywords: Tool, Emp, Theory, C++

Abstract: Software metrics serve as a significant issue to improve software quality. It is an important research of software engineering. In line with the methodologies of object-oriented analysis and design widely developed, many software metrics techniques have been proposed. However, not many focus on the metrics evaluation of an inheritance hierarchy. In this paper, we propose a novel concept named unit repeated inheritance (URI) in Z notation to realize object-oriented software metrics. The approach describes an inheritance level technique (ILT) method as a guide to measure the software complexity of an inheritance hierarchy. The measures of inheritance metrics are formed based on the proposed mechanism. Also, we use Lex and Yacc to construct a windowing tool which is used in conjunction with a conventional C++ programming environment to assist a programmer in analyzing and measuring his/her C++ programs.

[472] Shih, T. K., C. C. Wang, et al., 'Using Z to specify object-oriented software complexity measures', Information and Software Technology, 39(8), pp515-529, 1997.

Keywords: Theory, Qual

Abstract: Software metrics have been a key strategy for software engineers to assure software quality and measure software complexity for many years. However, the complexity metrics of object inheritance hierarchies have not yet been carefully studied. The paper proposes an inheritance level based metric for measuring the object oriented software complexity of an inheritance hierarchy. We introduce an algorithm which is proved to be complete and sound to decompose an inheritance hierarchy into a number of measured elements, namely, unit repeated inheritances (URIs). We use the Z specification to model the inheritance hierarchy and describe an inheritance level technique (ILT) based on URIs as a guide to measure the inheritance hierarchy. The proposed metric shows that inheritance has a close relation to object oriented software complexity. The metric also reveals that overuse of repeated (multiple) inheritance will increase

software complexity and thus is prone to implicit software errors. The measurement of inheritance metrics is formed based on the proposed mechanism.

[473] Siebellehner, J., G. Kappel, et al., Coupling and cohesion metrics for object-oriented software development, in Theorie und Praxis der Softwaremessung, R. Dumke and H. Zuse, Editors, Deutscher Universitaetsverlag, Wiesbaden, Germany: 1994.

Keywords: Des, Qual

Notes: In German.

[474] Simoens, R. 'The introduction of an object oriented analysis/design method and object oriented metrics in the software development life-cycle', in Proc. Ada in Europe. Second International Eurospace - Ada Europe Symposium. Springer-Verlag, Berlin, Germany, 1996.

Keywords: Man, Emp

Abstract: Eurocontrol is the European organisation for the safety of air navigation. One of its tasks is the air traffic control. For this task, Eurocontrol uses an automated real-time system. The system was developed in the late 60s. The system will undergo a stepwise re-engineering and modernisation programme lasting until the year 2000. One of the first activities in this re-engineering programme was the establishment of a quality system and the definition of a software development environment that supports the complete development life-cycle. This paper first describes the introduction of object oriented analysis and design techniques in the software development life-cycle. Next it describes the definition of a set of object oriented metrics. The architecture of the software product is defined during the architectural design phase. It is documented in the object oriented architectural design model and included in the architectural design document (ADD). The design is further detailed during the detailed design phase and the product is finally implemented during the coding and unit test phase [PSSOS]. This paper discusses the introduction of the object oriented methods and metrics in the software requirements phase and architectural design phase.

[475] Sneed, H. 'Applying size, complexity and quality metrics to an object-oriented application', in Proc. 10th European Software Control & Metrics Conference. Herstmonceux, England: Shaker Publishing, 1999.

Keywords: C++, Size, Qual, Emp

[476] Sneed, H. M. 'Estimating the Development Costs of Object-Oriented Software', in Proc. Evolving Systems. Durham '95. 9th European Workshop on Software Maintenance. Durham, UK: DSM Ltd, 1995.

Keywords: Size

Abstract: The view stated here is that conventional metrics for sizing software such as lines of code and function points are not valid for sizing OO software. A new metric, object-points, is proposed to express the size and complexity of such software. The traditional influence factors are also inapplicable. New influence factors are needed to do justice to modern development environments. In this paper, an approach is presented which combines these features in an attempt to more accurately estimate the costs of developing object-oriented software.

[477] Stalhane, T. 'Development of a model for reusability assessment', in Proc. Objective Software Quality. Objective Quality: Second Symposium on Software Quality Techniques and Acquisition Criteria. Springer-Verlag, Berlin, Germany, 1995.

Keywords: Qual, Reuse, Rev

Abstract: Shows how the ESPRIT project REBOOT (REuse By Object-Oriented Techniques) constructed a reusability assessment model based on a survey of what software engineers consider to be important for reuse. The main result of this presentation is that software engineers agree on a set of characteristics for a reusable software component. These characteristics can be combined into a factor-criteria-metrics assessment model. Since the assessment model represents the views of the software engineers, it has a high probability of being accepted in the industry.

[478] Stark, M., 'Impacts of object-oriented technologies: seven years of SEL studies', ACM SIGPLAN Notices, 28(10), pp365-373, 1993.

Keywords: C++, Emp, Ind, Man

Abstract: From the text: "This paper addresses the question, Is object-oriented technology, then, truly the most influential method studied by the SEL to date? The conclusion of the SEL is that OOT does promote reuse, sometimes even neglecting other important issues like run-time efficiency. When coupled with domain analysis, OOT enables high reuse across a range of applications in a given environment. While the reuse expectations were met, the use of OOT was not so intuitive as expected, partly because the technique was new to an organization with a mature structured development process. The other factor affecting the ease of transition is the inherent and growing complexity of flight-dynamic problems; OOT may be a better process but, in addition to software techniques, skilled designers are still needed to solve difficult programs." A good source for domain analysis: Prieto-Diaz, R., "Domain analysis: an introduction", ACM Software Eng. Notes, 15 (2), 47-54, 1990 .

Notes: OOPSLA '93, Vancouver, Canada

[479] Stark, M., 'Impacts of object-oriented technologies: seven years of SEL studies', J. Systems and Software, 23(2), pp163-169, 1993.

Keywords: C++, Emp, Ind, Man

Abstract: I think this is essentially the same as [STAR93].

[480] Steinmuller, U. 'Qualifying C++ Foundation Classes for use in Industrial Applications', in Proc. Technology of Object-Oriented Languages and Systems (TOOLS 7). Dortmund Germany: Prentice Hall, 1992.

Keywords: C++, Reuse

[481] Stiglic, B., M. Hericko, et al., 'How to evaluate object-oriented software development?', ACM SIGPLAN Notices, 30(5), pp3-10, 1995.

Keywords: Tool

[482] Succi, G., S. Doublait, et al., 'Reuse and reusability metrics in an object oriented paradigm', International Journal of Applied Software Technology, 1, pp3-4, 1995.

Keywords: Reuse, Qual, Tool

Abstract: The connection between reuse and object oriented programming (OOP) is outlined, Although both claim the same benefits, object oriented programming can see "reuse" as a "test" demonstrating that the job of OOP has been done. Reuse metrics are seen as essential in measuring the quality of object oriented designs and codes. After a brief overview of reuse and metrics, the role of metrics in a reuse based software development environment are described. Subsequently attention is focused on specific figures of merit that can be used to judge the quality of OOP designs and code for reuse (actual reuse) and reusability (estimated reuse potential). Then a strategy based upon a flexible tool platform is put forward for implementing the metrics. Finally, some concluding remarks are offered, and some other areas for additional use of reuse/reusability metrics in management of OOP are suggested.

[483] Sutcliffe, A. G., 'Object-oriented systems development: survey of structured methods', Information & Software Technology, 33(6), pp433-442, 1991.

Keywords: Rev, Des

Abstract: Good source paper on OO methods. Contains lots of nominal measures classifying methods according to which have which OO features. See also [Eckert, 1994] and [Webster, 1994].

[484] Szabo, R. M. and T. M. Khoshgoftaar. 'An assessment of software quality in a C++ environment', in Proc. 6th Int. Symposium on Software Reliability Engineering, ISSRE'95. Toulouse, France: 1995.

Keywords: C++, Emp, Prod, Qual

Abstract: In this experience report, we discuss the application of a three group discriminant model to an object oriented software system. The model is used to classify software modules as high, medium, or low risk with respect to the number of faults. To our knowledge, this is among the first empirical validations of a true three group software quality model. Two models are presented. One model incorporates only traditional measures while the other model includes both traditional and object oriented measures. We show that for this system, the addition of the object oriented measures enhances the model by reducing the overall misclassification rate and significantly reducing the misclassification in the medium group.

[485] Szabo, R. M. and T. M. Khoshgoftaar, The detection of high risk software modules in an object-oriented system. Internal Report No. TR-CSE-95-07, Department of Computer Science and Engineering, Florida Atlantic University, 1995.

Keywords: C++, Des, Emp, Ind

Abstract: From the conclusion: "In this study we report a classification model using only traditional software product measures collected from a commercial C++ environment. This validates Tegarden et al.'s ([Tegarden, 1992, "The effectiveness of traditional metrics for object-oriented systems"]) report that traditional measures alone are applicable in an object oriented environment. Furthermore, the relationship is not significantly better when object oriented measures unique to C++ are included in the analysis.... unlike Li and Henry ([Li, 1993,

"Object-oriented metrics that predict maintainability"]) we did not have a statistically significant model using object oriented measures alone." The study uses principal component analysis to relate product metrics to the process measure number of faults found during testing.

Notes: Taghi Khoshgoftaar is at taghi@cse.fau.edu, Robert Szabo is at rszabo@vnet.ibm.com.

[486] Szabo, R. M. and T. M. Khoshgoftaar, Modelling software quality in an object oriented software system. Internal Report No. TR-CSE-95-05, Department of Computer Science and Engineering, Florida Atlantic University, 1995.

Keywords: Qual

[487] Taylor, D. A., Object-Oriented Information Systems: Planning and Implementation. Wiley: New York, 1992.

Keywords: Man, Qual, Small, Rev

Abstract: Reports on a project at Electronic Data Systems to replace a PL/1 manufacturing application with Smalltalk. The project showed 3:1 to 4:1 productivity improvement with no performance degradation (I read this in [Shan, 1995] - I haven't seen the book).

[488] Taylor, D. A., 'Software metrics for object technology', Object Magazine, (March-April), pp22-25, 1993.

[489] Tegarden, D. P., OO Measurement Bibliography. unpublished document , Virginia Polytechnic Institute and State University, 1994.

Keywords: Rev

Abstract: Comprehensive bibliography on OO measurement and related topics. No annotations but with a classification into: cognitive issues; testing; reuse; complexity; project management and estimation.

Notes: David Tegarden's contact see [Tegarden, 1992, "The effectiveness of traditional metrics for object-oriented systems"].

[490] Tegarden, D. P. and S. D. Sheetz. 'Object-oriented system complexity: an integrated model of structure and perceptions', in Proc. OOPSLA '92 Workshop 'Metrics for Object-Oriented Software Development. 1992.

Keywords: Des, Rev

Abstract: A short overview paper providing a good introduction to the major issues in OO measurement, with 45 refs. There is a welcome emphasis on the importance of cognitive issues. Roberts' report on this workshop [Roberts, 1992].

[491] Tegarden, D. P., S. D. Sheetz, et al. 'The effectiveness of traditional metrics for object-oriented systems', in Proc. 25th Hawaii International Conference on System Sciences. IEEE Computer Society Press,

1992.

Keywords: Prod, Emp

Abstract: "The ability to quantify the complexity of software is a necessary condition for the creation of acceptable measurement of software quality. Traditional software metrics such as lines of code, software science, cyclomatic complexity are investigated as indicators or complexity of object-oriented systems. This research reports the effects of polymorphism and inheritance on the complexity of object-oriented systems as measured by traditional metrics. The results of this research indicate that traditional metrics are applicable to the measurement of the complexity of object-oriented systems" From the Conclusions: "Even though the order of magnitude of the traditional metrics may be suspect, the directionality seems to be correct. The use of inheritance and/or polymorphism should decrease the complexity ... this is captured by the traditional metrics However, we believe additional metrics are required."

Notes: Traditional software metrics such as lines of code, software science and cyclomatic complexity are investigated as possible indicators of complexity of object-oriented systems. Traditional metrics are used to measure the effects of inheritance and polymorphism on OO systems. The conclusion is that traditional metrics are applicable to the measurement of object-oriented software.

David Tegarden is at dtegarde@vtaix.cc.vt.edu.

[492] Tegarden, D. P., S. D. Sheetz, et al., 'A Software Complexity Model of Object-Oriented Systems', Decision Support Systems, 13(3-4), pp241-262, 1995.

Keywords: Des, Qual

Abstract: A model for the emerging area of software complexity measurement of OO systems is requires for the integration of measures defined by various researchers and to provide a framework for continued investigation. We present a model, based in the literature of OO systems and software complexity for structured systems. The model defines the software complexity of OO systems at the variable, method, object and system levels. At each level, measures are identified that account for the cohesion and coupling aspects of the system. Users of OO techniques perceptions of complexity provide support for the levels and measures.

[493] Teologlou, G. 'Measuring object-oriented software with predictive object points', in Proc. 10th European Software Control & Metrics Conference. Herstmonceux, England: Shaker Publishing, 1999.

Keywords: Size, Man

Abstract: Describes the use of Predictive Object Points as a means of predicting size and effort. A small example is included.

[494] Teologlu, G. 'Estimating the cost of object-oriented programming', in Proc. 6th European Software Cost Measurement Conference (ESCOM). Rolduc, The Netherlands: 1995.

Keywords: Size

Notes: The ESCOM conferences are run by Adrian Cowderoy (ACowderoy@aol.com).

[495] Thomas, D. 'Object-orientation and software quality assurance', in Proc. 8th Intl. Conf. on Software Engineering and its Applications. Paris-La-Defense: 1995.

Keywords: Qual

Abstract: Proceedings available from the organisers: EC2, Paris-La-Defense Cedex, Jeanclaude.Rault@&utopia.fnet.fr.

[496] Thomson, N., R. Johnson, et al. 'Project estimation using an adaptation of function points and use cases for OO projects', in Proc. Workshop on Pragmatic and Theoretical Directions in Object-Oriented Software Metrics, OOPSLA'94. 1994.

Keywords: Des, Ind, Size

Abstract: "Project estimation is difficult on large projects and the degree of difficulty is increased when it involves a new software technology. Two factors have stood out — estimation on satisfying individual requirements in a highly interdependent requirements and solution space plus estimation of project resources and milestones. This paper explores the adaptation of function points, an effective metrics tool for estimation in the non-OO world, to OO, plus the application of Use Cases to simplify software integration and delivery planning for the GSF project at BNR". A good brief account of experiences, as well as a list of about 12 metrics used to assist in estimation.

Notes: Neil Thomson is happy to provide people with copies of the paper and can be contacted at neilt@bnr.ca. See also [Bilow, 1995].

[497] Thuy, N. N. 'Testability and unit tests in large object-oriented software', in Proc. Quality Week '92 Conference. 1992.

Keywords: Test

Notes: Quality Week is run by Software Research Inc who presumably also make available the proceedings: 625 Third Street, San Francisco, CA 94107-1997, USA.

[498] Ungar, D. 'Position paper', in Proc. OOPSLA'93 Workshop on Object-oriented Testing. 1993.

Keywords: C++, Emp, Test

Abstract: Not necessarily available as a published paper, although the main OOPSAL'93 Proceedings were published by ACM/SIGPLAN ISBN: 0 201 58895 1. I understand Ungar examines error rates in C++ and Self code: findings suggest that OO code is as error-prone as other types. (Ungar developed the Self compiler).

[499] Unger, B. and L. Prechelt, The impact of inheritance depth on maintenance tasks - Detailed description and evaluation of two experimental replications. No. TR18/1998, Karlsruhe University, 1998.

Keywords: Emp, Maint, Java

[500] Vaishnavi, V. K. and R. K. Bandi, 'Measuring Reuse', Object Magazine, 6(2), pp53-57, 1996.

Keywords: Reuse

Abstract: We present and illustrate a model (Framework Assisted GQM model) for measuring object oriented reuse based on the GQM model, which is widely used for a metrics program. Measurement by itself without any clear objectives will not be of any benefit to anyone. One cannot randomly choose any set of metrics and expect them to prove beneficial. The selection of metrics to be used should be done carefully and in the context of the objectives that need to be achieved. In other words, measurement must be tied to a broader set of goals that depend on the perspective of measurement. Using the model, along with a high level framework that establishes perspective, we discuss goals from both the perspective of a supplier who develops reusable products and the consumer who uses reusable products in the development of products. We illustrate the model`s use for selecting relevant metrics that can be tied back to the goals of measuring object oriented reuse.

[501] Ververs, F. and C. Pronk. 'On the interaction between metrics and patterns', in Proc. OOIS'95. Dublin City University: 1995.

Keywords: Reuse

Abstract: In the area of object-oriented technology two subjects have been researched recently: design patterns and metrics. This paper discusses the influence the widespread use of design patterns will have on some well established metrics. A cautious conclusion will be that several metrics will have to be reconsidered after design patterns are in common use.

[502] Ververs, F. and P. van Dalen. 'Measuring for (re)design', in Proc. Conference on Software Measurement and Management. Int. Function Point Users Grup, Westerville, OH, USA, 1996.

Keywords: Emp, Qual

Abstract: This paper discusses the application of many object-oriented metrics to a very large (700 Klines) Objective-C software archive. The results give useful information for defining guidelines and coding rules. Also a number of classes have been identified for redesign and/or recoding. Moreover a lot of information has been collected which can be used in the near future where a growth of the code with 300% is expected. An improved software process and better resulting code are necessary.

[503] Vessey, I. and S. A. Conger, 'Requirements specification: learning object, process, and data methodologies', Commun. ACM, 37(5), pp102-113, 1994.

Keywords: Emp, Man

Abstract: From the text: "We investigated the effectiveness of the process-, data-, and object-oriented methodologies in specifying information requirements ... This study investigated the following research questions: are novice systems analysts able to develop information requirements specifications more readily with certain methodologies than with others? Do novice analysts learn to use certain methodologies more readily than others?" "from the viewpoint of practitioners choosing methodologies, the results of this study suggest that object-oriented approaches may not be best for all problem solvers in all situations. Information systems managers need to evaluate the claims made by devotees of object-oriented approaches very

carefully."

Notes: Iris Vessey is at Penn. State Univ.: ivessey@big.bus.indiana.edu. Sue Conger is at sconger@aol.com, fax: +1 214 931 9125.

[504] Voas, J. M. 'Object-oriented software testability', in Proc. 3rd International Conference on Achieving Quality in Software. Chapman and Hall, London, 1996.

Keywords: C++, Emp, Test

Abstract: Describes an investigation into Voas' conjecture that OO can have a detrimental effect on system-level testability (in the sense of decreasing the probability of faults being exposed by testing). Statistically significant results were not obtained but some evidence is claimed in support of the conjecture (although, surprisingly, the figures suggest higher testability for a C++ implementation of a drawing package compared to a C implementation). The experimental results are hard to follow without a prior understanding of Voas' testability metrics (see Voas, J., "PIE: a dynamic failure-based technique", IEEE Trans. on Software Eng. 18 (8) 1992, 717-727).

Notes: Jeffrey Voas is at jmvoas@RSTCorp.com. ISBN 0-412-63900-9

[505] Walker, I. J., 'Requirements of an object-oriented design method', Software Engineering Journal, 7(2), pp102-113, 1992.

Keywords: Rev

Abstract: Annotation from [Webster, 1994]: An important paper as it covers a lot of issues. It sets out to see how OO some methods are and how good they are. After reviewing Booch's topics for an object model and some interesting discussions of each it presents four criteria for a method: Abstraction; Notation and representational verisimilitude; Validation and Re-use. It is not clear how these were arrived at. A matrix is presented of criteria against methods (JSD, Alabiso, Pun & Winder, OOSD, HOOD, Booch, Rumbaugh). Booch and Rumbaugh do well in the comparison. The paper concludes: "In particular, an almost universal absence of clear, detailed, objective recommendations of criteria for assessing the 'goodness' of a particular design (metrics) is disturbing."

[506] Walsh, J. 'Preliminary defect data from the iterative development of a large C++ project', in Proc. OOPSLA '92. Vancouver, Canada: 1992.

Keywords: C++, Emp, Ind, Qual

Abstract: From the text: "Preliminary results from the development of Rational Rose, a large (>100 KLOC) program written in C++, suggest that high product quality can be achieved during a telescoped development schedule through the use of an iterative-development methodology. Data on defect density and discovery rate gathered on one phase of ROSE development implies a low error rate in code delivered for functional test and supports 80-20 defect clusterings, 80-20 distribution of non-critical versus critical defects, an association of defects detected during functional test with department in the subsystem hierarchy, and the utility of data on rates of defect discovery for C++ programs." Walsh reports a strong correlation between defect density and the order in which subsystems must be compiled and linked because of their dependencies on one another, expressed — in C++ — by include files. See also [Roberts, 1992].

Notes: Appears in SIGPLAN Notices, 27 (10)

[507] Walsh, J., Software quality in an iterative object-oriented development paradigm. Interal Report , Rational, 1993.

Keywords: Man, Qual

[508] Wang, C. C., W. C. Pai, et al. 'Using Z approach to object-oriented software testing and metrics for C++ inheritance hierarchies', in Proc. 13th International Conference on Computers and Their Applications. International Society for Computers and Their Applications -ISCA, Cary, NC, USA, 1998.

Keywords: C++, Tool , Test

Abstract: We propose a concept named unit repeated inheritance (URI) with the Z language to realize object-oriented testing and object-oriented metrics. The approach describes an inheritance level technique (ILT) as a guide in order to detect the software errors of the inheritance hierarchy and measure the software complexity of the inheritance hierarchy. The measurement of inheritance metrics and some testing criteria are formed based on the proposed mechanism. Also, we use Lex and Yacc to construct a windowing tool which is used in conjunction with a conventional C++ programming environment to assist a programmer to analyze, test, and measure his/her C++ program.

[509] Wang, C. C., T. K. Shih, et al. 'An automatic approach to object-oriented software testing and metrics for C++ inheritance hierarchies', in Proc. ICICS, 1997 International Conference on Information, Communications and Signal Processing. IEEE, New York, NY, USA, 1997.

Keywords: C++, Test, Tool

Abstract: In this paper, we propose a concept named unit repeated inheritance (URI) to realize object-oriented testing and object-oriented metrics. The approach describes an inheritance level technique (ILT) as a guide to detect the software errors of the inheritance hierarchy and measure the software complexity of the inheritance hierarchy. The measurement of inheritance metrics and some testing criteria are formed based on the proposed mechanism. Thus, we use Lex and Yacc to construct a windowing tool which is used in conjunction with a conventional C++ programming environment to assist a programmer to analyze, test, and measure his/her C++ programs.

[510] Wang, H. Y., C. M. Chung, et al. 'Object-oriented software quality through data scope complexity measurement', in Proc. 1997 IEEE International Conference on Systems, Man, and Cybernetics. Computational Cybernetics and Simulation. IEEE, New York, NY, USA, 1997.

Keywords: Prod

Abstract: Software metrics is a necessary step for software reliability and quality, and software metrics of traditional procedure-oriented programming are fairly mature and have various methodologies and tools available for use. Object-oriented programming has recently became popular. However, traditional procedure-oriented software metrics are not appropriate for the development of object-oriented software. Some research into object-oriented software metrics has been proposed, but these articles focus on only one metric that measures a specific characteristic of the object-oriented software. The authors propose a new metric

methodology, the data scope complexity, for object-oriented software based on the data scope of a program. The data scope complexity can show complexities of multiple features of object-oriented programming at the same time. They also quantify and compare object-oriented programming with procedure-oriented programming.

[511] Webster, S., 'An annotated bibliography for object-oriented analysis and design', Information & Software Technology, 36(9), pp569-582, 1994.

Keywords: Rev

Abstract: Extensive bibliography on OO: 240 references of which 60 are annotated.

[512] Wei, L., Applying Software Maintaining Metrics in the Software Development Life Cycle. Masters Thesis , MIT, 1992.

Keywords: Maint, Emp, Prod

Abstract: Annotation from C. Gibbon.

This thesis is a more in-depth account of the paper presented by Wei and Henry on Maintenance Metrics. Wei's research concentrated on ten metrics in the OO paradigm, five of which were Chidamber and Kemerer's to provide statistical validation using maintenance effort. Two commercial system were used UIMS and QUES implemented in Classic Ada. The paper stipulates that maintenance effort can be predicted using complexity metrics; metrics collected from the source code design documents can predict maintenance effort; and finally it highlights empirical observations of the maintenance efforts patterns in the two commercial systems.

[513] Wessale, W., D. Reifer, et al., 'Large project experiences with object-oriented methods and reuse', J. Systems and Software, 23(2), pp151-161, 1993.

Keywords: C++, Ind, Reuse

[514] West, M., An investigation of C++ metrics to improve C++ project estimation. IBM internal paper , IBM, 1992.

Keywords: Des, Ind, Size, Tool, C++, Emp

Abstract: Martin West writes: "The paper includes some actual statistics from a number of class libraries. The statistics are basic metrics like LOC per method, LOC per class, methods per class. These were derived from an early version of CPPSTATS, an IBM Internal Metrics tool. Also included are some project metrics taken periodically through the project and showing variations in the metrics during the life-cycle.

Notes: Martin West is at A_M_West@uk.ibm.com.

[515] West, M., A data interchange format for OO metrics data. , IBM Hursley, UK, 1994.

Keywords: Prod

Abstract: Martin West writes: "A proposal for interchanging metrics data submitted to the Post-OOPSLA'95 OO Metrics Workshop workgroup. The document in postscript format can be obtained from the author". Such a data interchange format is a good thing in view of the warning of Churcher and Shepperd [Churcher, 1995, "Towards a Conceptual Framework for Object Oriented Software Metrics"].

[516] West, M., 'Taking the measure of metrics', Object Expert, 1(2), pp43-45, 1996.

Keywords: prod

Abstract: The article provides an introduction to object oriented (OO) metrics. OO metrics are an essential part of the continuing advancement of object technology. The "object" has provided additional measurement points at which the OO development cycle can be estimated and measured. There is much interest and a growing amount of research being done in this area. Metrics groups are being established and metrics is a recurring topic at OO conferences. However, little empirical data has been published. This may be for two reasons: there is not much data being gathered, and what has been gathered is seen as competitive advantage and is therefore closely guarded. There are a number of ways to approach OO metrics, and the article divides the metrics into four categories: size, productivity, quality, and reuse. Size and productivity are mainly concerned with project management. The quality metrics deal with how good and how complete the various deliverables are in an OO project. Reuse metrics cover both areas in that they are about productivity and quality. Reuse metrics is the most deficient area in this field of OO metrics. This is part of the reason why widespread large scale reuse is not being achieved.

Notes: Annotation from C. Gibbon.A short and concise paper outlining the four categories of OO metric: size; productivity; quality and reuse. Each category is examined and a means to collects actual data in the goal of validating/calibrating them described.

[517] Whitmire, S. A. 'Measuring complexity on object-oriented software', in Proc. 3rd International Conference on Applications of Software Measurement. La Jolla, CA: 1992.

Keywords: Prod

Notes: The ASM conferences are organised by Software Quality Engineering, 3000-2 Hartley Road, Jacksonville, FL 32257, USA, tel: (904) 268 8639, fax: (904) 268 0733, contact: Bill Hetzel. Alternatively, Scott A. Whitmire can be contacted at: Advanced Systems Research, 25238 127th Avenue SE, Kent Washington 98031, USA, tel: (206)631-7868, fax:(206)630-2238, E-mail: scottw@advsysres.com.

[518] Whitmire, S. A., Applying Function Points to Object-Oriented Software (chapter 13), in Software Engineering Productivity Handbook, J. Keyes, Editor, 1993.

Keywords: Size

[519] Whitmire, S. A., Object-Oriented Measurement of Software, in Encyclopedia of Software Engineering, J. Marciniak, Editor, John Wiley and Sons Inc.: New York, 1994.

Keywords: Des, Man, Rev

Abstract: Scott Whitmire writes: "The title is incorrect, it should be "Measurement of Object-Oriented Software", but they changed it to make it fit in the encyclopedia format. This short piece is a survey of the better works in the field as of last spring. It's major contribution is a framework for measurement, within which design-level measures fit quite nicely. It relates design-level measures with project-level and enterprise-level measures, and describes how they can be used."

[520] Whitmire, S. A. 'A formal object model for measurement', in Proc. OOPSLA'96 - workshop: OO product metrics. 1996.

Keywords: Theory

[521] Whitmire, S. A., Object-Oriented Design Measurement. John Wiley & Sons: New York, 1997.

Keywords: Rev, Theory

Notes: The book cover states: "Based on a thorough study of measurement theory, category theory, and a strong mathematical foundation, Scott Whitmire presents his own formal model of objects--a ground-breaking development for object-oriented design measurement. Using this model, or any other formal model, you can create a custom metric for any design characteristic you can describe through careful observation. This indispensable book guides you through the development process for nine unique design characteristics, including a controversial new quality of abstraction characteristic, which combines Sufficiency, Completeness, and Cohesion to help you determine the extent to which components include all the features required of your design.

With Object-Oriented Design Measurement, you'll get measures you can use right now to save time and money on software design, practical guidance through the process of creating your own measures, a culled history of metrics that pulls out the lessons learned for object technology, a mathematical basis for design simulation, a framework in which to place measures by audience, object of measurement, and purpose, and formal definitions and measures for design characteristics of object-oriented measures used in industry today, and new fashioned."

[522] Whitty, R. W. 'Applying Process Maturity Assessment Data to Evaluate Research in Object-orient Software Metrics', in Proc. Bournemouth Metrics Workshop. Bournemouth, UK: 1996.

Keywords: Man, Rev

Abstract: "An analysis is presented, part bibliographic part hermeneutic, of the literature relating to process maturity, software measurement and object-oriented metrics research. This analysis seems to suggest that there is a mismatch between what is of interest to object-oriented metrics researchers and what is of utility to users of object technology. This mismatch may be summed up by observing that, for a random company, there is a less than 50% chance that a random paper on object-oriented metrics will be of use to that company."

Notes: Can be obtained from the author at: robin.whitty@sbu.ac.uk

[523] Whitty, R. W., 'Object-oriented metrics: a status report', Object Expert, (January/February), pp39-44, 1996.

Keywords: Rev

Abstract: It is an article of faith that software systems engineering should be supported by measurement. It has taken a long time, however, for software metrics researchers to assemble the concepts and techniques needed to provide such support. It is only now that software metrics seems to be being taken seriously by industry, partly because of its key role in software process improvement. This newly matured discipline could find one of its first customers in object technology; indeed, the volume of research in metrics for object orientation seems to indicate that this has already happened. We report on the current status of object oriented (OO) metrics research and analyse what support is actually being made available for, say, OO cost estimation, making the switch to object orientation, or choosing between competing object technologies.

[524] Whitty, R. W., 'Object-oriented metrics: an annotated bibliography', ACM SIGPLAN Notices, 31(4), pp45-75, 1996.

Keywords: Rev

Notes: This annotated bibliography is meant to offer an authoritative coverage of what is known about the measurement of object-oriented (OO) technology and its use. `Measurement' is interpreted widely to include such matters as cost estimation, test management, surveys of the uptake of OO and industrial experience, provided these are to any extent quantitative. Its meaning has not been extended to general rules of style or principles of design. For instance, a study of cohesion as a desirable design property does not merit inclusion unless its actual measurement is involved; similarly articles on reuse and testing have not been included unless they are explicitly being measured in some way. Articles on metrics for Ada have been excluded unless there is a specific OO context (abstract data types have been allowed in, however). I have also excluded papers on performance measurement (benchmarking of compilers, etc.), since this is not normally considered part of software metrics. The bibliography entries are classified as follows: C++; empirical studies (including metric validation); industrial studies; management issues (including the case for OO); quality assurance and measurement (including ISO 9126 factors such as functionality, reliability, usability, efficiency, maintainability and portability); reuse and/or reusability measurement; product metrics (including complexity, coupling, etc.); sizing and estimation; Smalltalk; surveys (bibliographies, meeting reports, books etc.); and testing and/or testability measurement.

[525] Wilde, N. and R. Huitt, 'Maintenance support for object-oriented programs', IEEE Transactions on Software Engineering, 18(2), pp1038-1044, 1992.

Keywords: C++, Ind, Small, Emp, Maint

Abstract: Discusses maintenance problems associated with object technology: dynamic binding, object-dependencies, control of polymorphism etc. Gives some data on method size from three systems, one C++ and 2 Smalltalk. They found median method size to be 1, 2 and 3 LOC respectively. 50% of the methods were less than 2 LOC for the C++, and less than 4 for the Smalltalk. Useful to read this in conjunction with the following paper: Lejter, M., Meyers, S. and Reiss, S.P., "Support for maintaining object-oriented programs", same issue, 1045-1052, which looks in particular at inheritance and dynamic binding.

Notes: Norman Wilde is at University of West Florida, wilde@cs.uwf.edu, Ross Huitt is at Bellcore.

[526] Wilde, N., P. Matthews, et al., 'Maintaining object-oriented software', IEEE Software, 10(1), pp75-80, 1993.

Keywords: C++, Ind, Small, Emp, Maint

Abstract: Gives some empirical results on inheritance depth and method size.

[527] Wilkie, F. G. and B. Hylands, 'Measuring Complexity in C++ Software', Software Practice and Experience, 28(5), pp513-546, 1998.

Keywords: C++, Prod, Emp

Abstract: The paper concerns the use of design/source code complexity metrics in analysing C++ software. It describes the use of one suite of object oriented metrics published by S.R. Chidamber and C.F. Kemerer (1994) to evaluate a commercial C++ application. It provides an interpretation and critique of these metrics, including the use of two traditional metrics (Cyclomatic Complexity (T.J. McCabe, 1976) and Software Science (M.H. Halstead, 1977)) in association with these object oriented metrics. The evolution, over a two and a half year period of one commercial grade C++ application comprising 114 classes with 25000 lines of code is studied. The efforts consumed in bug fixes and enhancements are correlated with the complexity measures on a per class basis, and results are presented. These results are compared to those from other workers. The paper provides a detailed analysis of the practical strengths and weaknesses of the metrics suite in the light of experiences with its use.

[528] Williams, J. D. 'Metrics for object oriented projects', in Proc. Object EXPO Europe. SIGS Publications, New York, NY, USA, 1993.

Keywords: Prod, Man

Abstract: Metrics are a much used and much abused tool of software engineering. Ostensibly, their purpose is to improve the quality of software. In practice, they haven't always been effective. The emphasis of the author is on practical metrics that help the developer track the progress of his project and analyze the quality of the system he is developing. Object oriented metrics that move beyond the 'rule of thumb' method are relatively new. Conventional software metrics are inadequate for analyzing object oriented systems. New metrics, that measure the quality and object orientedness of systems, are being created by developers who need more information about the systems they develop. This is also true for metrics that track the swirling ebb and flow of an object oriented project during development. The author presents several metrics that have proven useful in analyzing object oriented systems and tracking system development.

[529] Williams, J. D. 'Metrics for object oriented projects', in Proc. Software. DevCon '94. SIGS Publications, New York, NY, USA, 1994.

Keywords: Prod, Man

Abstract: The paper presents several metrics that have proven useful in analyzing object oriented systems and tracking system development. There are a set of practical metrics, that move beyond the rule of thumb approach for object oriented systems. These metrics can help you manage and track project development They can help point out areas in the process that need improvement. There are other object oriented metrics that help you understand how well you have made use of object oriented technology in your design and implementation. These metrics were not developed to give managers something to report. They were developed to improve the quality of software. They are not an exhaustive set of metrics, but they have proven helpful in delivering quality software on time and under budget.

[530] Williams, J. D. 'Metrics for object-oriented projects', in Proc. OOP'94 and C++ World. SIGS Publications, 1994.

Keywords: Prod, Man

Abstract: Metrics are a much used and much abused tool of software engineering. Ostensibly, their purpose is to improve the quality of software. In practice, they haven't always been effective. The emphasis of this paper is on practical metrics that help the developer track the progress of his project and analyze the quality of the system he is developing. This is not an exhaustive treatise on object oriented metrics, but this paper goes farther than the current craft approach. Object oriented metrics that move beyond the "rule of thumb" method are relatively new. Many of the books on object oriented methodology do not even mention them. Conventional software metrics are inadequate for analyzing object oriented systems. New metrics, that measure the quality and object orientedness of systems, are being created by developers who need more information about the systems they develop. This is also true for metrics that track the swirling ebb and flow of an object oriented project during development. This paper presents several metrics that have proven useful in analyzing object oriented systems and tracking system development.

[531] Wirfs-Brock, R., 'How designs differ', Report on Object Analysis and Design (ROAD), 1(4), pp51-53, 56, 1994.

Keywords: Des, Emp, Prod

Abstract: Annotation from C. Gibbon.

A comparison to two methods of design upon the same problem domain is re-examined. Originally conducted by Sharble and Cohen, this paper highlights the significance of the differences and similarities between the responsibility-driven and data-driven design approaches. Chidamber and Kemerer design metrics are used to compare the final results. Most notably, the responsibility-driven approach boasted a delegated control style, fewer messages and inherited behaviour, and the data-driven approach a centralized control architecture, more low level messages and inherited attributes.

[532] Wirfs-Brock, R., B. Wilkerson, et al., Designing Object-Oriented Software. Prentice-Hall: 1991.

Keywords: Des

Abstract: David Tegarden writes: "in Chapter 7, they talk about coupling between classes. They do not propose any metrics. They only suggest that 'strongly interdependent classes may be connected by a frequently used collaboration ...' ".

[533] Yamazaki, S., K. Kajihara, et al., 'Object-oriented design of telecommunications software', IEEE Software, 10(January), pp81-87, 1993.

Keywords: Des, Emp, Ind

Abstract: "To evaluate the ROOD method, we designed some telecommunications software twice. The 1st time was an experiment to check ROOD's suitability...In the experiment, 2 programming teams developed 2 identical sections of the system, one using ROOD and the other using functional decomposition." The

resulting code was compared for extendibility (ROOD scored 2.5 times higher no. of modules needing change and 3.0 times higher no. of bugs found in development); performance (ROOD scored 10% slower), size (ROOD scored 1.6 times larger) and no. of modules (ROOD scored 3.6 times greater). These figures make ROOD seem worse on all counts - I think the extendibility figures have been printed the wrong way round.

[534] Yogeesh, K. H. and J. G. Smith, 'Experiences in C++ and object-oriented design', Journal of Object-Oriented Programming, 5(7), pp23-28, 1992.

Keywords: C++, Ind, Qual

Abstract: Discusses AT&T's Call Attempt Data Collection Services (CADCS) project: 200K LOC written in C++ and 'other'. Data given includes 'staffing ramp up with OOD/C++ learning curve'; numbers of modification requests for two successive releases; and class use/reuse over the two releases. Generally, the introduction of OOD/C++ was judged a success.

[535] Yousfi, N. 'Measuring internal attributes of object-oriented software products', in Proc. TOULOSE '92. Software Engineering and Its Applications. EC2, Nanterre, France, 1992.

Keywords: Prod

Abstract: The best known way of ensuring that software products are built correctly is to apply methods which one way or another impose certain structural-type attributes. Understanding the relative importance of internal attributes is thus one of the ways that exist in software engineering for understanding software failures due to incorrect development. More importantly, this is the only way developers are able to make accurate predictions about the external 'quality' of the software without actually running it. In many situations, such predictions have to be made even before an implementation version is made. The author puts forward a set of such attributes for object-oriented software products.

[536] Zhuo, J., P. Oman, et al. 'Using relative complexity to allocate resources in gray-box testing of object-oriented code', in Proc. Fourth International Software Metrics Symposium. IEEE Comput. Soc, Los Alamitos, CA, USA, 1997.

Keywords: Test, Emp, C++

Abstract: Software testing costs would be reduced if managers and testing engineers could gauge which parts of a system were more complex and thus more likely to have faults. Once these areas are identified, testing resources and testing priority could be assigned accordingly. The paper defines a method that uses the relative complexity metric to allocate resources for gray box testing in an environment where object oriented code is used and historical data are not available. The proposed method can also be applied to black box and white box testing as well as software quality assessments such as maintainability and reliability. The work on an industrial C++ software subsystem presented here shows that the rank order of minor test areas of the subsystem by relative test complexity is significantly similar to the rank order obtained from the experts who designed, wrote and tested the code.

[537] Zhuo, J., R. Pichai, et al. 'On the validation of relative test complexity for object-oriented code', in Proc. Fifth International Software Metrics Symposium. IEEE Comput. Soc, Los Alamitos, CA, USA, 1998.

Keywords: Test, C++, Emp

Abstract: In order to help software managers and engineers allocate test resources in object-oriented software development, the Relative Test Complexity (RTC) metric was proposed and applied to an industrial system developed in C++. The initial validation by an engineering quality circle supported the validity of the RTC metric. In this paper, the RTC metric is further validated using actual fault data. It is shown that the RTC metric is a better surrogate of faults than Relative Complexity (RC), Harrison's Macro-Micro Complexity (MMC), McCabe's cyclomatic complexity (V(g)), Halstead's effort (E), and simple measures of size like LOC. Finally, the RTC and RC models are applied to change data with results that indicate that the RTC and RC metrics can be used to predict source code turmoil.

[538] Zuse, H., Foundations of the validation of object-oriented software measures, in Theorie und Praxis der Softwaremessung, H. Zuse and D. Reiner, Editors, DUV Deutsche Universitätsverlag: 1994.

Keywords: Size, theory

Abstract: Application of Zuse's measurement theory techniques to the OO domain. In particular, it is argued on theoretical grounds that the basic COCOMO model cannot be used in this domain.

Notes: These techniques are not for the faint-hearted: the reader is recommended to look first at Horst's book Software Complexity: Measures and Methods, De Gruyter, Berlin, 1991 . A gentle introduction to measurement theory in an OO rather than a software metrics context, is Kristen 1994 .

[539] Zuse, H. 'Foundations of object-oriented software measures', in Proc. 3rd International Software Metrics Symposium. IEEE Comput. Soc. Press, Los Alamitos, CA, USA, 1996.

Keywords: Theory

Abstract: The foundations of the properties of object-oriented software measures are presented. The criteria for these measures are characterized with several binary operations between objects, classes, methods, etc. Binary operations can be used as a tool to give numbers an interpretation above the ordinal scale level. The result of our investigation is that software measures for object-oriented programs mostly do not assume an extensive structure. In order to obtain qualitative criteria for object-oriented measures, the Dempster-Shafer belief function, the Kolmogoroff axioms and the DeFinetti axioms are introduced. These axioms give qualitative criteria for the use of object-oriented software measures between the weak order and the extensive structure.

[540] Zuse, H. and T. Fetcke. 'Properties of Object-Oriented Software Measures', in Proc. 7th Annual Oregon Workshop on Software Metrics. Silver Falls, Oregon: 1995.

Keywords: Theory

Abstract: In this paper foundations of the properties of object-oriented software measures are presented. The criteria for the properties of object-oriented software measures are characterized with several concatenation operations between objects, classes, methods etc. Concatenation operations can be used as a tool to give numbers an interpretation above the ordinal scale level. The result of this investigation is that software measures for object-oriented techniques have completely other properties than measures for imperative languages. It is shown that many of the measures in the object-oriented programming area follow the Dempster-Shafer Measure of Belief in Artificial Intelligence. The consequences of these properties of object-oriented measures related to prediction models and validation are also discussed.

[541] Zweben, S. H., S. E. Edwards, et al., 'The effects of layering and encapsulation on software development cost and quality', IEEE Trans. on Software Eng., 21(3), pp200-208, 1995.

Keywords: Des, Emp, Qual

Abstract: Reports on three experiments using students. The language concerned was Ada and the study is more to do with abstract data types than OO. From the conclusion: "The results of our experiments support the contention that, by using only a description of the functionality of and interfaces to existing components, new components can be developed with less effort than that required if the source code and representation data structures of the existing components are also used. In addition, it appears from our experiments that there certainly is no loss in the quality of the development process, at least in terms of the number of defects made during development, when the layering approach is used." These results may be compared with those of [Mitchell, 1987]. The paper is also concerned to emphasise the importance of a careful statistical approach, as exemplified by this observation from the Discussion: "...had the analysis of the defect data for the experiment 1 not corrected for overdispersion, it would falsely have concluded that there was a significant effect favoring layering."

Notes: Stuart Zweben is at zweben@cis.ohio-state.edu, Stephen Edwards is at edwards@cis.ohio-state.edu, Bruce Weide is at weide@cis.ohio-state.edu, Joseph Hollingsworth is jholly@ius.indiana.edu.