Cohesion Metrics Research Articles

Learning from optimization: A case study with Apache Ant

ContextSoftware architecture degrades when changes violating the design-time architectural intents are imposed on the software throughout its life cycle. Such phenomenon is called architecture erosion. When changes are not controlled, erosion makes maintenance harder and negatively affects software evolution. ObjectiveTo study the effects of architecture erosion on a large software project and determine whether search-based module clustering might reduce the conceptual distance between the current architecture and the design-time one. MethodTo run an exploratory study with Apache Ant. First, we characterize Ant’s evolution in terms of size, change dispersion, cohesion, and coupling metrics, highlighting the potential introduction of architecture and code-level problems that might affect the cost of changing the system. Then, we reorganize the distribution of Ant’s classes using a heuristic search approach, intending to re-emerge its design-time architecture. ResultsIn characterizing the system, we observed that its original, simple design was lost due to maintenance and the addition of new features. In optimizing its architecture, we found that current models used to drive search-based software module clustering produce complex designs, which maximize the characteristics driving optimization while producing class distributions that would hardly be acceptable to developers maintaining Ant. ConclusionThe structural perspective promoted by the coupling and cohesion metrics precludes observing the adequate software module clustering from the perspective of software engineers when considering a large open source system. Our analysis adds evidence to the criticism of the dogma of driving design towards high cohesion and low coupling, at the same time observing the need for better models to drive design decisions. Apart from that, we see SBSE as a learning tool, allowing researchers to test Software Engineering models in extreme situations that would not be easily found in software projects.

Software Faults Emulation by Software Fault Injection

In Computer Science, an emulator is hardware or software or both that duplicates (or emulates) the functions of one computer system (the guest) in another computer system (the host), different from the first one, so that the emulated behavior closely resembles the behavior of the real system (the guest).The computer systems are an affected by software and hardware fault, solved in numerous mechanisms to handle. Fault injection is the method of testing such mechanisms, by providing artificial faults and errors (intending to mimic real faults and errors as closely as possible) in order to activate fault handling components. An emulator is object oriented software systems are used for fault emulation. In this paper first, the software components or classes are identified for fault injection by using the calculation is cohesion metrics. If the class is highly cohesive then that software component or class is used for fault emulation. In existing approaches cohesion measured from only structural information. Disadvantage is lack of high cohesion and lacking of measurement in cohesion. Here we propose unstructured information for cohesion measurement so achieving high cohesion and using this, accurate fault prediction can be performed.

New Class Cohesion Metric: An Empirical View

Cohesion is an Object-Oriented (OO) software design property that helps for the measuring of degree of interdependency or connectivity within subsystems of a system. Numerous class cohesion metrics can be found in the literature. Which metric is best suited for a given situation is always a critical question. Few metrics are validated empirically against open source software projects. The purpose of this paper is to validate empirically of the proposed new class cohesion metric (CC) using some open source software projects and find the effected quality factors. Results of this paper conclude that CC continuously gives better correlation with Number Line of Code (NLOC) compare to other existing cohesion metrics. The average value of CC (CohS) of a system also predicts the natures (understandability, modifiability, and maintainability) of a system.

Collaboration within the Puget Sound Marine and Nearshore Science Network

This article presents results of a study intended to paint a broad picture and uncover general trends in collaboration within the Puget Sound marine and nearshore research community. Survey results showed that natural scientists dominate the network, representing 80% of all actors in the sample. Relational contingency analysis revealed high internal rates of collaboration among social scientists and among interdisciplinary scientists. The lowest rates of collaboration were observed between natural scientists and social scientists (p <.001). Cohesion metrics were examined within sub-networks of individuals working on a variety of topical focus areas. In general, sub-networks focused on human dimensions–related topics had higher fragmentation scores (lower cohesion) than sub-networks focused on ecological, biological, or physical processes. These less cohesive sub-networks are identified as areas of opportunity for strategic network interventions to support and foster new collaborations. Results of qualitative analysis highlight factors that facilitate or inhibit success of collaborative research efforts, such as leadership, incentives, and long-term adequate funding. Additionally, the degree to which a collaborative research model can be linked to “high-impact,” policy-informing research outcomes is addressed.

Detection and Refactoring of Bad Smell Caused by Large Scale

Bad smells are signs of potential problems in code. Detecting bad smells, however, remains time consuming for software engineers despite proposals on bad smell detection and refactoring tools. Large Class is a kind of bad smells caused by large scale, and the detection is hard to achieve automatically. In this paper, a Large Class bad smell detection approach based on class length distribution model and cohesion metrics is proposed. In programs, the lengths of care confirmed according to the certain distributions. The class length distribution model is generalized to detect programs after grouping. Meanwhile, cohesion metrics are analyzed for bad smell detection. The bad smell detection experiments of open source programs show that Large Class bad smell can be detected effectively and accurately with this approach, and refactoring scheme can be proposed for design quality improvements of programs.

Measuring Cohesion: An Approach That Accounts for Differences in the Degree of Integration Challenge Presented by Different Types of Sentences

Many proposed cohesion metrics focus on the number and types of explicit cohesive ties detected within a text without also considering differences in the ease or difficulty of required referential and connective inferences. A new cohesion measure structured to address this limitation is proposed. Empirical analyses confirm that this new measure performs similarly to existing measures when applied to the simpler problem of detecting lower and higher cohesion versions of the same text, yet is significantly more effective than existing measures when applied to the more complex problem of distinguishing different texts rated by human experts as requiring lower or higher levels of reading comprehension skill. Implications of these findings relative to the goal of helping teachers and other educators select texts for use in instruction and assessment are discussed.

Measurement of Design Complexity of Different types of Inheritance using Cohesion Metrics

Main aim of Software Engineering is to increase quality and maintain Software Product. Inheritance reflects the degree of reusability of existing classes and reuse increases productivity. Most Cohesion Metric tool do not consider inherited elements while measuring cohesion but we can measure design quality by including the concept of inheritance in Cohesion metrics. In this paper values of all cohesion metrics (LCOM1, LCOM2, LCOM3, LCOM4, LCOM5, CO, TCC and LCC) is calculated including the concept of inheritance for Single, Multiple, Multilevel and Hierarchical Inheritance and compare results to determine design complexity of various types of Inheritances.

DEVELOPMENT OF A NOVEL OBJECT ORIENTED COHESION METRIC

Class cohesion is considered as one of the most important software quality assessment. Unfortunately, most of cohesion metrics that have been developed do not consider the different intersections among class elements in measuring class cohesion. This paper introduces a novel class cohesion metric which considers the different cohesion intersections. The proposed cohesion metric is tested on more than 35K classes from 16 open-source projects. Experimental results show that the proposed cohesion metric achieves a higher discrimination power along with a vast difference compared with other competitive and well known cohesion metrics. Therefore, it is highly recommended to use the proposed metric for evaluating the software design quality.

An exploratory case study of aspect‐oriented metrics for fault proneness, content and fixing effort prediction

PurposeThe purpose of this paper is to investigate the relationships between some aspect‐oriented metrics and aspect fault proneness, content and fixing effort.Design/methodology/approachAn exploratory case study was conducted using an open source aspect‐oriented software consisting of 76 aspects, and 13 aspect‐oriented metrics were investigated that measure different structural properties of an aspect: size, coupling, cohesion, and inheritance. In addition, different prediction models for aspect fault proneness, content and fixing effort were built using different combinations of metrics' categories.FindingsThe results obtained from this study indicate statistically significant correlation between most of the size metrics and aspect fault proneness, content and fixing effort. The cohesion metric was also found to be significantly correlated with the same. Moreover, it was observed that the best accuracy in aspect fault proneness, content and fixing effort prediction can be achieved as a function of some size metrics.Originality/valueFault prediction helps software developers to focus their quality assurance activities and to allocate the needed resources for these activities more effectively and efficiently; thus improving software reliability. In literature, some aspect‐oriented metrics have been evaluated for aspect fault proneness prediction, but not for other fault‐related prediction problems such as aspect fault content and fixing effort.

Qualitative Analysis for the Impact of Accounting for Special Methods in Object-Oriented Class Cohesion Measurement

Class cohesion is a key object-oriented software quality attribute. It refers to the degree of relatedness of class attributes and methods. Several class cohesion metrics are proposed in the literature. However, the impact of considering the special methods (i.e., constructors, destructors, and access and delegation methods) in cohesion calculation is not thoroughly theoretically studied for most of the existing cohesion metrics. An incorrect determination of whether to include or exclude the special methods in cohesion measurement can lead to improper refactoring decisions according to the misleading class cohesion values that are obtained. In this paper, we qualitatively analyze the impact of including or excluding the special methods in cohesion measurement on the values that are obtained by applying 19 popular class cohesion metrics. The study is based on analyzing the definitions and formulas that are proposed for the metrics. The results show that including/excluding special methods has a considerable effect on the cohesion values that are obtained and that this effect varies from one metric to another. The study shows the importance of considering the types of methods that must be accounted for when proposing a cohesion metric.

Correlation between Various Quality Characteristics for Aspect-Oriented Systems

Aspect-oriented system is a new emerging technique of software development that provides mechanism for implementing cross-cutting concerns. Quality assessment of important characteristics like cohesion, coupling, complexity, reusability, maintaibility, etc. is fairly unexplored for Aspectoriented systems. Through this research work we have tried to find out the correlation between some of the quality characteristic of aspect-oriented system. We have established correlation between cohesion and complexity, Cohesion and Changeability. Then we have find out that whether cohesion metric can be used as indicator for assessing complexity and changeability of aspect oriented system. Then will find out that whether cohesion metric and complexity can be used as indicator for assessing reusability of aspect oriented system through finding the correlation between cohesion and reusability, and complexity and reusability.

Method cohesion analysis through concept lattices

Cohesion in object oriented technology is usually associated with a class and hence majority of the available cohesion metrics capture cohesion of classes. Methods which are the main contributors to class cohesion are not analyzed for their internal cohesiveness. This concept paper proposes method cohesion analysis through concept lattices. The approach facilitates rapid identification of elements (statements or variables) in methods that are less cohesive with respect to the remaining part of the method. The paper discusses the analysis and interpretation of cohesion lattices. The approach is demonstrated through dummy examples

Incorporating transitive relations in low‐level design‐based class cohesion measurement

SUMMARYClass cohesion metrics apply different approaches to quantify the relatedness of the attributes and methods in a class. These relations can be direct or transitive. Method invocations are among the key sources of potential transitive attribute–method relations. That is, a method is not only related to the attributes that it references, but it may also be transitively related to the attributes referenced by the methods that it invokes. A few of the existing class cohesion metrics capture this potential transitive cohesion aspect. In this paper, we classify the method invocations as direct or transitive. The definitions of the class representative models used by 16 existing low‐level design (LLD) metrics are extended to incorporate the cohesion caused by the two types of method invocations. The impact of incorporating the transitive relations because of the two types of method invocations on the cohesion values and on the ability of the LLD metrics to predict faulty classes are studied empirically. The results show that the transitive relations because of both types of method invocations featured a considerable degree of cohesion that is not captured by most of the existing LLD metrics. However, practically, incorporating transitive relations in cohesion measurement was found to be ineffective in improving the fault‐prediction powers of most of the LLD metrics. Copyright © 2012 John Wiley &amp; Sons, Ltd.

Faults and Their Relationship to Implemented Patterns, Coupling and Cohesion in Commercial C# Software

This paper documents a study of fault proneness in commercial, proprietary software and attempts to determine whether a relationship exists between class faults and the design context of a class, namely the coupling and cohesion of a class, and whether the class is a participant of common design patterns. The authors studied a commercial software system for a 24 month period and identified design pattern participants by inspecting the design documentation and source code; coupling and cohesion metrics were measured by inspecting the source code with a tool; we also extracted fault data for the same period to determine whether a relationship existed between the design context and the fault propensity of a class. Results showed that design pattern participant classes were marginally more fault-prone than non-participant classes, The Adaptor, Method and Singleton patterns were found to be the most fault-prone of thirteen patterns explored. Coupling was found to have a significant relationship with the fault proneness of classes in the system; efferent coupling was a stronger indicator of fault propensity than afferent coupling. Cohesion, when measured using the LCOM(HS) metric, was not found to have a strong relationship with fault proneness.

A Precise Method-Method Interaction-Based Cohesion Metric for Object-Oriented Classes

The building of highly cohesive classes is an important objective in object-oriented design. Class cohesion refers to the relatedness of the class members, and it indicates one important aspect of the class design quality. A meaningful class cohesion metric helps object-oriented software developers detect class design weaknesses and refactor classes accordingly. Several class cohesion metrics have been proposed in the literature. Most of these metrics are applicable based on low-level design information such as attribute references in methods. Some of these metrics capture class cohesion by counting the number of method pairs that share common attributes. A few metrics measure cohesion more precisely by considering the degree of interaction, through attribute references, between each pair of methods. However, the formulas applied by these metrics to measure the degree of interaction cause the metrics to violate important mathematical properties, thus undermining their construct validity and leading to misleading cohesion measurement. In this paper, we propose a formula that precisely measures the degree of interaction between each pair of methods, and we use it as a basis to introduce a low-level design class cohesion metric (LSCC). We verify that the proposed formula does not cause the metric to violate important mathematical properties. In addition, we provide a mechanism to use this metric as a useful indicator for refactoring weakly cohesive classes, thus showing its usefulness in improving class cohesion. Finally, we empirically validate LSCC. Using four open source software systems and eleven cohesion metrics, we investigate the relationship between LSCC, other cohesion metrics, and fault occurrences in classes. Our results show that LSCC is one of three metrics that explains more accurately the presence of faults in classes. LSCC is the only one among the three metrics to comply with important mathematical properties, and statistical analysis shows it captures a measurement dimension of its own. This suggests that LSCC is a better alternative, when taking into account both theoretical and empirical results, as a measure to guide the refactoring of classes. From a more general standpoint, the results suggest that class quality, as measured in terms of fault occurrences, can be more accurately explained by cohesion metrics that account for the degree of interaction between each pair of methods.

Improving Class Cohesion Measurement: Towards a Novel Approach Using Hierarchical Clustering

Class cohesion is considered as one of the most important object-oriented software attributes. High cohesion is, in fact, a desirable property of software. Many different metrics have been suggested in the last several years to measure the cohesion of classes in object-oriented systems. The class of structural object-oriented cohesion metrics is the most in-vestigated category of cohesion metrics. These metrics measure cohesion on structural information extracted from the source code. Empirical studies noted that these metrics fail in many situations to properly reflect cohesion of classes. This paper aims at exploring the use of hierarchical clustering techniques to improve the measurement of cohesion of classes in object-oriented systems. The proposed approach has been evaluated using three particular case studies. We also used in our study three well-known structural cohesion metrics. The achieved results show that the new approach appears to better reflect the cohesion (and structure) of classes than traditional structural cohesion metrics.

Theoretical Analysis for the Impact of Including Special Methods in Lack-of-Cohesion Computation

Classes are the basic units in object-oriented programs, and therefore, their quality has impact on the overall quality of the software. Class cohesion is an object-oriented software internal key quality attribute, and it refers to the degree of relatedness of class members. Software developers use class cohesion measure to guide the restructuring of poorly designed classes and assess the quality of the software products. Several class cohesion metrics are proposed in the literature, and the impact of considering the special methods (i.e., constructors, destructors, and access and delegation methods) in cohesion calculation is not thoroughly theoretically studied for most of them. In this paper, we address this issue for five popular class lack-of-cohesion metrics. For each of the considered metrics we theoretically study the impact of including or excluding special methods on the values that are obtained by applying the metric. This study is based on analyzing the definitions and formulas that are proposed for the metrics. The results show that including/excluding special methods has a considerable effect on the obtained cohesion values and that this effect varies from one metric to another. The study shows the importance of considering the types of methods that have to be accounted for when proposing a cohesion metric.

The impact of accounting for special methods in the measurement of object-oriented class cohesion on refactoring and fault prediction activities

Class cohesion is a key attribute that is used to assess the design quality of a class, and it refers to the extent to which the attributes and methods of the class are related. Typically, classes contain special types of methods, such as constructors, destructors, and access methods. Each of these special methods has its own characteristics, which can artificially affect the class cohesion measurement. Several metrics have been proposed in the literature to indicate class cohesion during high- or low-level design phases. The impact of accounting for special methods in cohesion measurement has not been addressed for most of these metrics. This paper empirically explores the impact of including or excluding special methods on cohesion measurements that were performed using 20 existing class cohesion metrics. The empirical study applies the metrics that were considered to five open-source systems under four different scenarios, including (1) considering all special methods, (2) ignoring only constructors, (3) ignoring only access methods, and (4) ignoring all special methods. This study empirically explores the impact of including special methods in cohesion measurement for two applications of interest to software practitioners, including refactoring and predicting faulty classes. The results of the empirical studies show that the cohesion values for most of the metrics considered differ significantly across the four scenarios and that this difference significantly affects the refactoring decisions, but does not significantly affect the abilities of the metrics to predict faulty classes.

Fault prediction and the discriminative powers of connectivity-based object-oriented class cohesion metrics

Context Several metrics have been proposed to measure the extent to which class members are related. Connectivity-based class cohesion metrics measure the degree of connectivity among the class members. Objective We propose a new class cohesion metric that has higher discriminative power than any of the existing cohesion metrics. In addition, we empirically compare the connectivity and non-connectivity-based cohesion metrics. Method The proposed class cohesion metric is based on counting the number of possible paths in a graph that represents the connectivity pattern of the class members. We theoretically and empirically validate this path connectivity class cohesion (PCCC) metric. The empirical validation compares seven connectivity-based metrics, including PCCC, and 11 non-connectivity-based metrics in terms of discriminative and fault detection powers. The discriminative-power study explores the probability that a cohesion metric will incorrectly determine classes to be cohesively equal when they have different connectivity patterns. The fault detection study investigates whether connectivity-based metrics, including PCCC, better explain the presence of faults from a statistical standpoint in comparison to other non-connectivity-based cohesion metrics, considered individually or in combination. Results The theoretical validation demonstrates that PCCC satisfies the key cohesion properties. The results of the empirical studies indicate that, in contrast to other connectivity-based cohesion metrics, PCCC is much better than any comparable cohesion metric in terms of its discriminative power. In addition, the results also indicate that PCCC measures cohesion aspects that are not captured by other metrics, wherein it is considerably better than other connectivity-based metrics but slightly worse than some other non-connectivity-based cohesion metrics in terms of its ability to predict faulty classes. Conclusion PCCC is more useful in practice for the applications in which practitioners need to distinguish between the quality of different classes or the quality of different implementations of the same class.

Measuring the Discriminative Power of Object-Oriented Class Cohesion Metrics

Several object-oriented cohesion metrics have been proposed in the literature. These metrics aim to measure the relationship between class members, namely, methods and attributes. Different metrics use different models to represent the connectivity pattern of cohesive interactions (CPCI) between class members. Most of these metrics are normalized to allow for easy comparison of the cohesion of different classes. However, in some cases, these metrics obtain the same cohesion values for different classes that have the same number of methods and attributes but different CPCIs. This leads to incorrectly considering the classes to be the same in terms of cohesion, even though their CPCIs clearly indicate that the degrees of cohesion are different. We refer to this as a lack of discrimination anomaly (LDA) problem. In this paper, we list and discuss cases in which the LDA problem exists, as expressed through the use of 16 cohesion metrics. In addition, we empirically study the frequent occurrence of the LDA problem when the considered metrics are applied to classes in five open source Java systems. Finally, we propose a metric and a simulation-based methodology to measure the discriminative power of cohesion metrics. The discrimination metric measures the probability that a cohesion metric will produce distinct cohesion values for classes with the same number of attributes and methods but different CPCIs. A highly discriminating cohesion metric is more desirable because it exhibits a lower chance of incorrectly considering classes to be cohesively equal when they have different CPCIs.