Evaluating the Quality of UCP-Based Framework using CK Metrics

Software effort estimation is one of the most important concerns in the software industry. It has received much attention since the last 40 years to improve the accuracy of effort estimate at early stages of software development. Due to this reason, many software estimation models have been proposed such as COCOMO, ObjectMetrix, Use Case Points (UCP) and many more. However, some of the estimation methods were not designed for object-oriented technology that actively encourages reuse strategies. Therefore, due to the popularity of UCP model and the evolution of the object-oriented paradigm, a UCP-based framework and supporting program were developed to assist software developers in building good qualities of software effort estimation programs. This paper evaluates the quality of the UCP-based framework using CK Metrics. The results showed that by implementing the UCP-based framework, the quality of the UCP-based program has improved regarding the understandability, testability, maintainability, and reusability. Keywords—ucp-based framework; use case points; ck metrics


I. INTRODUCTION
Software effort is defined as the person months required to make a software application [1].This definition is close to [2] who define software effort as the number of staff days/weeks/months or even years associated with a project.Software effort estimation (SEE) can broadly be defined as the process of estimating the effort required to develop a software project [3].It has been focused by many researchers over the past 40 years [4] and nowadays, it has become one of the most important concerns of the software industry [5]- [9].
There are many software estimation models have been proposed to improve the accuracy of effort estimate at early stages of software development [10]- [12].However, some estimation methods were not designed to work well with object-oriented technology that introduces inheritance and actively encourages reuse strategies.SLIM [13], Checkpoint [14], PRICE-S [15], SEER [16], COCOMO II [10], ObjectMetrix [17], [18] and Use Case Points [19] are among the popular object-oriented estimation models that have been widely used in previous studies.
Use Case Points (UCP) is a software sizing and estimation method adopted from the standard Function Point (FP) method in solving the specific needs of object-oriented systems based on use cases [20], [21].It was developed by Gustav Karner at Objectory Systems [19].Previous studies have demonstrated that the accuracy of UCP estimations was quite close to the actual estimates [22]- [25].Due to the popularity of UCP, in the last two decades, many UCP-based effort estimation techniques have been proposed [24], [26]- [35], either to give more options or to enhance the capability of UCP.Studies also showed that some parts of UCP-based models have similarity in estimating software effort [19], [24], [30], [32].However, just a few of them are equipped with proper estimation tools.Most of them used MS Excel to calculate the estimates [36], [37].
To date, software developers have very little guidance to develop quality UCP-based software effort estimation using the object-oriented approach.Even though a tool known as U-EST was developed using Java programming language, the design framework was not accessible to the public [38].The authors also did not claim that the tool was well-designed and able to be reused or extended by other developers.Therefore, a new framework for UCP-based software effort estimation was developed to promote the reusability of UCP.Without reusability, software applications are very hard to maintain or extend [39]- [42].
Therefore, this study aims to evaluate the quality of UCP-based framework using CK Metrics.The framework was designed using UML notations after identifying the class dependencies using Java programming language.The remainder of this paper is structured as follows.Section II and III provide some basic concept of the UCP-based framework and CK Metrics respectively.Section IV describes the experimental research design.Experimentation results and discussion are discussed in section V. Section VII includes conclusion and suggestion for future work.

II. THE PROPOSED UCP-BASED FRAMEWORK
The UCP-based framework is defined as a general reusable solution for UCP-based software effort estimation design.This framework is not a finished design that can be transformed directly into source codes.It is a description or template for solving a UCP-based problem that can be used in many different design approaches [43].This framework was formed based on four UCP-based models namely Use Case Points (UCP) [19], Adapted Use Case Points (AUCP) [30], Industrial use of Use Case Points (IUCP) [24] and Simplified Use Case Points (SUCP) [32].Fig. 1 illustrates the UCP-based framework.
The UCP-based framework shows how the elements are structured, and how they work together.In other words, the UCP-based framework is more to the abstract level of Fig. 1.A UCP-Based Framework software design, where the abstraction and implementation are independent.The implementations may vary dynamically [44].This framework captured the important aspects of the UCP-based models to visualize the main packages, classes, and the relationship among them.By using this UCP-based framework, software designers can easily conduct experiments and propose the possible well-designs which can contribute to high-quality software.This framework is also useful especially in software maintenance because it suggests the high-level aspects of UCP-based requirements.By using this framework, the existing UCP-based programs can be changed or extended systematically.
The main elements of the UCP-based framework are classes and use two types of relationships namely association and generalization.The classes determine the general concept of UCP domain knowledge where every software designer familiar and understandable.Classes can be interpreted at various levels in software design.In the early stages of software design, the UCP-based framework captures more logical aspects of the problem.In the later stages, the framework can be extended to any object-oriented design decisions based on the software designer's experience and creativity.In this study, a class is drawn as a rectangle.
Overall, there are 19 classes, and 12 of them are the principal classes where the principal classes are derived from the UCP model.In general, the UCP-based framework is divided into three main components: project size, project complexity, and risk factors.These three main components are based on the estimating principle defined by Garmus and Herron [45].Project size is composed of six classes.Five of the classes are the principal classes while AUCP_UAW class is the extended class.Project complexity includes four principal classes as well as four extended classes namely IUCP_EFactor, SUCP_EFactor, IUCP_TFactor, and  [36] are associated with the association relationship.This means that without these key classes the effort estimation cannot be done completely.

III. CHIDAMBER AND KEMERER (CK) METRICS
Software metrics play a major role in comparing different versions of object-oriented programs [46].One of the most popular object-oriented metrics and the most thoroughly investigated is CK Metrics [47].It was introduced by Chidamber and Kemerer [48] and has been a subject of discussion since the last two decades.The authors themselves and other researchers have carried out a series of experiments to improve the accuracy of the metrics.Even though it was proposed quite a long time ago, the usefulness in analyzing open-source software is still significant [49]- [52], including examining the reusability of software projects [53].
Chidamber and Kemerer proposed six metrics for evaluating the quality of software design namely Weighted Method per Class (WMC), Response For a Class (RFC), Lack of Cohesion in Methods (LCOM), Coupling Between Objects (CBO), Depth of Inheritance Tree (DIT) and Number of Children (NOC).The definition of each metric can be found in [48].The metrics have been theoretically validated and widely accepted standard to be used as early quality indicators [52], [54]- [58].By using these metrics, it will help software designers to make a better decision in designing any object-oriented software applications.

IV. EXPERIMENTAL SETTING
The object-oriented approach is very important among all software practitioners.Generally, encapsulation, inheritance, and polymorphism are three main object-oriented principles that are applied throughout the whole object-oriented software engineering process [59].Instead of these three principles, abstraction is also considered as a key element in designing software applications.By using abstraction, the complexity of a large problem can be minimized.The idea of abstraction is to identify common features in two or more classes and abstract those features out into a higher-level class [60].A good design, each method in a well-designed class should support abstraction and encapsulation [61].In this case, all common functionalities of UCP-based models were grouped to form reusable abstract classes.
In this experiment, a new program known as Like-UCP was developed to simulate the UCP-based framework.In order to achieve the consistency between the UCP-based framework and Like-UCP program, the Like-UCP was designed based on four object-oriented programming principles; abstraction, inheritance, encapsulation, and polymorphism.The design must ensure that, for every abstract class of Like-UCP, the subclass must implement the method from the abstract class unless the subclass is also an abstract class.
After completing the development, CK Metrics was used to measure the quality of Like-UCP program.It is impossible to obtain the Like-UCP metrics without using supporting tools.Thus, in this study, CK Java Metrics (CKJM) extended version 2.2 [62] was used to obtain the metrics.CKJM is an open-source program which was also written in Java programming language used to obtain six CK Metrics of the object-oriented programs.In many cases, no single design style can meet all quality attributes simultaneously.Software architects or designers often need to balance among quality attributes.Most of the time, a new program needs refinement, extension, generalization, or improvement [63].Therefore, if the quality of Like-UCP program did not achieve the desired quality attributes, repetition process from designing the UCP-based framework must be done.
Then, each of the classes was analyzed, and each metric was calculated to obtain the mean value.The mean value of each metric was used as an indicator of quality measurements.Finally, the obtained results were concluded based on the relationship between CK Metrics, Object-oriented Design (OOD) measures, and quality factors.Table I and Table II show the relationship between CK Metrics and OOD measures, and the relationship between CK Metrics and quality factors respectively [64].

V. EXPERIMENTATION RESULTS AND DISCUSSION
The Like-UCP program was developed using Java programming language to evaluate the quality of the  UCP-based framework.To visualize the dependencies between classes, class diagram of Like-UCP was generated in Eclipse environment.Fig. 2 shows the class dependencies of Like-UCP program.Basically, each of the classes is a replication of UCP-based framework using the object-oriented approach.As can be seen in Fig. 2, some of the classes such as UCP_UUCW, Unadjusted_UseCasePoints, and UseCasePoints have high dependencies compared to other classes.In other words, these three classes are required by all the identified UCP-based models to form the UCP-based framework.
To obtain the empirical evidence of quality attributes achieved by Like-UCP program, 22 classes (19 classes derived from the UCP-based framework with three additional driver classes) were analyzed using CKJM-extended-2.2.Table III and Table IV present the descriptive statistics of Like-UCP program and the summary of all the metrics respectively.In this experiment, the total number line of codes (LOC) of Like-UCP is 2556 with the mean value 116.18.The maximum LOC is 380 used by IUCP class, and the minimum is 11 used by UseCasePoints class.The next sub-sections will discuss the obtained results and compare with the suggestions in [48].

A. Weighted Method per Class (WMC)
The number of methods and the complexity of the methods involved indicate how much time and effort is required to develop and maintain the class.The larger the number of methods in a class, the higher the potential impact on subclasses, since subclasses will inherit all the methods defined in the superclass.It was recommended that most classes should have a small number of methods, maximum up to 10 methods in a class [48].If WMC value is one, it was recommended that to merge the class in some other classes within the same package without influencing the LCOM value, that is without affecting the abstraction and encapsulation of the classes.If WMC value is zero, the possibility of a redesign is high.If WMC over than 20, the class should be refactored to reduce the complexity of the software project.20 WMC is consistent with the threshold value suggested by Shatnawi [65].
Based on the WMC statistics shown in Table IV, it can be seen that the mean value of the WMC metric is 6.50 which is less than 10.Only four classes, TechnicalComplexity, EnvironmentalComplexity, IUCP_PF, and IUCP have more than 10 but still below 20 WMC.None of the classes has

B. Response For a Class (RFC)
RFC is the number of methods that can be invoked in response to a message in a class.If RFC for a class is large, it means that there is high complexity [48].If RFC increases, the effort required for testing will increase because the test sequence grows.The overall design complexity of the class also increases and it is difficult to maintain the classes later on.The RFC for a class should usually not exceed 50 although it is acceptable to have RFC up to 100 [66].However, Shatnawi [65] suggested that the threshold value for RFC is 40.Based on the RFC statistics shown in Table IV, it can be seen that the mean value of the RFC metric is 15.23.None of the classes exceed 50.Fig. 3 shows that only one class which is IUCP has more than 40 RFC.Overall, the low values of RFC indicate that the Like-UCP design is less complex.

C. Lack of Cohesion in Methods (LCOM)
The cohesiveness of methods inside a class is desirable since it promotes encapsulation and decreases the complexity of the objects.High cohesion decreases complexity, thereby decreasing the probability of errors during the development process [48].Accordingly, a high LCOM value is a major issue in all the software projects.High LCOM value shows poor encapsulation and abstraction at the class level.The general threshold for LCOM is classified as Good: 0, Regular: range between 1 − 20 and Bad: > 20 [67].Based on the LCOM statistics shown in Table IV, the mean value of LCOM is 15.91.This value indicates that most of the classes are normal and less complex.Only six classes, UCP, AUCP, IUCP, IUCP_PF, TechnicalComplexity, and EnvironmentalComplexity have greater than 20.However, as can be seen in Fig. 3, only one class which is TechnicalComplexity has a very high value of LCOM.Fig. 4 also shows that the total value of TechnicalComplexity class is also the highest among all classes of Like-UCP.The results indicate that the TechnicalComplexity class should be re-designed to improve the quality the overall quality of Like-UCP program.

D. Coupling Between Objects (CBO)
In general, objects should be loosely coupled, which implies there ought to be a little dependency between objects.High coupling implies that the sensitivity to changes in other classes is also high which may indicate poor class design [48].A class which is tightly coupled will cause a large ripple effect when an object is changed and increasing the risk of regressions.Furthermore, testing all the changes will be tedious and hard to check.In contrast, the low CBO values demonstrate that most of the classes refer to a few other classes.In other words, the more independent a class is, the easier to reuse it in other applications.Therefore, it increases the understandability, efficiency, and reusability of the class design [48].A measure of coupling is useful to determine how complex the testing of various parts of a class design are likely to be.It was suggested that classes with a CBO more than 19 should be examined to reduce coupling [65].Based on the CBO statistics shown in Table IV, the mean value of CBO is 3.82.None of the CBO values greater than 19.The maximum value of Like-UCP is nine which is equal to the threshold value suggested by Shatnawi [65].Therefore, it can be concluded that the possibilities of understandability, efficiency, and reusability of the class design are very high.

E. Depth of Inheritance Tree (DIT)
DIT is the length of the longest path from a subclass to the superclass in the inheritance hierarchy.A high value of DIT implies more reusability, but the complexity of the class design may increase due to more methods and classes involved [48].Classes with bunches of subclasses need to be very carefully modified to avoid regressions in those subclasses.One conceivable solution is that the classes ought to be more abstract with a reasonable number.It was proposed that the maximum value of DIT should be less than 10 [48].If DIT value is zero or one, it demonstrates poor reusability of the class.Based on the DIT statistics shown in Table IV, the mean value of DIT is 1.5.This value indicates that inheritance was rarely used in Like-UCP program, mainly because of the domain model.Consequently, the program did not have a deep inheritance tree.However, the maximum value of DIT is two which is evaluated as Good/Common by DIT threshold [68].Therefore, with 1.5 DIT, Like-UCP program can be concluded as potentially to be reused and easy to be understood by software developers.

F. Number of Children (NOC)
Inheritance is a form of reuse.Thus, the greater the number of subclasses for a class, the greater reuse.However, a large number of subclasses may introduce inappropriate abstraction of the superclass.It is better to have depth than breadth in the inheritance hierarchy [48].In other words, high DIT and low NOC is the perfect combination for software design.Low values of DIT and NOC are firmly indicated that reuse through inheritance may not be completely adopted [48].Based on the NOC statistics shown in Table IV, the majority of the classes (77%) have no subclasses, and the mean value of NOC is 0.50 which is less than the mean value of DIT.Fig. 3 shows that Like-UCP program has a minimal number of outliers.The results indicate that the Like-UCP program may not be using inheritance of methods as a basis for designing classes.However, these results are consistent with the previous case studies [48].Due to the mean value of NOC smaller than the mean value of DIT, most probably the Like-UCP classes are potential to be reused by other UCP-based programs.

VI. THREATS TO VALIDITY
Each of metric tools might interpret and produce a different set of results.To avoid this problem, the replication of this study must follow the interpretation that we describe in this paper.However, we encourage readers to use different metric tools with different programming languages.

VII. CONCLUSION AND FUTURE WORK
This study presents an evaluation of UCP-based framework using CK Metrics.In order to achieve this objective, Like-UCP program was developed using Java programming language.The program was a replication of the UCP-based framework using the object-oriented approach.Then the developed program was examined using CK Metrics to evaluate whether the Like-UCP has accomplished the desired quality standard.As can be seen in Fig. 4, TechnicalComplexity and EnvironmentalComplexity have higher metric values.Therefore, these two classes need more treatments in order to improve the quality of Like-UCP program.As mentioned earlier, IUCP, AUCP, and SUCP are the class drivers of Like-UCP.These classes were merely used for program simulation.Thus, the high metric values of these three classes will not affect the overall quality of UCP-based framework.
Overall, based on WMC, RFC, CBO, DIT and NOC obtained by CKJM-extended-2.2, it can be concluded that Like-UCP program was well designed.Low value of LCOM indicates that most of these classes were also less complex.Although this experiment was based on a small sample of programs, the results have provided additional evidence that by implementing the object-oriented approach, the quality of Like-UCP has improved regarding the understandability, testability, maintainability, and reusability of the program.The results also indicate that less effort was required to develop the Like-UCP program.As mentioned earlier, Like-UCP is a replication of UCP-based framework.Therefore, the achievement of these quality attributes also reflects the UCP-based framework.In other words, the UCP-based framework can also be said good qualities regarding the understandability, testability, maintainability, and reusability.
The results also show that the program did not have a deep inheritance tree due to the fewer functionalities in the domain model.However, this can be improved by implementing more UCP-based models in the program.Hence, we intend to additionally investigate this topic by utilizing other object-oriented design methodologies such as implementing SOLID Design Principles and make a comprehensive comparison against these outcomes.
As has been mentioned earlier, U-EST was also developed using Java programming language.However, there was no evidence regarding the quality of the program.Therefore, to date, we are unable to compare the Like-UCP program with other ucp-based programs.To ensure this ucp-based framework has a significant contribution to the software practitioners, we encourage other researchers to simulate this framework using new design approaches and compare the outcome with our results.
Besides CK metrics, there are several object-oriented techniques for evaluating the quality design of object-oriented programs.One of the most commonly used is QMOOD (Quality Model for Object-oriented Design).Therefore, we also plan to investigate this topic further using QMOOD and make a comparison between the two approaches.
SUCP_TFactor.Meanwhile, risk factor has only one principal class namely Productivity_Factors and two extended classes.Relationships among classes are drawn as paths connecting class rectangles.Generalization shows the relationship between a more general class and a more specific class which is used for inheritance.In this framework, 11 classes are inherited from their parent classes.For instance, AUCP_UAW class is extended from Unadjusted_Actor_Weight class.Associations carry information about the relationship among objects in UCP-based domain knowledge.For instance, the Use_Case_Points class is associated with Unadjusted_UseCasePoints class.All principal classes which are captured from nine steps of UCP

TABLE I .
RELATIONSHIP BETWEEN CK METRICS AND OOD MEASURES

TABLE II .
RELATIONSHIP BETWEEN CK METRICS AND QUALITY FACTORS

TABLE III .
CK METRICS FOR LIKE-UCP PROGRAM

TABLE IV .
SUMMARY OF CK METRICS FOR LIKE-UCP PROGRAM zero or one WMC.These results indicate that all the classes were properly designed.