An aggregated coupling measure for the analysis of object-oriented software systems

Highlights

• A new aggregated coupling measure for OO systems is introduced.

• It expresses both structural and conceptual characteristics of coupling.

• Experiments confirms a good performance compared to classical coupling measures.

Abstract

Coupling is a fundamental property of software systems which is strongly connected with the quality of software design and has high impact on program understanding. The coupling between software components influences software maintenance and evolution as well. In order to ease the maintenance and evolution processes it is essential to estimate the impact of changes made in the software system, coupling indicating such a possible impact. This paper introduces a new aggregated coupling measurement which captures both the structural and the conceptual characteristics of coupling between the software components. The proposed measure combines the textual information contained in the source code with the structural relationships between software components. We conduct several experiments which underline that the proposed aggregated coupling measure reveals new characteristics of coupling and is also effective for change impact analysis.

Introduction

It is well-known that cohesion and coupling are software properties which are highly connected with the quality of a software design. Generally, a good object-oriented design is characterized by the principle of low coupling and high cohesion, being known that the main symptom for badly-structured systems is the violation of the rule “Put together what belong together”. The internal structure of a software is often changed during its lifecycle, having a major impact on the system’s evolution. Inaccurate implementations for the newly added functional requirements lead to structure deterioration and a more difficult and expensive maintenance. Therefore, for assuring a facile and efficient software maintenance and evolution, it is essential for the developers to clearly estimate the impact of the changes they made in the software. One method for understanding such impact is to assess the coupling between different software components (Poshyvanyk et al., 2009).

Coupling is considered an important factor in software maintenance. Independent modules are easier to change, extend and fix as, in their case, the impact of an eventual change is smaller. All forms of coupling are generally viewed in the literature as having a negative impact on maintainability (Stevens et al., 1974). Direct coupling is one category of coupling, usually easily determined using static source code analysis. But there are other forms of coupling identified in the literature: indirect coupling (Yang et al., 2005) and hidden dependencies (Yu and Rajlich, 2001) with similar negative effect on software maintainability.

Several coupling measurements were introduced in the software engineering literature for expressing the degree to which different parts of a software system are related. Among these, the class of structural coupling (Ajienka and Capiluppi, 2017) contains software metrics (Aez-Varela et al., 2017) which measure the connection between software entities (classes, methods, attributes) (Bavota et al., 2013), while the category of conceptual coupling measures the conceptual relation between the identifiers and comments from different application classes (Poshyvanyk et al., 2009). Other coupling types defined in the literature are dynamic coupling, which takes into consideration connections that appear during the execution of the program and logical coupling which considers entities that are changed together (Bavota et al., 2013). While most of the existing coupling measures belong to the class of structural coupling measures and these are the most often used, the other ones were introduced because researchers considered that there are important relations which are not captured by structural coupling measures. Bavota et al. performed an experiment to determine how different the relations captured by these four coupling types are and how much are they correlated to the strength of the couplings perceived by software developers (Bavota et al., 2013). They concluded that connections identified by logical and dynamic coupling are mostly identified by structural or conceptual coupling while these two are complementary (the links identified by them overlap only partially). When comparing the values of the metrics to evaluations of coupling given by software developers, the authors concluded that conceptual measures are the closest to the developer’s perception of coupling (Bavota et al., 2013).

A task of major importance for software developers is to understand dependencies between software components, including those which are hidden. Understanding the existing connections in a software contributes to easing the software maintenance and evolution process. Among the software development related activities which are based on dependencies between software components we mention (Vanciu and Rajlich, 2010): impact analysis (Briand, Wuest, Lounis, 1999, Poshyvanyk, Marcus, Ferenc, Gyimóthy, 2009), change propagation (Rajlich, 1997) and regression testing (White et al., 2008). Coupling metrics have proven to be useful in different software engineering activities, such as: predicting defect proneness (Kirbas et al., 2014), predicting maintainability in service-oriented designs (Perepletchikov et al., 0000), crosscutting concerns identification (Marin, Deursen, Moonen, 2007, Moldovan, Şerban, 2006), software restructuring (Czibula and Serban, 2006), change impact analysis (Poshyvanyk et al., 2009).

A recent study showed that for the problem of software restructuring, using software metrics might not be sufficient. Simons et al. performed an experiment in which they computed the values of several software metrics (which were based on structural connections between the entities) for two software systems and compared them to the evaluation of the quality of those systems given by professionals (Simons et al., 2015). The authors concluded that the values of the metrics are not correlated with the judgment of professionals.

The results of the previously mentioned studies (one presenting that structural metrics might not always capture how software developers think (Simons et al., 2015), and the other presenting that conceptual coupling is the closest to how developers consider coupling) suggest that by combining structural and conceptual metrics we could achieve a measure which can be better, more useful than any of them alone. This is also suggested by the conclusion of a study performed by Kagdi et al., where conceptual and logical (in the paper it was called evolutionary) coupling measures were combined and their combination improved the precision and recall of impact analysis (Kagdi et al., 2010). The combination of different software metrics is encouraged by Harman et al. as well, since software metrics are often used as fitness functions in Search Based Software Engineering and their combination can lead to better fitness functions (Harman et al., 2012).

Sustained by the aforementioned studies from the literature, the idea of combining structural and conceptual coupling metrics seems to be promising, as it is agreed that the structural metrics do not express entirely the conceptual side of coupling and vice versa. Starting from the hypothesis that a coupling measure expressing both the structural and conceptual characteristics of coupling would be, very likely, capable to detect dependencies between software components which cannot be captured using only structural or conceptual coupling, we introduce in this paper a new aggregated coupling measure, ACE, which captures both the structural and the conceptual relationships between the software components. Our assumption will be empirically confirmed in Section 4.2 where an experiment related to software packages remodularization is conducted for highlighting that ACE is able to encapsulate relevant information which is different from the one captured by only structural or conceptual coupling measures.

The ACE measure aggregates a measure which is based on the textual information contained in the source code and a measure which expresses the structural relationship between software components. Experiments will be performed with the main goal of evaluating the extent to which the combination of structural and conceptual coupling into a single aggregated measure is suitable for better expressing the degree to which software entities are related together. We also aim to emphasize that the aggregated measure differs quite significantly from existing structural and conceptual coupling measures and that it can capture multiple aspects of coupling and is more useful than classical coupling measures in software engineering related activities. The proposed ACE measure can be used independently of the programming paradigm in which the analyzed software was developed, even if, in this paper, we are focusing on object-oriented software systems. Several experiments are conducted in order to emphasize the effectiveness of ACE. In the current proposal, ACE expresses a linear combination between structural and conceptual coupling metrics. However, a non-linear relationship may be effective and will be further investigated.

In summary, the major goal of the work conducted in this paper is that of emphasizing the relevance of aggregating structural and conceptual coupling into a single measure ACE, as a proof of concept, by answering the following research questions:

• RQ1 Is the ACE aggregated coupling measure able to express new aspects of coupling, which are not detected by the existing structural and conceptual coupling measures from the literature?

• RQ2 To what extent is the ACE measure correlated with existing structural and conceptual coupling measures from the literature?

In addition to addressing RQ1 and RQ2 we also aim to provide a possible application of using ACE measure for an important activity in software maintenance and evolution, that of impact analysis. With this aim the proof of concept considers only two software systems of different sizes for highlighting the potential of ACE for guiding the process of analyzing the impact of changes in software systems. If this stands, the study of using ACE for impact analysis can be further extended on a larger scale. Therefore, research question RQ3 formulated below will be furthermore investigated.

• RQ3 Would ACE be effective for change impact analysis an how does it compare to similar measures already proposed in the literature for this activity?

The paper is organized as follows. We start by reviewing in Section 2 existing coupling measurements from the literature. Our aggregated coupling measure ACE which expresses the coupling between object-oriented software system components is introduced in Section 3. Section 4 highlights the differences between ACE and other existing coupling measures. The effectiveness of using the proposed ACE measure for change impact analysis is shown in Section 5. The experimental results as well as their analysis are provided in Section 6. Section 7 discusses about the threats to validity that can affect the results of our study. The conclusions of our paper and further research directions are outlined in Section 8.