Software Engineering Metric for Object Oriented Programming

Document Sample
Software Engineering Metric for Object Oriented Programming Powered By Docstoc
					Software Engineering Metrics for Object Oriented
                 Programming

                                                       Name – Shrijit Joshi
                                                       Course – CSC 532
                                                       Instructor – Dr. Box
                                                       Email – ssj005@latech.edu
                                                       Date – November 3, 2005




 Abstract
              Software engineering metrics is an important feature in the software
 management functions of project planning and project evaluation. Researchers have
 developed various metrics for object oriented software development environment as
 there has been an extensive use of object oriented methods in software development.
 Object oriented programming requires a different approach in design and
 implementation than that in structured programming. In addition to this, as objects are
 the fundamental building blocks for the object oriented programming rather than
 algorithm, the approach of software engineering metrics for the object oriented
 environment should be different from the functional programming environment. Hence,
 object oriented paradigm results in new relationships within module and among other
 software modules. Metrics developed for structured programming do not account for
 these new relationships and may be insufficient for use in object oriented environment.
 In this context, this paper reviews various software engineering metrics for the object
 oriented development environment in the literature.

 Keywords
              Object oriented programming, Software engineering metrics

 1. Introduction
             ‘Software’ refers to a program and all of the associated information and
 materials needed to support its installation, operation, repair and enhancement [1].
 ‘Software engineering’ refers to the disciplined applications of engineering, scientific



                                                                                       1
and mathematical principles and methods to the economical production of quality
software [1, 2]. The field of software engineering was born in 1968 in response to the
chronic failures of large software projects to meet schedule and budget constraints [2].
Software engineering process constitutes of – (1) requirement, (2) analysis, (3) design,
(4) implementation, and (5) test work flows. One of the key issues in the management
of the development process is the capability to measure and record the relevant
attributes of the software products and of the process itself in a structured and coherent
framework [3]. The availability of the software metric helps manager to control the
various activities of the development life cycle and contributes to the overall objective
of software quality.
             Object oriented programming is a popular concept in today’s software
development environment. They are often heralded as the silver bullet for solving
software problems, while in reality there is no silver bullet; object oriented technology
has proved its value for the systems that must be maintained and modified [4]. To
evaluate the quality of the object oriented software, we need to assess and analyze its
design and implementation using appropriate metrics and evaluation techniques [5].
Metrics developed for structured programming may be insufficient for assessing and
analyzing the design and implementation of the object oriented development
environment. In this context, this paper illustrates various software engineering metrics
for the object oriented development environment and answers whether any of the
traditional metrics can be adapted to the object oriented environment.
              The rest of the paper is organized as follows – Section 2 deals with the
characteristics and the importance of having software engineering metrics for software
development. Section 3 reviews various software engineering metrics for object
oriented programming and conclusion of this term paper is given in section 5.

2. Characteristics and Importance of Software Engineering Metrics
            Software engineering metric provides measurement which is an ideal
mechanism for characterizing, evaluating, predicting, and providing motivation for the
various aspects of software construction processes and products [6-9]. Using the
software metric, understanding of both the product and the construction process is
achieved if measurements are taken on both the software processes and the various
software products [6, 10]. This helps in improving the quality of the product.
             Subjective and objective metrics are required for achieving the success of
applying metric for object oriented programming. Many process, product and
environment aspects can be characterized by either subjective or objective metrics.
Other aspects which are not characterized by both; but they can be characterized on a
quantitative scale to a reasonable degree of accuracy [6, 8, 11]. Most aspects of
software processes and products are too complicated to be captured by a single metric.
For definition and interpretation purposes, a set of metrics that frame the purpose for
measurement needs to be defined [6, 9].




                                                                                        2
             Software engineering metric helps in [3] – (1) identification of ‘hidden’
problems in earlier stages, (2) effective control of quality, and (3) providing the most
comprehensive solution to the problem of evaluating the benefits of technological
migration or transition.
              Although the metrication in object oriented environment seems to be
familiar, traditional software metrics are aimed at the traditional procedural – oriented
languages. Traditional software metrics do not address the various issues in object
oriented paradigm like – classes, methods, inheritance, polymorphism, encapsulation
etc [3]. Thus, a number of researchers have developed various metrics for object
oriented environment to manage and foster quality in object oriented software
environment.
3. Software Engineering Metrics for Object Oriented Environment
             The problem of assessing the design quality of object oriented system has
been of interest to many researchers [12-17]. This paper demonstrates the candidate
metrics derived by Morris [18] for productivity measurement while making
observations on object oriented code.
            List of software engineering metrics for object oriented environment
derived by Morris [18, 19] are as follows –
                                   (1)     Methods per class,
                                   (2)     Inheritance dependencies,
                                   (3)     Degree of coupling between objects,
                                   (4)     Degree of cohesion of objects,
                                   (5)     Object library effectiveness,
                                   (6)     Factoring effectiveness,
                                   (7)     Degree of reuse of inheritance methods,
                                   (8)     Average method complexity,
                                   (9)     Application granularity.


             3.1 Methods per class [18]
                     Addition of a method to an object increases the size of the object.
             Thus, the larger number of methods per object complicates testing due to
             the increased object size and complexity.
             3.2 Inheritance dependencies [18]
                    In the context of reusability, inheritance tree depth is likely to be
             more favorable than the inheritance tree breadth. But in terms of testing,
             deep inheritance is difficult to test.



                                                                                       3
             3.3 Degree of coupling between objects [18]
                     In the context of reusability, the higher the degree of object
             independence the more likely the object will be suitable for reuse within
             the same applications and within other applications. Testing is likely to
             degrade with the higher the degree of coupling between objects as object
             interactions and interconnections are more complex.
             3.4 Degree of Cohesion of Objects [18]
                      In the context of reusability, the objects which are less dependent
             on other objects are likely to be more reusable. Though, in terms of
             reliability low degree of cohesion adds complexity which can translate
             into a reduction in application reliability.
             3.5 Average method complexity [18]
                      In terms of reliability, greater method complexity adversely affects
             the application reliability. In terms of testing, greater method complexity
             is difficult to test.
             3.6 Degree of reuse of inheritance methods [18]
                     Simply defining methods in such a way that they can be reused via
             inheritance does not guarantee that those methods are actually reused.
     Fernando [3] derived various software engineering metric for object oriented
     programming. Here in this paper, we will consider size metrics derived by [3].
             3.7 Size metrics [3]
                 Size metrics are an important piece of the resource estimation process.
             Various candidate size metrics derived by [3] are – (1) method size
             metrics, (2) class size metrics, (3) system size metrics.


4. Conclusion
             This paper presents an overview of a compilation of software engineering
metrics for object oriented programming environment that should be considered
throughout the development life cycle. Software engineering metrics derived by Morris
and Fernando are also studied in this paper. Applications of software engineering
metrics to software development results in developing a clearer picture of system with
regard to whether the notion of the object oriented programming has been fully applied
to the best of its capabilities. In addition to this, these software metrics are useful in
estimating any shortcomings of a similar nature that can be rectified in the future
systems.



5. References

                                                                                        4
1.    Humphrey, W.S., The Software Engineering Process: Definition and Scope. The
      Mythical Man-Month. 1975: Addison Wesley.

2.    Carlo Ghezzi, Mehdi Jazayeri, and D. Mandrioli, Fundamentals of Software
      Engineering.

3.    Fernando Brito e Abreu and R. Carapuça, Candidate Metrics for Object-Oriented
      Software

      within a Taxonomy Framework. Journal of Systems and Software, July 1994.
      26(1).

4.    Rosenberg, L.H., Applying and Interpreting Object Oriented Metrics. Software
      Assurance Technology Center, NASA.

5.    Sherif M. Yacoub, Hany H. Ammar, and T. Robinson, Dynamic Metrics for
      Object Oriented Designs.

6.    Victor R. Basili and H.D. Rombach, The TAME Project: Towards Improvement -
      Oriented Software Environments. IEEE Transactions of Software Engineering,
      June 1988. 14(6).

7.    Basili, V.R. Quantitative evaluation of software engineering methodology. in
      First Pan Pacific Computer Conference. July 1985. Melbourne, Australia.

8.    V. R. Basili, ” in Proc. Tenth Annu. Sojiware Engineering, N.G.S.F.C. Workshop,
      Greenbelt, MD, Dec., and 1985. Can we measure software technology: Lessons
      learned from 8 years of trying. in Tenth Annu. Sojiware Engineering Workshop.
      Dec. 1985. NASA Goddard Space Flight Center, Greenbelt, MD,USA.

9.    V. R. Basili and E. E. Katz. Measures of interest in an Ada development. in IEEE
      Computer Society Workshop Software Engineering. Apr. 1983. Technology
      Transfer, Miami, FL.

10.   Agresti, W. SEL Ada experiment: Status and design experience. in Eleventh Annu.
      Software Engineering Workshop. Dec. 1986. NASA Goddard Space Flight
      Center, Greenbelt, MD.

11.   -. Tailoring the software process to project goals and environments. in Ninth Int.
      Conference on Software Engineering. 1987. Monterey,CA.

12.   S. Chidamber and C. Kemerer, A Metrics Suite for Object Oriented Design. IEEE
      Transactions on Software Engineering, June 1994. 20(6): p. 476-493.




                                                                                      5
13.   Hitz, M. and B. Montazeri. Measuring Coupling and Cohesion in Object-oriented
      Systems. in International Symposium on Applied Corporate Computing. Oct.
      1995. Monterrey, Mexico.

14.   M. Hitz and B. Montazeri. Measuring Product Attributes of Object-Oriented
      Systems. in 5th European Software Engineering Conference (ESEC `95).
      Barcelona, Spain.

15.   M. Hitz and B. Montazeri, Chidamber & Kemerer's Metrics Suite, A
      Measurement Theory Perspective. IEEE Transactions on Software Engineering,
      April 1996. 22(4): p. 276-270.

16.   L.Briand, P. Devanbu, and W. Melo. An Investigation into Coupling Measures for
      C++. in 19th International Conference on Software Engineering (ICSE'97). May
      1997. Boston.

17.   L. Briand, J. Daly, and J. Wurst, A Unified Framework for Coupling
      Measurement in Object-Oriented Systems. IEEE Transaction on Software
      Engineering, Jan/Feb 1999. 25(1): p. 91-121.

18.   Morris, Metrics for Object-Oriented Software Development Environments, in
      Master's Thesis, Sloan School of Management. 1989, M. I. T.

19.   http://irb.cs.uni-magdeburg.de/sw-eng/us/oop/morris.shtml




                                                                                  6

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:5
posted:11/4/2012
language:English
pages:6