A Survey on Software Coupling Relations and Tools

Enrico Fregnan∗
University of Zurich, Switzerland

Tobias Baum
Leibniz Universität Hannover, Germany

Fabio Palomba and Alberto Bacchelli

University of Zurich, Switzerland

Abstract

Context: Coupling relations reflect the dependencies between software enti-

ties and can be used to assess the quality of a program. For this reason, a
vast amount of them has been developed, together with tools to compute their
related metrics. However, this makes the coupling measures suitable for a given
application challenging to find.

Goals: The first objective of this work is to provide a classification of the

different kinds of coupling relations, together with the metrics to measure them.
The second consists in presenting an overview of the tools proposed until now
by the software engineering academic community to extract these metrics.

Method: This work constitutes a systematic literature review in software en-

gineering. To retrieve the referenced publications, publicly available scientific
research databases were used. These sources were queried using keywords in-
herent to software coupling. We included publications from the period 2002 to
2017 and highly cited earlier publications. A snowballing technique was used to

∗ Corresponding author
Email addresses: [email protected] (Enrico Fregnan),
[email protected] (Tobias Baum), [email protected],
[email protected] (Fabio Palomba and Alberto Bacchelli)

Preprint submitted to Information and Software Technology December 14, 2018

 retrieve further related material.

Results: Four groups of coupling relations were found: structural, dynamic,

semantic and logical. A fifth set of coupling relations includes approaches too re-
cent to be considered an independent group and measures developed for specific
environments. The investigation also retrieved tools that extract the metrics
belonging to each coupling group.

Conclusion: This study shows the directions followed by the research on soft-
ware coupling: e.g., developing metrics for specific environments. Concerning
the metric tools, three trends have emerged in recent years: use of visualization
techniques, extensibility and scalability. Finally, some coupling metrics appli-
cations were presented (e.g., code smell detection), indicating possible future
research directions.
Keywords: Software Engineering; Coupling relations; Software metrics
2010 MSC: 00-01, 99-00

1. Introduction

Software development is a complex task that requires careful planning and a

high amount of time and energy [1]. Furthermore, maintainability [2, 3] and re-
liability [4] are important qualities that software should possess. To assess these
5 properties, software complexity measures (coupling and cohesion) were intro-
duced [5, 6]. As defined by Robbes et al. [7], coupling measures the amount of
dependency between entities in a software. Over the years, different coupling
measures have been proposed. Starting from structural metrics developed for
procedural languages [5], new approaches were introduced to measure different
10 relations in object-oriented environments [8]. Nonetheless, the central impor-
tance of these metrics for software engineering encouraged researchers to give
birth to even more coupling measures in the attempt to evaluate further con-
nections between software entities [9]. Excluding the already existing structural
coupling, three new groups of coupling relations were created: dynamic, se-

2
15 mantic, and logical coupling. Dynamic coupling analyzes the run-time relations
among different software entities [10]. Semantic coupling exploits the semantic
relations among different elements in the source code using information retrieval
techniques [11]. Finally, logical coupling approaches work by finding relations
among system parts that are frequently changed together [12].
20 Due to the flourishing of this research field, a vast amount of original coupling
measures have been proposed. However, all these different approaches can make
it difficult for a software engineer to find the proper coupling relations to test the
quality of the software on which he or she is working on. Some coupling relations
can be applied only to particular groups of programming languages such as
25 the object-oriented ones. Other metrics reveal themselves useful in specific
situations: for example, evolutionary coupling is particularly helpful to highlight
software changes. For these reasons, this work aims to provide a taxonomy of
the coupling relations proposed so far, categorizing them in different groups and
highlighting the commonalities and differences among them. Special attention
30 has been given to the various trends that emerged in this field so far, highlighting
the motivations behind the construction of new coupling relations. We argue
that this study constitutes a good overview of software coupling relations and
a starting point for further research in this field. Furthermore, we compare
different tools developed by researchers to extract these relations in terms of
35 output and required input information. The goal of this second part of our
literature review is complementary to the first one. We argue that a researcher,
having identified the coupling metrics of interest, may also be interested in
which tools he/she may use to extract them. To the best of our knowledge, this
constitutes a new contribution to the existing literature.
40 Other systematic reviews on coupling relations have been done by Kirbas
et al. [12] and Nicolaescu et al. [13]. However, they have a different aim: Kirbas
et al. limit their review to the field of logical coupling, while Nicolaescu et al.
organize it in chronological order. The work of Kirbas et al. uses a measure-
ment theory perspective to analyze logical coupling measures. This approach
45 is reflected in the research questions identified in the study: questions like "Do

3
 existing studies use a sound empirical relation system?" or "Do existing studies
define measurement methods and procedures?" show the authors’ focus on eval-
uating how well logical coupling is currently captured by the different measures
proposed. However, such an approach is not easily applicable to the broader
50 perspective of our review. We consider logical coupling measures only as a sub-
group of all the proposed coupling ones. Our review’s goal is to give a general
classification of all the possible coupling measures introduced in the software
engineering field and not to analyze in details the properties of a specific sub-
group. For this reason, the focus on logical coupling is limited to an overview
55 of the different measures introduced to assess it.
Nicolaescu et al. propose an analysis of the main trends of coupling metrics
for object-oriented systems, considering both the fundamental research done in
the field and new directions that have been explored in recent years. Although
their work constitutes an extraordinary attempt to present an overview of this
60 complex research area, they report the different proposed coupling metrics in
chronological order instead of dividing them into groups. In fact, Nicolaescu
et al. analyzed 26 research papers dividing them in three time periods: fun-
damental works (1990-1999), advanced approaches (2000-2010) and recent di-
rections (2011-2015). On the contrary, in our work the main focus is to give
65 a conceptual subdivision of the different coupling relations. In fact, our main
concern is not the period in which the considered metrics have been proposed
(although, if possible, we keep a chronological order for clarity), but the different
rationales behind them, which gave birth to their classification.

2. Research questions

70 Coupling relations have fundamental importance in software development

since they are useful in activities such as, among others, maintenance and pro-
gram comprehension [7]. For this reason, researchers explored links between
software entities in the attempt to capture different characteristics of software
to ensure its quality [9]. Nonetheless, a systematic classification of these dif-

4
75 ferent techniques is still missing. Therefore, in this work we first answer the
following research question:

RQ1 Which different coupling relations have been proposed by the

software engineering research community?

The goal of RQ1 is to produce a taxonomy of the existing coupling rela-

tions, describing their core points together with the novelty that they introduce.
Furthermore, the differences between them will be presented. Then, we will in-
80 vestigate different metric tools based on the relations found in RQ1 with their
outcome and input information. For this reason, our next research question is
the following:

RQ2 Which tools to extract coupling metrics have been developed by

the software engineering research community?

RQ2 aims to retrieve the tools that the software engineering research commu-
nity has developed to extract different coupling relations. We will classify them
85 based on the taxonomy produced by answering RQ1. Moreover, their different
inputs and outputs will be highlighted, together with their limitations: e.g., the
programming languages to which they are restricted.

3. Research strategy

In our investigation, we followed the guidelines given by Kitchenham [14].

90 Figure 1 shows the steps of our research strategy. To address RQ1, we con-
ducted an initial query to evaluate the goodness of our approach. Based on the
papers retrieved, in particular, the work by Bavota et al. [9], we refined our
query including terms specific for each coupling group. Moreover, we checked
for alternative spellings and synonyms. The terms identified were:

95 • Structural coupling

• Dynamic coupling

5
 Figure 1: Methodology steps

• (Semantic or Conceptual) coupling

• (Logical or evolutionary or change) coupling

Finally, to investigate our first research question (RQ1) we combined using

100 boolean operators all terms identified to create the following search string:

(Software AND coupling) OR (coupling AND object-oriented) OR

(software AND coupling AND ((logical OR evolutionary OR change)
OR (semantic OR conceptual) OR dynamic OR structural))

We included the word “software” to reduce the number of results from re-
search fields other than software engineering. However, this was not neces-
sary when we used terms proper to the computer science area such as “object-
oriented”. The same procedure was applied to develop a search string for our
105 second research question (RQ2).

(Coupling AND tool) AND (metrics OR (logical OR evolutionary

OR change) OR (semantic OR conceptual) OR dynamic OR struc-
tural)

These two research strings were used to investigate the following resources:

6
 • IEEE Xplore Digital Library1

• ACM Digital Library2

• SpringerLink3

110 • ScienceDirect4

Table 1 shows the size of the papers set retrieved at each step of our investiga-
tion. ScienceDirect and SpringerLink returned a number of results too vast for
an accurate analysis (more than 200’000 results). To restrict this set, we filtered
the journals to the ones on computer science and software/software engineer-
115 ing and then we applied our queries to each of them (complete list available in
Appendix A). In SpringerLink, we excluded the “preview-only” content.

Table 1: Data sources and search results

Source Total results retrieved5 Initial selection Final selection
IEEE Xplore Digital Library 10391 + 1639 69 65
ACM Digital Library 2838 + 1120 +13 +13
ScienceDirect 2887 + 2014 +9 +8
SpringerLink Digital Library 3733 + 2967 +2 +2
Total 93 88

The retrieved papers were evaluated based on a set of exclusion and inclusion
criteria. The exclusion criteria were:

• Articles that do not focus on software coupling relations and/or tools.

120 • Articles that were not written in English.

• Articles whose full text is not available.

1 IEEE, http://ieeexplore.ieee.org/Xplore/home.jsp
2 ACM, https://dl.acm.org/
3 SpringerLink, https://link.springer.com
4 ScienceDirect, http://www.sciencedirect.com
5 We reported the number of results obtained with the first query and the number of results

obtained with the second one. We did not compute their sum since the two queries presented
overlapping results.

7
 • Not peer-reviewed articles, e.g., Ph.D. or M.Sc. thesis

To assess the quality of the retrieved research material, in other words, if the pa-
pers identified by our queries contained information useful to answer our research
125 questions (respecting the first criterion), the following three-step procedure was
applied. In the first step, the papers’ titles and abstracts were carefully read to
exclude the ones clearly irrelevant to the focus of our research. The second step
consisted in skimming the whole text of the material left after the first selection
to assure that it contained information related to coupling relations, measures
130 and/or tools to extract them. Finally, the third step was an accurate reading
through the whole text to ensure that this information was effectively helpful to
address the two research questions: for the tools, we checked that their input,
output and limitations were described.
At the same time, we applied the following inclusion criteria:

135 • Year of publication: only papers published between 2002 and 2017 were
accepted;
OR

• Number of citations: only papers referenced by more than 100 other pub-
lications were accepted;

140 The two criteria do not have to be valid simultaneously: they are connected with
the logical operator OR. Therefore, a paper is selected if it meets at least one of
the two criteria. The first criterion was selected to include recent publications on
the topic. We included in our work only papers published in the last 15 years at
the moment on which this research is conducted: from January 2002 to Decem-
145 ber 2017. However, we argue that this criterion may have excluded fundamental
papers on coupling. Although they have been published before 2002, their con-
tribution could be fundamental to obtain insights on trends and characteristics
of more recent metrics. For this reason, we introduced the second criterion to
augment the first one. We selected 100 citations as threshold because we were
150 interested in the analysis of solid and well-established resources on the topic of

8
 interest. The number of citations has been attested using Google Scholar to
have a verification system independent from the single data source. However, we
recognize the potential limits of this approach: a paper with a high number of
citations is not necessarily an important paper on the subject. To mitigate this
155 problem, we complemented this research strategy with a snowballing technique
[15]. We applied forward and backward snowballing on all the papers included
in our final selection set until saturation was reached. The purpose of using the
snowballing technique was to compensate for fundamental material that may
have been left out by our previously mentioned search queries.

Table 2: Total of papers retrieved

Final set Snowballing Total
88 48 136

160 As a further check on the goodness of the retrieved material and its correct
use, we reached authors of other similar works on coupling to ask them to check
if their papers were cited correctly and suggest us any other published work
relevant for our review. 17 authors were reached and 6 replied. As result, we
discovered one paper previously not included and we added it to the set of
165 primary studies.

4. RQ1: Coupling relations

In this section different existing coupling relations and techniques will be

presented, based on the result obtained investigating our first research question.
As stated by Briand et al. “Coupling refers to the degree on interdependence
170 among the components of a software system” [16]. A component can be a module
of the system or a smaller entity such as a class or an object. Moreover, coupling
can indicate a relation between two components but also a property of an entity
compared to all the other related entities in the system: e.g., CCBC (Conceptual
Coupling Between Classes) and CoCC (Conceptual Coupling of a Class) [17].
175 Bavota et al. identified four different measures of coupling [9]:

9
 • Structural coupling

• Dynamic coupling

• Semantic coupling

• Logical coupling

180 Structural coupling exploits the static relations in the source code: it focuses
on finding patterns such as called methods, relations among classes (inheritance
and friendship) and accessed variables. Dynamic coupling also reflects calls
between classes and methods but it does that at run-time, instead of looking at
the static code. Semantic coupling relies on Information Retrieval techniques
185 to find relations in the code lexicon, while logical coupling intends to assess
the entities that are frequently changed together, and therefore share a link,
using historical information. Finally, other approaches try to combine these
groups of relations in a complementary way or present coupling measures for
domain-specific programming languages. Figure 2 shows an overview of the
190 coupling relation taxonomy that we have constructed in our review. The goal
of this first part of our work is to present the evolution of the coupling relations
and metrics proposed, while keeping intact the categories presented by Bavota
et al. [9].

4.1. Structural coupling

195 Structural coupling relations exploit static connections among software enti-
ties (modules, objects or classes). Measures to assess them have been initially
developed for procedural languages, but, later, extended to the object-oriented
paradigm. Furthermore, some structural coupling relations have been proposed
specifically for object-oriented languages. In general, it is possible to divide
200 them into two broad groups: procedural programming coupling measures and
object-oriented coupling measures [18].
Myers divided the coupling for procedural programming languages in 6 dif-
ferent levels, reported in Table 3 ordered from the worst to the best in terms

10
 Content coupling

Common coupling

Control coupling
Procedural languages coupling
External coupling

Stamp coupling

Data coupling

Content coupling

Common coupling
Structural coupling
Control coupling
Interaction coupling
External coupling

Stamp coupling

Data coupling

Hidden coupling
Object-oriented languages coupling
Component coupling Scattered coupling

Coupling relations Specified coupling

Modification coupling

Inheritance coupling Refinement coupling

Extension coupling

Import coupling
Dynamic coupling
Export coupling

Semantic coupling

Logical coupling

Figure 2: Coupling relation taxonomy

11
 of consequences on the maintainability and quality of the software [19]. These
205 coupling levels have been extended by Offutt et al. to include global and bidi-
rectional coupling measures, previously left uncovered [5]. Although it has been
originally introduced for procedural languages, this subdivision remains valid
also for object-oriented ones.
In 1981, Henry and Kafura proposed an information-flow technique to con-
210 struct different measures for a software system [21]. Their idea constitutes an in-
teresting approach to compute coupling relations. In particular, the information
flow metrics can recognize content coupling and common coupling. The authors
argue that content coupling is equivalent to their direct local flows. Common
coupling is equivalent to the global flow measure. Henry and Kafura developed
215 two metrics fan-in and fan-out. fan-in counts the number of local flows to the
considered procedure together with the number of data structures read by the
procedure. fan-out measures the quantity of local flows from a selected proce-
dure plus the number of data structures on which the procedure writes. At a
later time, Allen et al. proposed to measure coupling metrics using the links
220 and information obtainable building the system graph of a software [22, 23].
The strength of this approach is that it can be applied to many software de-
sign abstractions and to all kinds of programming languages (procedural and
object-oriented).
The flourishing of the object-oriented paradigm brought the researchers to
225 propose metrics and relations to cover its new aspects. Coupling relations for
object-oriented systems have been investigated in the work done by Eder et al. in
1994. The authors identified three groups of coupling relations [24]: interaction,
component and inheritance coupling. Their classification is shown in Table 4.
A fundamental structural coupling metric for object-oriented software is
230 CBO (Coupling Between Object) [25], which belongs to the interaction cou-
pling subgroup [24]. CBO reflects the degree to which an object acts upon
another, excluding the parent-child relation. It constitutes one of the core cou-
pling metrics and it has been further refined and applied in different other
domains. Chidamber and Kemerer also defined RFC (Response For a Class), a

12
 Table 3: Structural coupling relations for procedural languages
Level Description
Content coupling Refers to two modules of which one directly accesses
the contents of the other: e.g., module A modifies a
statement or branches to a local label of module B.
Common coupling Happens when two modules have access to the same
global data: for example, both modules can read and
write the same global record. Schach points out that
if the access to the data is read-only, then this can
not be considered common coupling [20].
Control coupling Happens when a module explicitly controls the logic
of another. However, this does not happen if the first
module passes only data.
External coupling Happens when two modules exchange information
using an external element such as a file.
Stamp coupling Exists between two modules if one of them passes
a data structure as an argument to the second one,
but the called module does not operate on all the
components of the data structure.
Data coupling Exists among two modules if the arguments that they
pass to each other are all homogeneous data items:
simple arguments or data structures in which all el-
ements are used by the calling module [20].

13
 Table 4: Structural coupling relations for object-oriented languages

Level Description Applicability Subdivision

Interaction coupling Defined as the invocations Methods and Content coupling
among different methods Classes Common coupling
and their sharing of External coupling
variables Control coupling
Stamp coupling
Data coupling
Component coupling A class A is related to Classes Hidden coupling
another class B if and only Scattered coupling
if A is referenced in B: this Specified coupling
happens when A is the
domain of an instance or
local variable, a method’s
parameter or a parameter
of a method called inside a
method of B
Inheritance coupling Relates two classes if one Classes Modification
of them is a subclass of the coupling
other Refinement
coupling
Extension coupling

14
235 coupling measure related to CBO [26, 27] that measures the total communica-
tion potential. These two metrics were further analyzed by Briand et al. [28] and
formalized to remove possible sources of ambiguities. Moreover, Briand et al.
introduced CBO0 to include the ancestor classes in the metric computation, pre-
viously left excluded [25]. Other important metrics that they considered were
240 Message Passing Coupling (MPC) and Data Abstraction Coupling (DAC), orig-
inally defined by Li and Henry [29]. Briand et al. further refined DAC in DAC0 ,
a metric that counts the number of classes used as types of attributes. Finally,
other important structural coupling measures are efferent and afferent coupling
(Ce and Ca [30]), Coupling Factor (COF) [31, 32] and Information-flow-based
245 coupling (ICP) [33]. Li defined two new coupling metrics to complement Chi-
damber and Kemerer’s metrics suite: CTA (Coupling Through Abstract data
type) and CTM (Coupling Through Message passing) [34]. Similarly to the
DAC0 [28] metric, CTA measures the relation between two classes created when
one of them uses the other in its data declaration. CTM (Coupling Through
250 Message passing) measures the number of messages sent by a considered class to
the other classes in the system, excluding the ones sent to objects used locally
by the methods of the class. MPC, RFC and CBO were also modified to be ap-
plied to program slices [35], creating the new metrics SMPC, SRFC and SCBO.
The method-level metrics proposed by Briand et al. have been adapted to a
255 finer granularity by English et al. to distinguish the different types of constructs
with which they might be related [36]. A specific focus has been given to the
friendship relation.
To take into account indirect coupling relations and the strength of coupling
between two classes, Li developed a new metric [37]. Indirect coupling has also
260 been considered by Yang et al. [38, 39] (creating also a tool, Indirect Coupling
Detector) and later by Almugrin et al. [40].
New measures have been introduced to allow an evaluation of the level
of object-orientation of a program to estimate the possibility that an object-
oriented fault happens. For this purpose, Tang et al. proposed new coupling
265 metrics [41]: IC (Inheritance Coupling) and CBM (Coupling Between Meth-

15
 ods). Gui and Scott focused instead on metrics specific for component reusabil-
ity [42], defining measures for the direct coupling among two classes (CoupD),
the transitive coupling among two classes (CoupT) and the total coupling of a
software system (WTCoup).
270 An interesting approach is the one proposed by Aloysius and Arockiam,
where a comprehensive coupling metric, CWCBO (Cognitive Weighted Coupling
Between Objects), is defined to give an overall measure of different degrees of
coupling [43]. This metric considers different kinds of coupling measures such
as data coupling, control coupling, global coupling and interface coupling and
275 applies to them a weighting factor. Using a comparative study, the authors
supported their claim that CWCBO is a better indicator than CBO to measure
the complexity of a class since it takes into consideration different coupling
levels.

4.2. Dynamic coupling

280 Dynamic coupling rules were introduced to address problems left not com-
pletely answered by previous static coupling measures: e.g., dynamic binding
and polymorphism [10]. In fact, these metrics lose precision when dealing with
intensive use of inheritance and dynamic binding. Furthermore, they aim to
evaluate software quality looking not only at the source code complexity, but
285 also at its operational environment [44]. Further research confirmed that these
metrics provide additional information to the structural metrics [45]. Dynamic
coupling approaches can be further divided according to the coupling direction,
import or export coupling, and their mapping level, object or class-level ori-
ented [46]. Coupling direction captures the difference between a sending entity
290 and a receiving entity [46, 10]. Considering the messages exchanged between
entities, the distinction is:

• Import coupling: focus on the messages sent from an entity

• Export coupling: focus on the messages received by an entity

16
 The mapping level reflects the applicability domain of dynamic coupling rules:
295 object-level or class-level coupling. Moreover, Arisholm et al. proposed three
different approaches to evaluate the strength of a coupling relation: the number
of messages, the number of distinct method invocations and the number of dis-
tinct classes. The first one refers to the quantity of distinct messages exchanged
between two entities. The other two represent the amount of methods called
300 and classes used, respectively, by a method in an object. The classification of
these metrics, as given by Arisholm [46], is summarized in Table 5.

Table 5: Dynamic Coupling Relations Summary [46]

Direction Mapping Strength Name
Import Coupling Object-level Dynamic messages IC_OD
Distinct Methods IC_OM
Distinct Classes IC_OC
Class-level Dynamic messages IC_CD
Distinct Methods IC_CM
Distinct Classes IC_CC
Export Coupling Object-level Dynamic messages EC_OD
Distinct Methods EC_OM
Distinct Classes EC_OC
Class-level Dynamic messages EC_CD
Distinct Methods EC_CM
Distinct Classes EC_CC

The direction of coupling was taken into account also by Mitchell and Power:
their idea was to expand the previously defined CBO metric [44]. The authors
presented two new coupling relations, both divided to account for internal and
305 external coupling. The first one, Run-time coupling between objects (R) (ex-
ternal or internal) counts the number of accesses made by/to a class divided
by the total number of accesses. The second one, run-time import (or export)
degree of coupling (RD), gives the strength of the coupling relation computed

17
 as the number of classes that access (or are accessed by) a selected class. In
310 further research, Mitchell and Power, in their attempt to verify if CBO can be
used efficaciously as a dynamic metric, defined two new coupling measures [47]:
Run-time Coupling Between Objects (RCBO) counts the amount of classes that
a specific class accesses at run-time. The second one, the Number of object class
clusters (Noc), counts the number of clusters obtained considering a class in the
315 system and studying the distribution of unique accesses per object.
Work at object-level was also done by Yacoub et al. [48]. The authors pro-
posed two dynamic coupling metrics that operate on the export and import
side, respectively. The former one, Export Object Coupling (EOC) measures
the percentage of messages sent from an object to the other, compared with the
320 total amount of messages exchanged in the complete execution. Import Object
Coupling (IOC) works in the opposite way, reflecting the number of messages
that an object receives from another. From EOC, Yacoub et al. defined OQFS
(Object reQuest For Service) as the sum of the EOC among a selected object
and all the other objects in the design. IOC was instead developed into OPFS
325 (Object resPonse For Service), defined as the sum of IOC between the given ob-
ject and all the other objects in the application during the execution of a specific
scenario. These values affect the maintainability, understandability, reusability
and the errors distribution in the code. Zaidman and Demeyer refined OQFS to
work at class-level, introducing CQFS (Class reQuest For Service) [49]. CQFS
330 counts all the methods that a given class calls during the application execution.
Every method is counted once: calling the same method more than one time
does not increase the count.
Hassoun et al. propose a general relation, called DCM (Dynamic Coupling
Metric) to formalize the idea of dynamic coupling [50]. Their metric works at
335 object-level and it can be used to analyze the coupling of a selected object or a
system during the program execution.
Dynamic coupling metrics require analysis conducted at run-time, but the
impact of the metrics is higher if they are computed at early stages of the
development. To address this issue, pseudo-dynamic coupling metrics were pro-

18
340 posed: static metrics that consider the expected usage profile (derived from
UML graphs during the design phase) [51]. Referring to Chidamber and Ke-
merer’s CBO, the pseudo-dynamic CBO metric was defined as the value of the
static CBO multiplied by the value of the operational profile. It presents a
strong correlation with the dynamic CBO metric. A similar static approach
345 to compute dynamic metrics has been proposed by Liu and Milanova [52]. A
different approach calculates dynamic metrics from the system use case maps
and the interactions between different scenarios [53].
An interesting evolution of the metrics defined by Arisholm [46] has been
introduced by Abualese et al. to evaluate the importance of a class in the un-
350 derstanding process that a developer has to face when approaching code written
by a different person [54].

4.3. Semantic coupling

Classes can not only be structurally related to each other but also conceptu-
ally. Based on this idea, semantic coupling uses information from comments and
355 identifiers to identify relations among software entities [11]. The technique pro-
posed by Poshyvanyk and Marcus relies on Latent Semantic Indexing (LSI) [55]:
a machine learning model developed to analyze relations between words and
documents. To investigate coupling aspects left unaddressed by the previous
metrics, the authors created four progressive coupling relations, each of them
360 based on the previous one: CCM (Conceptual Coupling Between Methods),
CCMC (Conceptual Coupling Between a Method and a Class), CCBC (Con-
ceptual Coupling Between two Classes), also called CSBC (Conceptual Similar-
ity Between two Classes) and CoCC (Conceptual Coupling of a Class) [11, 17].
Poshyvanyk and Marcus also considered the idea to exclude weak coupling links
365 in the computation of the metrics defining a new metric called CSMCm . From
it, they also recomputed CSBC and CoCC accordingly, producing the two new
metrics CSBCm and CoCCm . Újházi et al. have further improved this approach
with a new metric called CCBO (Conceptual Coupling Between Object classes),
which does not merely take the maximum but identifies a threshold to distin-

19
370 guish between a strong and weak semantic coupling [56].
All the aforementioned semantic coupling measures use LSI to create an
initial semantic corpus for the analysis. Gethers and Poshyvanyk proposed
a coupling approach based on a different technique: Relational Topic Model
(RTM), a model that can find connections between documents based on the
375 context [57]. The authors introduced a measure called Relational Topic-based
Coupling (RTC). This metric individuates new aspects of coupling between
classes compared to the metrics based on LSI, such as CoCC. Furthermore, a
fundamental benefit of this model is that it does not need any previous knowl-
edge about the links between classes.
380 Revelle et al. extended semantic coupling relations to work at feature level,
aiming to identify which parts of a system are linked to a specific function [59,
58]. In fact, a feature represents the implementation of a functionality de-
scribed in the requirements. Since features can be represented by structured
information (source code and related artifacts) and unstructured information
385 (textual information), two different metrics were proposed: SFC (Structural
Feature Coupling) and TFC (Textual Feature Coupling). Furthermore, the
authors introduced HFC (Hybrid Feature Coupling) to consider together the
complementary information captured by SFC and TFC.
Semantic coupling has been combined with evolutionary coupling [60] or
390 domain-based relations [61]. Domain-based coupling individuates relations among
domain variables, functions and User Interface Components (UIC) [62, 63] and
has been applied to fields such as code clone detection with promising re-
sults [64]. Gethers et al. defined CSE (Conceptual Similarity between Enti-
ties) and CSED (Conceptual Similarity between two UICs) to perform impact
395 analysis in hybrid software systems [61]. Moreover, semantic and domain-based
coupling relations have been checked to assure their orthogonality. This analysis
confirmed that these relations capture different aspects of the analyzed system
and, therefore, they can be efficaciously combined. Based on CBE, Kagdi et al.
defined CSEMC and CSEBC [65]. Furthermore, semantic coupling has been
400 combined with structural coupling to create a metric that takes into account

20
 both aspects at the same time [66]. The authors defined four coupling met-
rics, each of them based on the previous one (in a fashion similar to the one
used by Poshyvanyk et al. [17]): MPC (Method Pair Coupling), HCMC (Hybrid
Coupling between Method and a Class), HCCC (Hybrid Coupling between two
405 classes) and SSCM (Coupling of a class in an object-oriented system). Moreover,
they positively performed an evaluation to confirm that these metrics identify
aspects not covered by structural and semantic coupling relations alone.

4.4. Logical coupling

Logical coupling (sometimes also called evolutionary or change coupling)

410 works by finding similar change patterns in the release history: it aims to in-
vestigate “the sequential dependencies such as if module A is changed in one
release, module B is changed in the next release” [67]. This approach has been
further developed to be applied at class level in the research conducted by Gall
et al. [68], with the aim to identify classes that share a common change behavior.
415 The authors proposed a distinction between internal and external links: internal
coupling happens between classes in the same module, while external coupling
involves classes contained in different modules. Their approach works using data
extracted from the CVS (Concurrent Versions System) release history. Fur-
ther research focused on a finer-grained analysis of system evolution, compared
420 to the description obtained using CVS. Robbes et al. [7] argued that this method
is imprecise because it employs the commits as basic analysis blocks. For this
reason, they defined coupling metrics to work using information collected dur-
ing software development through a tool that saves all the changes made to a
system in development together with the exact time at which they were made.
425 Alali et al. proposed to further extend these metrics analyzing the contribution
of age and pattern distance measures [69]. Age is defined as the period of time
between the appearance of the specific evolutionary coupling relation and its
disappearance. Pattern distance represents the tree distance between two files
in a program. Another interesting approach is the one proposed by D’Ambros
430 et al. [70]. They introduced two weighted change coupling measures EWSOC

21
 (Exponentially Weighted Sum of Coupling) and LWSOC (Linearly Weighted
Sum of Coupling). They both emphasize recent changes over past ones, but the
latter penalizes them less than the former.

4.5. Recent or isolated trends

435 Outside this classification, other coupling relations have been proposed.
They are novel techniques, still too recent to be considered a proper subgroup
of metrics, or relations developed for specific domains.
A first novel relation is interaction coupling. Interaction coupling aims to
group artifacts that are likely to implement the same task. Zou et al. [71] worked
440 on the task interaction history, defining the strength of the relation between two
entities as the number of times they are accessed together. Although interac-
tion coupling may be considered similar to logical coupling, the former requires
information from the task interaction histories and involves not only artifacts
that are changed together, but also entities that are viewed in the same por-
445 tion of time. Interaction coupling and logical coupling have been combined by
Bantelay et al. to predict future interactions [72].
The usefulness of general coupling relations led the researchers to tailor them
to domain-specific applications: e.g., knowledge-based systems. Kramer and
Kaindl proposed the Degree of Coupling of Frame (DCpF) metric to measure
450 the number of slots in a frame connected to other slots in different frames by
a rule [73]. Coupling measures have also been developed for Web Ontology
Language to evaluate the complexity of the system [74]. Table 6 summarizes
the metrics proposed for this application. Furthermore, coupling metrics have
been modified to be applied to Agent-oriented software development. Jordan
455 and Collier proposed a reformulation of the CBO metric as coupling between
abstractions, defining Coupling Between Elements (CBE) [75]: two elements
are coupled if any direct dependencies exist between any of their parts. If an
element accesses or modifies the implementation details of another one, this
leads to a dependency.

22
 Table 6: Web Ontology coupling metrics
Metric Description Ref
NEC (Number of external Number of other classes outside [74]
classes) the selected ontology
REC (References to External Counts the number of references [74]
Classes) to external classes considering a
selected ontology
RI (Referenced Includes) Computes the number of [74]
includes used in an ontology
CBE-in (Coupling Between Considers the class to be in the [76, 77]
Entities) property domain
CBE-out (Coupling Between Considers the class to be in the [76, 77]
Entities) property range
SC (Self-Coupling) Captures the properties with a [76, 77]
class contemporary in the
property range and domain

23
460 Coupling relations have also been adapted for Aspect-Oriented (AO) soft-
ware, where the basic entities are aspects and classes, to assess its reusability
and maintainability [78]. Sant’Anna et al. [78] and Ceccato and Tonella [79] (fur-
ther improved by Shen and Zhao [80] with the addition of other seven metrics)
proposed an initial set of metrics to measure aspect-oriented coupling relations.
465 An example is CBC (Coupling Between Components) [78], a general measure
of coupling that accounts for different relations between classes and aspects in
AO programs. However, these metrics have been criticized by the software
engineering community for not taking into account finer dimensions of class-
aspect coupling and their lack of empirical validation. Moreover, their adoption
470 was disregarded by the software developers [81]. For this reason, Burrows et al.
aimed to asses the quality of these metrics and, if necessary, how they might
be improved. The authors defined a new AOP coupling measure called Base-
Aspect Coupling (BAC) that quantifies the strength of the link between the
base and the aspect code. In the same year, Bernardi and Lucca proposed a
475 further set of coupling metrics based on their classification of aspects’ interac-
tions [82]. They proposed a metric for coupling due to interactions altering the
static structure (CLSS), to interactions altering the control flow (CLCF) and to
interactions altering the state of an object (CLSO). Finally, they considered all
these interactions together in the metric CLA (Coupling Level of an Aspect).
480 New metrics were proposed by Bennett and Mitropoulos to address the prob-
lem of aspect interference [83]: an aspect that causes unexpected changes to
the flow of a class or a method. The authors argued that previously proposed
AO coupling metrics did not cover all the interaction necessary to describe
potential aspect interference. To solve this issue, two new metrics were intro-
485 duced: IP (Interference Potential) and ICP (Interference Causality Potential).
Furthermore, these two metrics have been combined in a new one, TIP (Total
Interference Potential) [84]. At the same time, attempts have been made to
create a comprehensive framework, independent from the language considered,
to define AO coupling measures [85, 86, 87].
490 Moreover, specific coupling metrics have also been developed for Service-

24
 Oriented Architectures (SOA) [88, 89, 90, 91, 92, 93, 94, 95]. A SOA is an ar-
chitectural model to combine different services in one platform. It can be formed
by a combination of technologies, products, APIs and various other components
and is not related to a particular programming language [96]. Among the metrics
495 proposed, we report ASSD (Average Service State Dependency), ASPD (Aver-
age Service Persistent Dependency), ARSD (Average Required Service Depen-
dency) [88], SOCI (Service Operational Coupling Index), ISCI (Inter-Service
Coupling Index) [89] and ASOU (Average Service Operation Coupling) [93].
ASSD and ASPD compute the average of the services’ states and persistent state
500 dependencies, respectively. A persistent state dependency happens between ser-
vices that share a state, which all of them can use and update. Finally, ARSD
measures the average number of services to which each service in the system pro-
vides its functionalities. SOCI (Service Operational Coupling Index) and ISCI
(Inter-Service Coupling Index) measure the dependence of a service on other
505 services and on messages, respectively. The former was adapted by the object-
oriented metric RFC, the latter from the CBO metric. ISCI can be considered
as the opposite of ARSD [88]. To measure the dependency based on messages, a
new metric was formulated: SMCI (Service Message Coupling Index). Even if it
may seem to have a dynamic nature, it is computed statically from the informa-
510 tion model of the domain. Finally, ASOU computes the coupling of a service as
the sum of its synchronous and asynchronous invocations divided by the total
number of services in the domain. Karhikeyan and Geetha identified five types
of dependencies that influence the coupling of a Service-Oriented system: di-
rect, indirect, state, IO and delayed message dependency [94]. They developed
515 a metric for each of them and proposed a fuzzy model to evaluate the overall
coupling of a system. Pautasso and Wilde proposed a framework to evaluate
coupling in Service-Oriented design, with a specific focus on Web technologies
[97]. They defined 12 coupling directions (or facets) to assess different design
aspects, giving an instrument for comparing different Web services options.
520 The discussed coupling metrics for SOA are all static. Based on the promis-
ing results obtained by dynamic coupling in object-oriented systems, Quynh and

25
 Thang introduced a set of dynamic metrics for Service-Oriented systems [91]:
CBS (Coupling Between Services), which has been derived from CBO, IMS (In-
stability Metric for Service), DC2S (Degree of Coupling between 2 Services) and
525 DCSS (Degree of Coupling within a given Set of Services).
Semantic coupling relations have also been further developed to deal with
Service-Oriented Architecture (SOA). New metrics needed to be created since
the ones proposed by Poshyvanyk et al. [17] could not be applied in this domain:
comments and identifier names are not accessible for services and, furthermore,
530 the required concepts can also be obtained using business level artifacts [98].
For these reasons, Kazemi et al. developed three coupling metrics [98]: CCO
(Conceptual Coupling between Operations), CDSO (Conceptual Dependency of
a Service to an Operation) and CCS (Conceptual Coupling of a Service).
An interesting application of coupling measures is to assess the information
535 security of object-oriented designs [99]. To this purpose, a new metric CCC
(Critical Classes Coupling) has been defined. CCC computes the degree of in-
terconnection among classes and classified attributes in a given software design.
Moreover, it is based on design graphs (e.g., UML). However, to extract security
information these graphs need to be annotated using tools such as UMLsec [100]
540 or SPARK’s annotations [101].
Finally, coupling measures have been defined for Computational Science and
Engineering (CSE) applications [102] and real-time application design [103]. In
the context of real-time application design, Ahmed and Shoaib defined a set of
metrics (e.g., MEF, Message Exchange Factor) to evaluate the system in its early
545 development phases [103]. Kamble et al. investigated coupling in Computational
Science and Engineering (CSE) software [102] to perform software integration.
They claimed that this domain is different from others due to the complex
algorithms and functions involved.

26
 5. RQ2: Developed tools

550 Different tools have been proposed to extract the measures discussed in
Section 4. Based on the previous classification, the aim is to identify how they
work, the information that they require and their advantages and disadvantages.
Table 7 shows a summary of the tools that we have considered divided based
on the kind of metrics that they extract (structural, dynamic, semantic, logical
555 coupling or relations belonging to smaller groups). For each tool its input and
output are reported, together with its limitations: mainly its restriction to a
particular programming language (or set of languages).
Some tools are stand-alone kits that simply extract a set of metrics: e.g.,
CCMETRICS [105]. However, during our analysis, two trends emerged clearly:
560 the use of visualization techniques to improve users’ understanding and the focus
on extensibility. Moreover, in tools developed for dynamic coupling metrics, due
to the significant amount of data that needs to be analyzed, researchers focused
on scalability to improve the tools’ performance.

565 5.1. Extensibility

A problem of metric tools proposed by the software engineering community

is that the majority of them can not be extended to support new metrics or
languages [133]. For this reason, some metrics tools focused on extensibility
with the specific intent to support future metrics. Examples can be found in
570 QScope [106], which provides an explicit mechanism to include new metrics
and a framework to develop and test them, OOMeter [112] and AMT [107].
This last tool takes a further step towards extensibility, being expandable not
only with new metrics but with new languages too. To achieve an implemen-
tation independent from the programming language analyzed it takes as input
575 a representation of the source code using XML. However, this representation
should be created from the source code using a parser. For this reason, at the
time of the publication of their research, Kayarvizhy and Kanmani’s tool AMT

27
 Table 7: Coupling Tools Analyzed
Coupling Tool Input Output Limitations Ref

Structural coupling ckjm Java files or JAR files CBO (Coupling Between Objects) Restricted to Java applications [104]
RFC (Response For a Class) and Ca (Afferent coupling)

CCMETRICS Source code DAC (Data Abstraction Coupling) Restricted to object-oriented [105]
MPC (Message Passing Coupling) languages

QScope XML database of CBO and RFC [106]

the program representation and their graphical visualization

AMT Source code CBO, CBO0 , RFC, MPC, DAC and DAC0 Restricted to Java and C# [107]
(At the time on which
Kayarvizhy and Kanmani published)

WebMetrics Source code CBO and RFC Supports C, C++, Java and Smalltalk [108] [109] [110]
Fan-in and Fan-out

DependencyViewer Java files or Ca (afferent coupling) and Ce (efferent coupling) Limited to Java applications [111]
JAR archives

OOMeter Source code (Java or C#) CBO (Coupling Between Objects) Restricted to Java and C# [112]
or UML diagrams (in XMI) (can be exported in XML, Microsoft Excel, html etc.) Only supports UML in XMI format

CLUSTERCHANGES CodeFlow changeset Clusters of diff-regions (visualized a tree graph) Restricted to C# [113]

SCPA UMLsec or SPARK graphs CCC Specific for assessing security [114]
(generated with the tool) (using UMLsec or SPARK’s annotations)

GMN tool UML diagrams (in XMI format) DAC, DAC0 [115]
Briand et al.’s metric suite [16]
NASS and DCC

AEA tool Java source code NOC, DIT Restricted to Java [116]

JMCT Java source files CBO, RFC (refer to table in [117]) Restricted to Java [117]

JCAT Java source files PCC, ECC, GCC, ICC Restricted to Java [118]

JCTIViz Java source files CBO, CTI Restricted to Java [119]

Indirect Coupling Eclipse IDE use-def indirect coupling Eclipse plug-in [38]
Detector

Dynamic coupling JDissect Running Java program Dynamic coupling measures [10] Restricted to Java [10]

SSS tool6 Running Java program Total Dynamic Messages (TDM) Restricted to Java applications [120]
Distinct Class Couples (DCC)
Distinct Method Couples (DMC)

DMA Jar files EC_CC, EC_CM and EC_CD Restricted to Java applications [121]
IC_CC, IC_CM and IC_CD

DynaMetrics Running program Set of static and dynamic measures [122] Restricted to Java/C++ [122]

Semantic coupling IRC2 M Source code CoCC and CoCCm Restricted to C++ programs [11]
CSBC and CSBCm

FLAT3 Source code TFC Eclipse plug-in [58]

Feature-Method Mapping SFC

Logical coupling ROSE CVS data Locations for further changes [123]
Warnings about probable missing changes

Evolution Radar CVS data Graphical visualization of coupling

between modules and files [124] [125] [126]

YMNC tool CVS data List of files changed together with the selected one [127]

Hanakawa’s tool Java source code Module coupling measure Module coupling is [128]
and CVS data Logical coupling measure restricted to Java
(graphic visualization of them)

Other couplings OWL-VisMod Ontologies code Graphical visualization of Restricted to OWL language [129]
CBE-in and CBE-out relations

AJATO Source code and CBC (Coupling Between Components) Restricted to Aspect-Oriented [130] [131]
Concern map (XML) and Design Warnings applications
Rules (XML)

AJMetrics AspectJ files and Java files CAM, CAA, CAI and Restricted to Aspect-Oriented [80] [132]
CAE, CIM, CFA software
and a suite of structural coupling metrics

CT tool AspectJ source code CAE, CIM, CMC, CFA Restricted to AspectJ [79]

SSP tool UML diagrams SOCI, ISCI and SMCI Restricted to SOA [89]

28
 only supports Java and C#. A similar approach has also been implemented in
WebMetrics [108]. The tool implements an architecture that includes an inter-
580 mediate level of abstraction between the code and the metrics computation: the
code is processed to extract a list of relations, which are analyzed in a second
step to compute the desired metrics. This allows an easier implementation of
new measures in the tool since the developer does not need to know how the
parser operates, but only the generated intermediate relations.
585

5.2. Visualization techniques

Applying visualization techniques to metric tools constitutes another impor-

tant trend in research. The goal is not only to extract a set of software metrics
but to support and improve the users’ understanding. A step in this direction
590 has been made by DependencyViewer [111] and OOMeter [112] in 2005. Both
of them can show the metrics extracted using simple graphs: e.g., Dependen-
cyViewer reports the metrics computed for a package as a column graph.
In the field of logical coupling metrics, Evolution Radar [124, 125, 126] (2006)
and the tool proposed by Hanakawa [128] (2007) implemented a visualization
595 technique. D’Ambros et al. [125] argue that visualization techniques give im-
mediateness to the user. Evolution Radar shows as output the coupling links
existing between a selected module and the other system’ modules. The vi-
sualization interface uses the distance between the center (where the selected
module is located) as a measure of the strength of the coupling relation: the
600 closer a module is to the center, the stronger is the link. Furthermore, due to
the interactivity of this approach, it is possible to see more information related
to the selected entity such as the author, timestamp, comments, lines added
and removed and its source code and the logical coupling among entities over
time. Hanakawa’s visualization tool presents two maps: a module coupling
605 map and a logical coupling one. Both of them can be shown at the same time.

6 When the tool’s name is not explicitly stated in the referenced research, we will call it
with the initial letters of the authors’ surnames

29
 JCTIViz [119] (2008) uses a polymetric view to display software metrics. Each
class or interface is represented with a node: the dimensions of the node (height,
width and depth) represents the value of a metric. In particular, the node depth
represents the CBO value. A different approach considers the creation of tools
610 as plug-ins for existing IDEs. EPOSpix [134] exploits this idea showing related
classes in Eclipse with a pixel map. eROSE [135] is an Eclipse plug-in that
computes logical coupling to suggest related changes to the developer.
Visualization techniques have been applied also by Garcia et al. to coupling
relations among OWL ontologies [76, 129]. Their tool, OWL-VisMod, requires
615 as input the ontology’s code and it shows the coupling CBE-in/out relations
among the classes. Classes are displayed using a radial layout, where the selected
class occupies the center. On the right and left side are displayed the classes
coupled by a CBE-out or a CBE-in relation, respectively. An edge link couples
classes and its color indicates the direction of the coupling relation.
620

5.3. Scalability and Dynamic coupling

Different ways exist to collect dynamic metrics: using run-time information
or relying on simulating the execution behavior of a system using interaction
diagrams, such as UML or Real-time Object Oriented Modeling (ROOM) lan-
625 guage [136].
A first tool to find dynamic relations, proposed by Arisholm, is JDissect [46].
The tool works in two phases: in the first one, it gathers information from a
running program, while in the second step the collected data are analyzed.
However, its first limitation consists in its restriction to Java applications, due
630 to its connection with the JVM (Java Virtual Machine). In fact, this tool uses
the JVM interfaces to collect dynamic information. For what concerns the
input required, JDissect needs a running Java program to extract the dynamic
coupling relations in it. Another tool to extract dynamic coupling metrics is
DynaMetrics, proposed by Singh and Singh [122]. It can compute both dynamic
635 and static metrics, analyzing the data collected at run-time (specifically, event
log files).

30
 Extracting a significant amount of data from the execution of a program
may require a vast amount of time and resources. To mitigate this problem, in
2015 Sarvari et al. proposed to parallelize this process using Hadoop MapRe-
640 duce [120]. Hadoop MapReduce needs the XML file of the program to be exe-
cuted. For this reason, the authors utilized JP2 [137]: an open source tool that
creates CTT XML files from a running Java program. Furthermore, Hadoop
MapReduce can be used both locally and on the cloud: a cloud-based approach
further helps in dealing with large quantities of data. For this reason, in 2017
645 Dogra et al. [121] proposed DMA (Dynamic Metric Analysis), a tool based on
Platform as a Service (PaaS). Like Sarvari et al.’s tool, DMA relies on JP2
but adapts it to be streamed to the cloud. In this way, it allows the user to
have a real-time analysis of the coupling metrics during the program execution.
Sarvari et al.’s tool returns three dynamic coupling measures: TDM (Total Dy-
650 namic Messages), DCC (Distinct Class Coupling) and DMC (Distinct Method
Couples). The authors introduced this nomenclature for the first time in the
software engineering research field. However, these metrics are the same as the
ones developed earlier by Arisholm et al. [10]: TDM corresponds to IC_CD (or
EC_CD, depending on the considered direction of the relation), DCC is equal
655 to IC_CC (or EC_CC) and DMC is the same as IC_CM (or EC_CM).
Another approach is to collect dynamic coupling data from the UML dia-
grams of the program [46]. On the one hand, since these diagrams are usually
done in the early design phase, the main advantage of this approach resides in
the possibility of using dynamic relations to take design decisions. On the other
660 hand, the coupling measures collected tend to be underestimated due to the im-
possibility to distinguish the different messages in the set of possible messages
in the system using UML. Unfortunately, our systematic review did not find
any examples of tools that implemented this approach to extract dynamic met-
rics. Tools such as OOMeter [112] and the tool proposed by Girgis et al. [115]
665 extract coupling metrics from design diagrams, but they are restricted to struc-

31
 Table 8: Coupling Metrics Summary
Coupling group Metric Tool(s) Metric Ref Tool ref

Structural coupling fan-in, fan-out WebMetrics [21] [108] [110]

CBO ckjm, QScope, AMT, WebMetrics, OOMeter, DynaMetrics [8] [25] [104], [106], [107], [108] [110], [112], [122]
RFC ckjm, QScope, AMT, WebMetrics [8] [25] [104], [106], [107], [108] [110]
CBO0 AMT [28] [107]
MPC, DAC CCMETRICS, AMT [29] [28] [105], [107]
DAC0 AMT [28] [107]
SMPC, SRFC, SCBO no tool [35]
Ca ckjm, DependencyViewer, DynaMetrics [30] [104], [111], [122]
Ce DepencencyViewer, DynaMetrics [30] [111], [122]
COF no tool [32] [31]
ICP no tool [33]
NAS no tool [138]
CTA, CTM no tool [34]
IC, CBM no tool [41]
CWCBO no tool [43]
CCC SCPA [99] [114]
RMC, RIC no tool [139]
MPEC, MPIC, AFM no tool [140]
PLC no tool [141]
CIC, CNIC, MC, CC, AMC no tool [142]
CoupD, CoupT, WTCoup no tool [42]

Dynamic coupling IC and EC7 DMA, JDissect [46] [10] [143] [121], [10]
R, RD no tool [44]
RCBO DynaMetrics [47] [122]
Noc no tool [47]
EOC, IOC, OQFS, OPFS DynaMetrics [48] [122]
CQFS DynaMetrics [49] [122]
DCM no tool [50] [144]
TDM, DCC, DMC SSS tool [120] [120]
EUC, EIUC no tool [54]
ICV no tool [53]

Semantic coupling CCM, CCMC, CSMC no tool [11] [17]

CSBC (CCBC), CoCC IRC2 M [11] [17] [11]
CSBCm (CCBCm ), CoCCm IRC2 M [11] [17] [11]
CCBO no tool [56]
RTC no tool [57]
SFC, TFC FLAT3 [58] [58]
SFC0 , HFC no tool [58]
CSE, CSED no tool [61]
CSEMC, CSEBC no tool [65]

Logical coupling LC ROSE, Evolution Radar, YMNC tool and Hanakawa’s tool [67] [67] [7] [123], [124] [125], [127], [128]
CC, TC no tool [7]
IC no tool [7] [71]
NOCC, SOC, EWSOC, LWSOC no tool [70]

Semantic + structural coupling MPC, HCMC, HCCC, SSCM no tool [66]

32
 Table 9: Other Coupling Metrics Summary
Applicability field Metric Tool(s) Metric Ref Tool ref

Knowledge-based Systems DCpF no tool [73]

Web Ontology Language NEC, REC, RI no tool [74]
CBE-in, CBE-out OWL-VisMod [76] [129]
SC, iSC, iCBE-in, iCBE-out no tool [76]
aspect-oriented Software CBC AJATO [78] [130] [131]
CFA, CIM, CMC, CAE AJMetrics, CT tool [79] [80] [79]
CAM, CAA, CAI, RFM, RFP AJMetrics [80] [80]
BAC no tool [81]
IP, ICP no tool [83] [84]
TIP no tool [84]
CoAT, CoPT, CoAR, CoOI, CoI, CoHA no tool [87]
CLSS, CLCF, CLSO, CLA no tool [82]
Agent Orientation Paradigm CBE no tool [75]
Service-Oriented Architecture ASSD, ASPD, ARSD no tool [88]
SOCI, ISCI, SMCI SSP tool [89] [89]
WISCE, WESICE, WESOCE, ESICSI, EESIOC, SIIEC, SPARF, SPURF no tool [95]
ASOU no tool [93]
CBS, IMS, DC2S, DCSS no tool [91]
CCO, CDSO, CCS no tool [98]
DD, IDDT, IDDSD, IDD, SD, IOD, DMsgD no tool [94]
Remote-component-based Systems CCOF no tool [145]
Real-time application design MEF no tool [103]

tural metrics.
6. Discussion

A vast quantity of coupling metrics and relations has been proposed for
different paradigms and applications, starting with procedural languages and,
670 later, object-oriented ones. Due to their importance in assessing the software
quality and analyzing programs’ features, coupling relations were proposed to
investigate aspects left uncovered by previous research and to be applied to
specific application domains.
Our research showed how CBO (Coupling Between Objects), proposed by
675 Chidamber and Kemerer as part of their metrics suite [25], became a funda-
mental coupling metric used as base for further metrics and refinements by
other researchers: examples can be found in CBO0 [28], CWCBO [43] and CBE
(Coupling Between Elements) [75]. Moreover, our investigation revealed that
sometimes the researchers encountered difficulties in retrieving previously pro-
680 posed metrics. Analyzing the material collected in our review, we noticed incon-

7 at different granularity levels

33
 sistencies in the metrics names: e.g., afferent and efferent coupling have been
proposed as Ca and Ce by Martin [30], but later referred by Singh and Singh
[122] as AFC and EC. This is only a formal issue, but different nomenclatures
for referring to the same metric may undermine the coherence of the research
685 corpus in this field. The problem of formally defining the metrics and validate
them led to the creation of many frameworks: e.g., the one defined by Tempero
and Ralph [146].
Software metrics should undergo a theoretical and empirical validation when
they are introduced. Our investigation revealed that coupling metrics are eval-
690 uated referring to the properties defined by Kitchenham et al. [147], Weyuker
[148] and Briand et al. [28]. Metrics such as CTA and CTM [34], CWCBO
[43] and CCBC [11] have been validated using this process. However, we no-
ticed that a vast number of metrics have been proposed without undergoing
a theoretical evaluation: for instance, based on properties like Representation
695 condition [147]. Many studies performed only an empirical evaluation. Using
a set of test cases, the goal of the studies was to assess that the newly pro-
posed metric achieves better performance than a previous one as an indicator
for a specific application: e.g., fault prediction. Moreover, a common trend
is to apply correlation analysis techniques (Spearman correlation or Principal
700 Component Analysis) to verify the orthogonality of a new metric compared to
previously presented ones. More emphasis has been given by the researchers on
this second aspect of the evaluation. The theoretical evaluation does not seem
to be considered as fundamental as the empirical one since the latter contributes
to highlight the novelty of the metric. Thus, we suggest novel metrics to employ
705 both a theoretical and empirical validation/correlation analysis.
Table 8 shows a summary of the metrics retrieved in our systematic litera-
ture review. They are grouped based on the category of coupling relations to
which they belong. Furthermore, they are associated with the tools that can be
used to extract them (if any). While for the structural, dynamic and semantic
710 coupling relations a set of metrics has been defined, for the logical coupling re-
lations no strict metric definitions seem to exist. In the table, we referred to the

34
 classification given by Robbes et al. [7], but their definitions allow different in-
terpretations of the same metric. Further efforts should be devoted to provide
a consistent formal definition of logical coupling metrics. Table 9 contains an
715 overview of the metrics belonging to the Other coupling approaches group. They
are grouped based on the field of applicability (e.g., Aspect-Oriented software).
As in the previous table, the tools that can be used to extract them (if retrieved
in our systematic review) are reported.
Our analysis of the coupling metric tools proposed by the researchers re-
720 vealed two interesting trends: the progressive use of visualization techniques as
a means to show the information to the user and the focus on making easily ex-
tendible tools. Visualization techniques, used in tools such as Evolution Radar
[125] or OWL-VisMod [129], help the user to have a better understanding of
the considered software properties. Usually, this approach allows changing the
725 considered entity interactively. D’Ambros et al. stated that the idea of recur-
ring to visualization is based on the following motives: “it provides effective
ways to break down the complexity of information” and “it has been shown to
be a successful means to study the evolution of software systems” [125]. As the
second trend, easily expandable tools want to overcome the problem of having
730 metric tools that work only on a specific programming language (or groups of
languages). Researchers proposed modular designs in which new metrics can be
implemented without the need to understand the whole tool implementation.
Examples can be found in tools such as AMT [107] and WebMetrics [108].
Tahir and MacDonell stated that dynamic metrics could be collected using
735 a run-time analysis or executable modules and interaction diagrams (UML or
ROOM) [136]. Although both of these approaches have been analyzed in the
literature, in our review we did not find any tool that implemented a methodol-
ogy based on interaction graphs. This could be caused by the lack of precision
that dynamic coupling metrics computed during the design phase are likely to
740 have, which may have discouraged further research attempts in this direction.
However, it is also necessary to highlight that this may be caused by the lim-
ited scope of our review, as given by our procedure and especially the choice to

35
 restrict the analysis to academic-developed tools. Also the semantic coupling
area suffers from a lack of tools to extract its correlated metrics: IRC2 M [17]
745 and FLAT3 [58] are the only ones retrieved in our systematic review. This can
be explained by the fact that semantic coupling relations have been investigated
only by a restricted group of researchers.
Coupling relations can be used to cluster related code changes, helping devel-
opers in the process of reviewing and modifying their software. Logical coupling
750 is particularly suited for this task, due to its intrinsic nature: logical coupling
relations were introduced to find similar change patterns in the code release his-
tory [67]. An example can be found in ROSE [123], which gives suggestions to
the user regarding which portions of code are likely to have to be changed with
the current one. However, also structural or semantic coupling relations can be
755 effectively used with this intent. CLUSTERCHANGES [113] uses data coupling
to cluster code diff-regions that influence each other and, therefore, should be
inspected together when modifying one of them. On the contrary, we argue
that dynamic coupling metrics are unsuitable for this task since they reflect
run-time relations among software elements which can not be easily collected
760 when dealing with code changes. An interesting way to approach the problem
of grouping related code changes is given by the evolutionary coupling relations
proposed by Zou et al. [71]. Information on which entities have been accessed
together during the development phase may constitute a sound basis on which
grouping together portions of code: in fact, these are likely to implement the
765 same functionality.

7. Coupling Relations: A Research Roadmap

While the research community heavily investigated ways to measure coupling

relations, we believe that future research directions should and will be devoted
to the application of such coupling metrics as well as the definition of effec-
770 tive combinations of metrics that would allow a better estimation of the actual
coupling of software classes. This section aims at reporting a (non-exhaustive)

36
 roadmap for further research in the field.
Applications. There are plenty of opportunities to use coupling metrics
to support other software maintenance and evolution tasks. For instance, their
775 use in the context of code review may represent an effective method to improve
the way developers detect defective source code. Specifically, change-based code
review constitutes an important trend in software development and improving
the existing techniques may lead to a significant contribution to software en-
gineering [149, 150, 151]. Coupling relations may be applied to analyze the
780 code contained in different changes and, consequently, cluster similar changes
together. Baum et al. proposed an ordering theory for code changes based on the
relations that they share with each other [149]. In particular, they conducted a
survey among developers to evaluate which relations were considered important.
Among all of them, they mentioned the similarity relation. We argue that logi-
785 cal and semantic coupling relations may be applied as practical implementation
of this relation. Still in the context of code review, coupling metrics might be
exploited in conjunction with just-in-time defect prediction [152]: we envision
the introduction of coupling-related information on top of the recommendations
provided by defect prediction models, so that developers might be informed on
790 the classes having relations with a defective file and possibly assess the risk of
defect propagation over these classes.
Another promising research field in Software Engineering is Code Smell de-
tection [153, 154, 155]. Recent works started to exploit it by using machine
learning techniques [156, 157] and to classify the severity of a code smell issue
795 [158]. While some structural and logical coupling metrics have already been
used as features of these models, there is still room for improvement: as shown
by our survey, the role of many complementary coupling metrics can be explored
to improve the (not always good [159]) performance of currently available code
smell prediction models. Still in the same area, the application of conceptual
800 coupling metrics have been explored by Palomba et al. [160, 161]. The authors
also suggested that the exploration of a combination between structural and
conceptual metrics may lead to promising results. This is something that is still

37
 unknown and that might lead to new research directions on how to combine
the output of different metrics. At the same time, it remains unclear what is
805 the value of other coupling metrics in the context of code smell detection: for
example, to the best of our knowledge, implications of using dynamic coupling
metrics to detect code smells are still to be evaluated. This seems to be a natu-
ral fit for the identification of Message Chain instances [162], given its intrinsic
dynamic nature: in fact, it occurs when a long chain of method invocations is
810 required for the operations of a class [163].
Finally, coupling relations have found a major field of application in Change
Prediction, a research area dealing with identifying the classes that are more
prone to be modified in the future [164]. Most works rely on the use of struc-
tural coupling metrics (among others) as indicators of these classes [165]. A
815 recent study conducted by Elish and Al-Rahman Al-Khiaty evaluates a set of
evolution metrics for change prediction purposes [166]. The authors reported
that these metrics measure different dimensions than the classical Chidamber
and Kemerer’s metrics suite [25] and that their combination improved the ac-
curacy of their prediction model. Based on the promising results of their work,
820 we argue that the application of logical coupling or conceptual coupling metrics
to this context may be worthy. This metric may be combined with structural
or dynamic ones and tested to see if the performance of a model that takes into
account these different aspects increases: we expect so from the moment that
recent studies [164, 167] showed how an improved description of the change pre-
825 diction phenomenon, done through the addition of orthogonal information, can
dramatically increase the overall ability of prediction models in discriminating
the classes that are more likely to change in the future.
Coupling relations and metrics have been applied in many different contexts,
of which the ones cited above (e.g., code review, code smells detection or change
830 prediction) constitute just a small part. Depending on the application consid-
ered, combining two or more groups of coupling metrics may be worthwhile: the
existing techniques could increase their performance. An example may be found
in the research conducted by Palomba et al. to identify code smells with concep-

38
 tual coupling metrics, where the authors argue that the possible combination
835 of these metrics with others belonging to different groups (e.g., structural or
conceptual) may lead to a further performance increase [160].

Combination. During our investigation, we noticed very few attempts to

integrate previously proposed coupling metrics in an ensemble metric, i.e., a
method able to combine the information coming from different sources. In our
840 opinion, this represents an important research direction that might be worth to
investigate to come up with more powerful solutions for measuring coupling re-
lations. As an example, consider the application of machine learning approaches
in this context: coupling metrics computed using different data sources (e.g.,
structural vs conceptual coupling) might be nicely adopted as features of a
845 regressor able to estimate a combined form of coupling that may provide de-
velopers with a comprehensive view of the phenomenon, thus facilitating her
ability to take informed decisions. At the same time, we envision a combination
of those metrics through the use of search-based algorithms: a clear opportu-
nity is represented by the possibility to apply them for refactoring purposes
850 (e.g., to improve software re-modularisation by means of aggregate measures
that optimize the locations of classes).
Furthermore, our work classifies new approaches or coupling metrics for spe-
cific domains in a generic group called “recent or isolated trends” (section 4.5).
The knowledge on those metrics is still poor and the way they can effectively
855 complement existing measures is still unknown. This represents an opportunity
for future research, as researchers are called to investigate further how these
emerging metrics can be combined with the set of metrics for which way more
information is available.

8. Conclusion

860 This work presented a systematic review of the coupling relations and metrics
proposed until now by the software engineering research community. In the
first part of our research, we analyzed the trends that emerged over time in

39
 the software coupling area. We developed a taxonomy, as complete as possible
within the limitations of our approach, of these relations in the attempt to give
865 a systematic classification of over thirty years of research in the field. Based
on previous works, such as the one done by Bavota et al. [9], we divided the
coupling relations into four main groups: structural, dynamic, semantic and
logical. Furthermore, we included a fifth group of coupling metrics not listed
with the previous ones, since they constitute new trends still in development
870 or coupling metrics developed for a particular field of applicability (such as
knowledge-based systems or aspect-oriented applications).
In the second part of our investigation, we presented the tools developed
by the research community to extract (and sometimes even visualize) coupling
relations. The tools retrieved have been summarized in Table 7 maintaining the
875 structure used to answer our first research question: dividing the tools based on
the coupling group of metrics that they extract. For each tool, we highlighted
the input that it needs and the output that it produces, together with its possi-
ble limitations: e.g., a restriction to a particular programming language. More-
over, we analyzed three main trends noticed in the academic-proposed tools:
880 application of visualization techniques, extensibility, and scalability (applied to
dynamic coupling metrics). We proposed a discussion on our findings and a
roadmap for future work. The complexity of this research field sometimes led
to discrepancies among the introduced coupling metrics. As guidance for future
work we highlighted interesting applications of the presented coupling relations
885 and metrics (change clustering, code review, code smells detection and change
prediction), reporting the groups of coupling metrics already applied in these
fields together with the ones that are yet to be explored and that may constitute
the starting point for future work. Furthermore, we discussed the possibility to
combine existing coupling metrics to create ensemble metrics, able to combine
890 information from different sources.

40
 Acknowledgments

E. Fregnan, F. Palomba, and A. Bacchelli gratefully acknowledge the sup-

port of the Swiss National Science Foundation through the SNF Project No.
PP00P2_170529.

895 List of primary studies

- A. Offutt, M. Harrold, P. Kolte, A software metric system for module

coupling, Journal of Systems and Software 20 (1993) 295–308.

- N.Fenton, J.Bieman, Software Metrics: A rigorous and practical approach,

CRCPress, 2014

900 - R. Robbes, D. Pollet, M. Lanza, Logical Coupling Based on Fine-Grained

Change Information, 15th Working Conference on Reverse Engineering, WCRE
’08 (2008) 42–46.

- S. Chidamber, C. Kemerer, Towards a metrics suite for object oriented

design, Conference Proceedings on Object-oriented programming systems, lan-
905 guages, and applications (OOPSLA ’91) (1991) 197–211.

- G. Bavota, B. Dit, R. Oliveto, M. Di Penta, D. Poshyvanyk, A. De Lucia,

An Empirical Study Of The Developers’ Perception Of Software Coupling, Pro-
ceedings of the 2013 International Conference on Software Engineering (ICSE
’13) (2013) 692701.

910 - E. Arisholm, L. Briand, A. Foyen, Dynamic Coupling Measurement For

Object –oriented Software, IEEE Transactions on Software Engineering 30 (8)
(2004) 491–506.

- D. Poshyvanyk, A. Marcus, The Conceptual Coupling Metrics for Object

–Oriented Systems, ICSM ’06 Proceedings of the 22nd IEEE International Con-
915 ference on Software Maintenance (2006) 469–478.

- S. Kirbas, T. Hall, A. Sen, Evolutionary coupling measurement: Making

sense of the current chaos, Science of Computer Programming 135 (2017) 4–19.

41
 - A. Nicolaescu, H. Lichter, Y. Xu, Evolution of Object Oriented Coupling
Metrics: A sampling of 25 years of research, IEEE/ACM 2nd International
920 Workshop on Software Architecture and Metrics (SAM) (2015) 48–54.

- L. Briand, P. Devanbu, W. Melo, An Investigation into Coupling Mea-

sures for C++, Proceeding of the 1997 International Conference on Software
Engineering (1997) 412–421.

- D. Poshyvanyk, A. Marcus, R. Ferenc, T. Gyimóthy, Using information

925 retrieval based coupling measures for impact analysis, Empirical Software En-
gineering 14 (1) (2009) 5–32.

- J. Alghamdi, Measuring Software Coupling, in: Proceedings of the 6th

WSEAS International Conference on Software Engineering, Parallel and Dis-
tributed Systems, SEPADS’07, World Scientific and Engineering Academy and
930 Society (WSEAS), Stevens Point, Wisconsin, USA, 2007.

- G. Myers, Reliable software through composite design, Mason and Lip-

scomb, 1975.

- S. Schach, Object-Oriented and Classical Software Engineering, 8th edition,

McGraw-Hill, 2011.

935 - S. Henry, D. Kafura, Software Structure Metrics Based on Information

Flow, IEEE Transactions on Software Engineering SE–7 (5) (1981) 510–518.

- E. Allen, T. Khoshgoftaar, Y. Chen, Measuring coupling and cohesion of

software modules: an information-theory approach, Proceedings of the 7th Inter-
national Software Metrics Symposium, 2011. METRICS 2001 (2001) 124–134.
940 - E. B. Allen, S. Gottipati, R. Govindarajan, Measuring size, complexity
and coupling of hypergraph abstractions of software: An information theory
approach, Software Quality Journal 15 (2) (2007) 179–212

- J. Eder, G. Kappel, M. Schrefl, Coupling and Cohesion in Object –Oriented

Systems, 1992.

945 - S. Chidamber, C. Kemerer, A metrics suite for object oriented design, IEEE
Transactions on Software Engineering 20 (6) (1994) 476–493.

42
 - M. Hitz, B. Montazeri, Measuring Coupling and Cohesion In Object –Ori-
ented Systems, Proceedings of International Symposium on Applied Corporate
Computing 35 (1995) 25–27.

950 - L. Briand, S. Morasca, V. R. Basili, Property-based software engineering

measurement, IEEE Transactions on Software Engineering 22 (1) (1996) 68–86.
- L. Briand, J. Daly, J. Wust, A unified framework for coupling measure-
ment in object-oriented systems, IEEE Transactions on Software Engineering
25 (1999) 91–121.

955 - W. Li, S. Henry, Object-Oriented Metrics that Predict Maintainability,

Journal of Systems and Software 23 (1993) 111–122.

- R. Martin, Object oriented design quality metrics: an analysis of depen-

dencies, vol. 2, 2006.

- F. Abreu, R. Esteves, M. Goulla̋o, Toward the Design Quality Evaluation

960 of Object–Oriented Software, 1995.

- F. Abreu, R. Carapuça, Object-Oriented Software Engineering: Measuring

and Controlling the Development Process, in: Proceedings of the 4th Interna-
tional Conference on Software Quality, 1994.

- Y. Lee, B. Liang, S. Wu, F. Wang, Measuring the Coupling and Cohesion

965 of an Object-Oriented Program Based On Information Flow, in: Proceedings of
the International Conference on Software Quality, 1995.

- W. Li, Another Metric Suite for Object-oriented Programming, Journal of

System and Software 44 (2) (1998) 155–162.

- J. Rilling, W. J. Meng, O. Ormandjieva, Context driven slicing based

970 coupling measures, in: 20th IEEE International Conference on Software Main-
tenance,2004. Proceedings., 2004.

- M. English, J. Buckley, T. Cahill, Fine-Grained Software Metrics in Prac-

tice, in: First International Symposium on Empirical Software Engineering and
Measurement (ESEM 2007), ISSN 1949–3770, 295–304,
975 doi:10.1109/ESEM.2007.32, 2007.

43
 - H. Li, A Novel Coupling Metric for Object-Oriented Software Systems, in:
2008 IEEE International Symposium on Knowledge Acquisition and Modeling
Workshop, 609–612, doi:10.1109/KAMW.2008.4810562, 2008.

- H. Y. Yang, E. Tempero, R. Berrigan, Detecting indirect coupling, in:

980 2005 Australian Software Engineering Conference, ISSN 1530–0803, 212–221,
doi:10.1109/ASWEC.2005.22, 2005.

- H. Y. Yang, E. Tempero, Indirect Coupling As a Criteria for Modularity, in:

First International Workshop on Assessment of Contemporary Modularization
Techniques (ACoM ’07), 10–10, doi:10.1109/ACOM.2007.5, 2007.

985 - S. Almugrin, W. Albattah, A. Melton, Using indirect coupling metrics to

predict package maintainability and testability, Journal of Systems and Software
121 (2016) 298–310, ISSN 0164–1212,
doi: https://doi.org/10.1060 1016/j.jss.2016.02.024,
URL http://www.sciencedirect.com/science/article/pii/S016412121600056X.
990 - M. Tang, M. Kao, M. Chen, An empirical study on object-oriented met-
rics, in: Proceedings Sixth International Software Metrics Symposium (Cat.
No.PR00403), 242–249, 1999.

- G. Gui, P. D. Scott, New Coupling and Cohesion Metrics for Evaluation

of Software Component Reusability, in: 2008 The 9th International Conference
995 for Young Computer Scientists, 1181–1186, doi:10.1109/ICYCS.2008.270, 2008.
- A. Aloysius, L. Arockiam, Coupling Complexity Metric: A Cognitive Ap-
proach, International Journal of Information Technology and Computer Science
4 (2012) 29–35.

- A. Mitchell, J. Power, An empirical investigation into the dimensions of run-

1000 time coupling in Java programs, Proceedings of the 3rd international symposium
on Principles and practice of programming in Java (2004) 9–14.

- R. Geetika, P. Singh, Dynamic Coupling Metrics for Object Oriented Soft-

ware Systems: A Survey, SIGSOFT Softw. Eng. Notes 39 (2) (2014) 1–8, ISSN
0163–5948, doi:10.1145/2579281.2579296,
1005 URL http://doi.acm.org/10.1145/2579281.2579296.

44
 - E. Arisholm, Dynamic coupling measures for object-oriented software, Pro-
ceeding of the 8th IEEE Symposium on Software Metrics (2002) 33–42.

-V. Dixit, R. Vishwkarma, Comparison of class-level versus object–level

static and dynamic coupling and cohesion measures in object oriented program-
1010 ming, 11th International Conference on Wireless and Optical Com1munication
Networks (WOCN) (2014) 1–5.

-H. Abualese, P. Sumari, T. Al-Rousan, M. R. Al-Mousa, Utility classes

detection metrics for execution trace analysis, in: 2017 8th International Con-
ference on Information Technology (ICIT), 469–474,
1015 doi:10.1109/ICITECH.2017.8080044, 2017.

- A. Mitchell, J. Power, Using object-level run-time metrics to study cou-

pling between objects, Proceedings of the 2005 ACM symposium on Applied
computing (SAC ’05) (2005) 1456–1452.

- S. Yacoub, H. Ammar, T. Robinson, Dynamic metrics for object oriented

1020 design, Proceedings of the 6th Software Metrics Symposium (1999) 50–61.

-A. Zaidman, S. Demeyer, Analyzing large event traces with the help of
coupling metrics, in: Proceedings of the Fourth International Workshop on OO
Reengineering, 2004.

- Y. Hassoun, R. Johnson, S. Counsell, A dynamic runtime coupling for meta-

1025 level architectures, Proceedings of the 8th European Conference on Software
Maintenance and Reengineering, CSMR 2004 (2004) 339–346.

- R. Gunnalan, M. Shereshevsky, H. H. Ammar, Pseudo dynamic met-

rics[software metrics], in: The 3rd ACS/IEEE International Conference on Com-
puter Systems and Applications, 2005., ISSN 2161-5322, 117–,
1030 doi:10.1109/AICCSA.2005.1387106, 2005.

- Y. Liu, A. Milanova, Static Analysis for Dynamic Coupling Measures,

in: Proceedings of the 2006 Conference of the Center for Advanced Studies
on Collaborative Research, CASCON ’06, IBM Corp., Riverton, NJ, USA,

45
 doi:10.1145/1188966.1188980, URL http://dx.doi.org/10.1145/1188966.1188980,
1035 2006.

- J. Cleland-Huang, C. Chang, H. Kim, A. Balakrishnan, D. Nassar, H.

Ammar, A. Mili, Requirements-based dynamic metrics in object-oriented sys-
tems, 5th IEEE International Symposium on Requirements Engineering (2001)
212–219.

1040 - B. Újházi, R. Ferenc, D. Poshyvanyk, T. Gyimóthy, New conceptual cou-

pling and cohesion metrics for object-oriented systems, 10th IEEE Interna-
tional Working Conference on Source Code Analysis and Manipulation 1120
(SCAM’10) (2010) 33–42.

- M. Gethers, D. Poshyvanyk, Using Relational Topic Models to capture

1045 coupling among classes in object-oriented software systems, 10th IEEE Inter-
national Working Conference on Software Maintenance (ICSM) (2010) 1–10.

- M. Revelle, M. Gethers, D. Poshyvanyk, Using structural and textual in-

formation to capture feature coupling in object-oriented software, Empirical
1050 Software Engineering 16 (2011) 773–811.

- D. Poshyvanyk, Y. Guéhéneuc, A. Marcus, G. Antoniol, V. Rajlich, Feature

Location Using Probabilistic Ranking of Methods Based on Execution Scenar-
ios and Information Retrieval, IEEE Transactions on Software Engineering 33
(2007) 420–432.

1055 - H. Kagdi, M. Gethers, D. Poshyvanyk, M. L. Collard, Blending Concep-

tual and Evolutionary Couplings to Support Change Impact Analysis in Source
Code, in: 2010 17th Working Conference on Reverse Engineering, 1135 ISSN
2375-5369, 119–128, doi:10.1109/WCRE.2010.21, 2010.

- M. Gethers, A. Aryani, D. Poshyvanyk, Combining Conceptual and Domain-

1060 Based Couplings to Detect Database and Code Dependencies, IEEE 12th In-
ternational Working Conference on Source Code Analysis and Manipulation
(SCAM) (2012) 144–153.

46
 - A. Aryani, I. Peake, M. Hamilton, Domain-based change propagation anal-
ysis: An enterprise system case study, IEEE International Conference on Soft-
1065 ware Maintenance (ICSM) (2010) 1–9.

- A. Aryani, F. Perin, M. Lungu, A. Mahmood, O. Nierstrasz, Can we predict

depencencies using domain information?, 18th Working Conference on Reverse
Engineering (WCRE) (2011) 55–64.

- M. Rahman, A. Aryani, C. Roy, F. Perin, On the relationships between

1070 domain-based coupling and code clones: an exploratory study, Proceedings of
the 2013 International Conference on Software Engineering (2013) 1265–1268.

- H. Kagdi, M. Gethers, D. Poshyvanyk, Integrating conceptual and logical

couplings for change impact analysis in software, Empirical Software Engineer-
ing 18 (5) (2013) 933–969.

1075 - M. Alenezi, K. Magel, Empirical Evaluation of a New Coupling Metric:

Combining Structural and Semantic Coupling, International Journal of Comput-
ers and Applications 36 (1) (2014) 34–44, doi:10.2316/Journal.202.2014.1.202-
3902,
URL https://www.tandfonline.com/doi/abs/10.2316/Journal.202.2014.1.202-3902.
1080 - H. Gall, K. Hajek, M. Jazayeri, Detection of Logical Coupling Based on
Product Release History, Proceedings of the International Conference on Soft-
ware Maintenance, 1998 (1998) 190–198.

- H. Gall, M. Jazayeri, J. Krajewski, CVS Release History Data For Detecting

Logical Couplings, Proceedings of the 6th International Workshop on Principles
1085 of Software Evolution (2003) 13–23.

- A. Alali, B. Bartman, C. Newman, J. Maletic, A Preliminary Investigation

of Using Age and Distance Measures in Detection of Evolutionary Couplings,
10th IEEE Working Conference on Mining Software Repositories (MSR) (2013)
169–172.

1090 - M. D’Ambros, M. Lanza, R. Robbes, On the Relationship Between Change

Coupling and Software Defects, in: 2009 16th Working Conference on Reverse
Engineering, ISSN 1095-1350, 135–144, doi:10.1109/WCRE.2009.19, 2009.

47
 - L. Zou, M. Godfrey, A. Hassan, Detecting Interaction Coupling from Task
Interaction Histories, 15th IEEE Internation Conference on Program Compre-
1095 hension, ICPC ’07 (2007) 135–144.

- F. Bantelay, M. B. Zanjani, H. Kagdi, Comparing and combining evolution-

ary couplings from interactions and commits, in: 2013 20th Working Conference
on Reverse Engineering (WCRE), ISSN 1095–1350, 311–320,
doi:10.1109/WCRE.2013.6671306, 2013.

1100 - S. Kramer, H. Kaindl, Coupling and cohesion metrics for knowledge-based

systems using frames and rules, ACM Transactions on Software Engineering
and Methodology 13 (2004) 332–358.

-A. Orme, H. Tao, L. Etzkorn, Coupling metrics for ontology –based system,
IEEE Software 23 (2006) 102–108.

1105 - H. Jordan, R. Collier, Evaluating Agent-Oriented Programs: Towards

Multi-paradigm Metrics, International Workshop on Programming Multi Agent
Systems (2010) 63–78.

- J. Garcia, F. Garcia, R. Theron, Visualizing Semantic Coupling among

Entities in an OWL Ontology, Ontology, Conceptualization and Epistemology
1110 for Information Systems, Software Engineering and Service Science, ONTOSE
2010 (2010) 90–106.

- J. García, F. García, R. Therón, Defining Coupling Metrics among Classes

in an OWL Ontology, in: N. García-Pedrajas, F. Herrera, C. Fyfe, J. M. Benítez,
M. Ali (Eds.), Trends in Applied Intelligent Systems, Springer Berlin Heidelberg,
1115 Berlin, Heidelberg, ISBN 978-3-642-13025-0, 12–17, 1195 2010.

- C. Sant’Anna, A. Garcia, C. Chavez, C. Lucena, A. von Staa, On the Reuse

and Maintenance of Aspect-Oriented Software: An Assessment Framework, in:
Proceedings of Brazilian Symposium on Software Engineering, 19–34, 2003.

- M. Ceccato, P. Tonella, Measuring the Effects of Software Aspectization,

1120 2004.

48
 - H. Shen, J. Zhao, An evaluation of coupling metrics for aspect-oriented
software, Tech. Rep., 2007.

- R. Burrows, F. C. Ferrari, A. Garcia, F. Taiani, An empirical evalua-

tion of coupling metrics on aspect-oriented programs, Proceedings of the 2010
1125 ICSE Workshop on Emerging Trends in Software Metrics (WETSoM ’10) (2010)
53–58.

- M. L. Bernardi, G. A. D. Lucca, A metric model for aspects’ coupling, in:

WETSoM, 2010.

- B. Bennett, F. Mitropoulos, New metrics for assessing aspect coupling, in:

1130 SoutheastCon 2016, 1–8, 2016.

- B. T. Bennett, Using hierarchical agglomerative clustering to locate poten-

tial aspect interference, in: SoutheastCon 2017, 1–8, 2017.

- J. Zhao, Measuring Coupling in Aspect-Oriented Systems, in: Information

Processing Society of Japan (IPSJ), 14–16, 2004.

1135 - T. Tonelli Bartolomei, A. Garcia, C. Sant’Anna, E. Figueiredo, Towards a

Unified Coupling Framework for Measuring Aspect-Oriented Programs, in: 3rd
InternationalWorkshop on Software Quality Assurance (SOQUA), ACM Press,
ACM Press, New York, NY, USA, ISBN 1-59593-584-3, 46–53,
doi:http://doi.acm.org/10.1145/1188895.1188907, 2006.

1140 - A. Kumar, R. Kumar, P. S. Grover, Generalized Coupling Measure for

Aspect-oriented Systems, SIGSOFT Softw. Eng. Notes 34 (3) (2009) 1–6, ISSN
0163-5948, doi:10.1145/1527202.1527209,
URL http://doi.acm. org/10.1145/1527202.1527209.

- K. Qian, J. Liu, F. Tsui, Decoupling Metrics for Services Composition, in:

1145 5th IEEE/ACIS International Conference on Computer and Information Science
and 1st IEEE/ACIS International Workshop on Component-Based Software
Engineering,Software Architecture and Reuse (ICIS-COMSAR’06), 44–47, 2006.
- R. Sindhgatta, B. Sengupta, K. Ponnalagu, Measuring the Quality of Ser-
vice Oriented Design, Springer Berlin Heidelberg, Berlin, Heidelberg, 485–499,
1150 2009.

49
 - A. A. M. Elhag, R. Mohamad, Metrics for evaluating the quality of service
oriented design, in: 2014 8th. Malaysian Software Engineering Conference 1235
(MySEC), 154–159, doi:10.1109/MySec.2014.6986006, 2014.

- P. Quynh, H. Thang, Dynamic Coupling Metrics for Service –Oriented

1155 Software, International Journal of Computer, Electrical, Automation, Control
and Information Engineering 3 (2009) 795–800.

- X. Wang, Metrics for Evaluating Coupling and Service Granularity in Ser-

vice Oriented Architecture, in: 2009 International Conference on In-formation
Engineering and Computer Science, ISSN 2156-7379, 1–4,
1160 doi: 10.1109/ICIECS.2009.5362767, 2009.

- S. Alahmari, E. Zaluska, D. C. D. Roure, A Metrics Framework for Eval-

uating SOA Service Granularity, in: 2011 IEEE International Conference on
Services Computing, 512–519, doi:10.1109/SCC.2011.98, 2011.

- T. Karhikeyan, J. Geetha, A metrics suite and fuzzy model for measur-

1165 ing coupling in Service Oriented Architecture, in: 2012 International Con-
ference on Recent Advances in Computing and Software Systems, 254–259,
doi:10.1109/RACSS.2012.6212677, 2012.

- M. Perepletchikov, C. Ryan, K. Frampton, Z. Tari, Coupling Metrics for

Predicting Maintainability in Service-Oriented Designs, in: 2007 Australian
1170 Software Engineering Conference (ASWEC’07), ISSN 1530-0803, 329–340, doi:10.1109/ASWEC.2007.17,
2007.

- A. Kazemi, A. Azizkandi, A. Rostampour, H. Haghihi, P. Jamshidi, F.

Shams, Measuring the Conceptual Coupling of Services Using Latent Semantic
Indexing, IEEE International Conference on Service Computing 1260 (SCC)
1175 (2011) 504–511.

- B. Alshammari, C. Fidge, D. Corney, Security Metrics for Object-Oriented

Designs, 21st Australian Software Engineering Conference (ASWEC) (2010)
55–64.

50
 - S. Kamble, X. Jin, N. Niu, M. Simon, A Novel Coupling Pattern in Com-
1180 putational Science and Engineering Software, in: 2017 IEEE/ACM 12th In-
ternational Workshop on Software Engineering for Science (SE4Science), 9–12,
doi:10.1109/SE4Science.2017.10, 2017.

M. Ahmed, M. Shoaib, Novel Design Metrics to Measure Real Time Envi-

ronment Application Design, Journal of American Science 7 (2011) 222.

1185 - D. Spinellis, Tool writing: a forgotten art? (software tools), IEEE Software
22 (4) (2005) 9–11.

- S. Husein, A. Oxley, A Coupling and Cohesion Metrics Suite for Object-

Oriented Software, in: Proceedings of the 2009 International Conference on
Computer Technology and Development - Volume 01, ICCTD ’09, IEEE Com-
1190 puter Society, Washington, DC, USA, ISBN 978-0-7695-3892-1, 421–425, 2009.

- M. Eichberg, D. Germanus, M. Mezini, L. Mrokon, T. Schafer, QScope: an

open, extensible framework for measuring software projects, in: Conference on
Software Maintenance and Reengineering (CSMR’06), 10 pp.–122, 2006.

1195 - N. Kayarvizhy, S. Kanmani, An Automated Tool for Computing Object

Oriented Metrics Using XML, Springer Berlin Heidelberg, Berlin, Heidelberg,
69–79, 2011.

- M. Scotto, A. Sillitti, G. Succi, T. Vernazza, A Relational Approach to Soft-

ware Metrics, in: Proceedings of the 2004 ACM Symposium on Applied Com-
1200 puting, SAC ’04, ACM, New York, NY, USA, ISBN 1- 58113-812-1, 1536–1540,
doi:10.1145/967900.968207,
URL http://doi.acm.org/10.1145/967900.968207, 2004.

- M. Scotto, A. Sillitti, G. Succi, T. Vernazza, Non-invasive Product Metrics

Collection: An Architecture, in: Proceedings of the 2004 Workshop on Quan-
1205 titative Techniques for Software Agile Process, QUTE-SWAP ’04, ACM, New
York, NY, USA, 76–78, doi:10.1145/1151433.1151444,
URL http://doi.acm.org/10.1145/1151433.1151444, 2004.

51
 - M. Scotto, A. Sillitti, G. Succi, T. Vernazza, A non-invasive approach
to product metrics collection, Journal of Systems Architecture 52 (11) (2006)
1210 668–675, agile Methodologies for Software Production.

- M. Wilhelm, S. Diehl, Dependency Viewer - A Tool for Visualizing Pack-

age Design Quality Metrics, in: 3rd IEEE International Workshop on Visual-
izing Software for Understanding and Analysis, 1–2, doi: 1305 10.1109/VIS-
SOF.2005.1684321, 2005.

1215 - J. Alghamdi, R. Rufai, S. Khan, OOMeter: A Software Quality Assurance

Tool, in: Ninth European Conference on Software Maintenance and Reengineer-
ing, ISSN 1534-5351, 190–191, doi:10.1109/CSMR.2005.44, 2005.

- B. Alshammari, C. Fidge, D. Corney, An Automated Tool for Assessing

Security-Critical Designs and Programs, in: WIAR 2012; National Workshop
1220 on Information Assurance Research, 1–10, 2012.

- M. R. Girgis, T. M. Mahmoud, R. R. Nour, UML class diagram met-

rics tool, in: 2009 International Conference on Computer Engineering Systems,
423–428, doi:10.1109/ICCES.2009.5383226, 2009.

- J. Alghamdi, M. Elish, M. Ahmed, A tool for measuring inheritance cou-

1225 pling in object-oriented systems, Information Sciences 140 (3) (2002) 217–227,
ISSN 0020-0255, doi:https://doi.org/10.1016/S0020-0255(01)00172-4,
URL http://www.sciencedirect.com/science/article/pii/S0020025501001724, soft-
ware Engineering: Systems and Tools.

- V. Bidve, P. Sarasu, Tool for Measuring Coupling in Object- Oriented Java

1230 Software 8 (2016) 812–820.

- J. Offutt, A. Abdurazik, S. R. Schach, Quantitatively measuring object ori-

ented couplings, Software Quality Journal 16 (4) (2008) 489–512, ISSN 1573–1367,
doi:10.1007/s11219-008-9051-x, URL https://doi.org/10.1007/s11219-008-9051-
x.

1235 - P. Rosner, S. Viswanathan, Visualization of Coupling and Programming to

Interface for Object-Oriented Systems, in: 2008 12th International Conference

52
 Information Visualisation, ISSN 1550-6037, 575–581, 1335
doi:10.1109/IV.2008.96, 2008.

- S. Sarvari, P. Singh, G. Sikka, Efficient and Scalable Collection of Dy-

1240 namic Metrics Using MapReduce, Asia-Pacific Software Engineering Conference
(APSEC), 2015 (2015) 127–134.

- A. Dogra, H. Singh, P. Singh, Execution Trace Streaming Based Real Time

Collection of Dynamic Metrics Using PaaS, 8th Workshop on Emerging Trends
in Software Metrics (WETSoM) (2017) 43–48.

1245 - P. Singh, H. Singh, DynaMetrics: a runtime metric-based analysis tool for

object-oriented software systems, ACM SIGSOFT Software Engineering Notes
33 (2008) 1–6.

- T. Zimmermann, P. Weisgerber, S. Diehl, A. Zeller, Mining Version His-

tories to Guide Software Changes, in: Proceedings of the 26th International
1250 Conference on Software Engineering, ICSE ’04, IEEE Computer Society, Wash-
ington, DC, USA, ISBN 0-7695-2163-0, 563–572, 2004.

- M. D’Ambros, M. Lanza, Reverse Engineering with Logical Coupling,

in: 2006 13th Working Conference on Reverse Engineering, ISSN 1095-1350,
189–198, doi:10.1109/WCRE.2006.51, 2006.

1255 - M. D’Ambros, M. Lanza, M. Lungu, Visualizing Co-Change Information

with the Evolution Radar, IEEE Transactions on Software Engineering 35 (2009)
720–735.

- M. D’Ambros, M. Lanza, M. Lungu, The Evolution Radar: Visualizing

Integrated Logical Coupling Information, in: Proceedings of the 2006 Interna-
1260 tional Workshop on Mining Software Repositories, MSR ’06, ACM, New York,
NY, USA, ISBN 1-59593-397-2, 26–32, doi:10.1145/1137983.1137992,
URL http://doi.acm.org/10.1145/1137983.1137992, 2006.

- A. Ying, G. Murphy, R. Ng, M. Chu-Carroll, Predicting Source Code

Changes by Mining Change History, IEEE Transcription Software Engineering
1265 30 (9) (2004) 574–586, ISSN 0098-5589, doi:10.1109/TSE.2004.52.

53
 - N. Hanakawa, Visualization for Software Evolution Based on Logical Cou-
pling and Module Coupling, in: 14th Asia-Pacific Software Engineering 1365
Conference (APSEC’07), ISSN 1530-1362, 214–221,
doi:10.1109/ASPEC.2007.36, 2007.

1270 - J. Garcia, F. Garcia, R. Therón, Modelling Relationships among Classes

as Semantic Coupling in OWL Ontologies, 2011.

- E. Figueiredo, A. Garcia, C. Sant’Anna, U. Kulesza, C. Lucena, Assess-

ing aspect-oriented artifacts: Towards a tool-supported quantitative method,
in: Proc. of the 9th ECOOP Workshop on Quantitative Approaches in OO
1275 Software, 2005.

- E. Figueiredo, A. Garcia, C. Lucena, AJATO: an AspectJ Assessment

Tool, Proceedings of European Conference on Object Oriented Programming
(ECOOP Demo).

- J. Zhao, S. Zhang, H. Shen, An Empirical Study of Maintainability in

1280 Aspect-Oriented System Evolution Using Coupling Metrics, in: 2008 2nd IFIP/IEEE
International Symposium on Theoretical Aspects of SoftwareEngineering(TASE),
vol. 00, 233–236, doi:10.1109/TASE.2008.17,
doi.ieeecomputersociety.org/10.1109/TASE.2008.17, 2008.

- A. S. Núñez-Varela, H. G. Pérez-González, F. E. Martínez-Pérez, J. Cuevas-

1285 Tello, Building a User Oriented Application for Generic Source Code Met-
rics Extraction from a Metrics Framework, in: 2016 4th International Con-
ference in Software Engineering Research and Innovation (CONISOFT), 27–32,
doi:10.1109/CONISOFT.2016.13, 2016.

- P.Weißgerber, L. V. Klenze, M. Burch, S. Diehl, Exploring Evolutionary

1290 Coupling in Eclipse, 2005.

- T. Zimmermann, V. Dallmeier, K. Halachev, A. Zeller, eROSE: guiding

programmers in eclipse, in: OOPSLA Companion, 2005.

- A. Tahir, S. MacDonell, A systematic mapping study on dynamic metrics

and software quality, 28th IEEE International Conference on Software Mainte-
1295 nance (ICSM) (2012) 326–335.

54
 - R. Harrison, S. Counsell, R. Nithi, Coupling metrics for object-oriented de-
sign, in: Proceedings Fifth International Software Metrics Symposium. Metrics
(Cat. No.98TB100262), 150–157, doi:10.1109/METRIC. 1998.731240, 1998.
- P. Joshi, R. K. Joshi, Microscopic coupling metrics for refactoring, in: Con-
1300 ference on Software Maintenance and Reengineering (CSMR’06), ISSN 1534–5351,
8 pp.–152, doi:10.1109/CSMR.2006.32, 2006.

- M. English, T. Cahill, J. Buckley, Construct specific coupling measure-

ment for C++ software, Computer Languages, Systems and Structures 38 (4)
(2012) 300–319, ISSN 1477-8424, doi:https://doi.org/10.1016/j.cl.2012.06.002,
1305 URL http://www.sciencedirect.com/science/article/ pii/S1477842412000243.

- A. Tripathi, D. S. Kushwaha, A metric for package level coupling, CSI

Transactions on ICT 2 (4) (2015) 217–233, ISSN 2277-9086, doi:10.1007/s40012-
015-0061-0, URL https://doi.org/10.1007/s40012-015-0061-0.

- C. Rajaraman, M. R. Lyu, Some Coupling Measures for C++ Programs,

1310 in: Proc. TOOLS USA 92 Conference, 225–234, 1992.

- Y. Hassoun, S. Counsell, R. Johnson, Dynamic coupling metric: proof of

concept, IEE Proceedings - Software 152 (6) (2005) 273–279, ISSN 1462-5970,
doi:10.1049/ip-sen:20045067.

- H. Washizaki, T. Nakagawa, Y. Saito, Y. Fukazawa, A Coupling-based

1315 Complexity Metric for Remote Component-based Software Systems Toward
Maintainability Estimation, in: 2006 13th Asia Pacific Software Engineering
Conference (APSEC’06), ISSN 1530-1362, 79–86,
doi:10.1109/ APSEC.2006.3, 2006.

- E. Tempero, P. Ralph, A Model for Defining Coupling Metrics, in: 23rd

1320 Asia-Pacific Software Engineering Conference (APSEC), ISSN 1530-1362, 145–152,
doi:10.1109/APSEC.2016.030, 2016.

- S. Eski, F. Buzluca, An Empirical Study on Object-Oriented Metrics and

Software Evolution in Order to Reduce Testing Costs by Predicting Change-
Prone Classes, in: 2011 IEEE Fourth International Conference on Software

55
1325 Testing, Verification and Validation Workshops, 566–571, 2011.

- M. O. Elish, M. Al-Rahman Al-Khiaty, A suite of metrics for quantifying

historical changes to predict future change–prone classes in object –oriented
software, in: J. Softw.: Evol. and Proc., 407–437, 2013.
- C. Pautasso, E. Wilde, Why is the Web Loosely Coupled? A Multi-Faceted
1330 Metric for Service Design, in proceedings of the 18th international conference
on World wide web 2009, 911–920, 2009

References

[1] M. M. Lehman, Programs, life cycles, and laws of software evolution,

Proceedings of the IEEE 68 (9) (1980) 1060–1076.

1335 [2] D. Coleman, B. Lowther, P. Oman, The application of software maintain-

ability models in industrial software systems, Journal of Systems and Soft-
ware 29 (1) (1995) 3 – 16, ISSN 0164-1212, doi:https://doi.org/10.1016/
0164-1212(94)00125-7, URL http://www.sciencedirect.com/science/
article/pii/0164121294001257, oregon Metric Workshop.

1340 [3] M. Riaz, E. Mendes, E. Tempero, A Systematic Review of Software

Maintainability Prediction and Metrics, in: Proceedings of the 2009 3rd
International Symposium on Empirical Software Engineering and Mea-
surement, ESEM ’09, IEEE Computer Society, Washington, DC, USA,
ISBN 978-1-4244-4842-5, 367–377, doi:10.1109/ESEM.2009.5314233, URL
1345 http://dx.doi.org/10.1109/ESEM.2009.5314233, 2009.

[4] A. L. Goel, Software Reliability Models: Assumptions, Limitations, and

Applicability, IEEE Transactions on Software Engineering SE-11 (12)
(1985) 1411–1423, ISSN 0098-5589, doi:10.1109/TSE.1985.232177.

[5] A. Offutt, M. Harrold, P. Kolte, A software metric system for module

1350 coupling, Journal of Systems and Software 20 (1993) 295–308.

56
 [6] N. Fenton, J. Bieman, Software Metrics: A rigorous and practical ap-
proach, CRC Press, 2014.

[7] R. Robbes, D. Pollet, M. Lanza, Logical Coupling Based on Fine-Grained

Change Information, 15th Working Conference on Reverse Engineering,
1355 WCRE ’08 (2008) 42–46.

[8] S. Chidamber, C. Kemerer, Towards a metrics suite for object oriented

design, Conference Proceedings on Object-oriented programming systems,
languages, and applications (OOPSLA ’91) (1991) 197–211.

[9] G. Bavota, B. Dit, R. Oliveto, M. Di Penta, D. Poshyvanyk, A. De Lucia,

1360 An Empirical Study Of The Developers’ Perception Of Software Coupling,
Proceedings of the 2013 International Conference on Software Engineering
(ICSE ’13) (2013) 692–701.

[10] E. Arisholm, L. Briand, A. Foyen, Dynamic Coupling Measurement For

Object-oriented Software, IEEE Transactions on Software Engineering
1365 30 (8) (2004) 491–506.

[11] D. Poshyvanyk, A. Marcus, The Conceptual Coupling Metrics for Object-

Oriented Systems, ICSM ’06 Proceedings of the 22nd IEEE International
Conference on Software Maintenance (2006) 469–478.

[12] S. Kirbas, T. Hall, A. Sen, Evolutionary coupling measurement: Making

1370 sense of the current chaos, Science of Computer Programming 135 (2017)
4–19.

[13] A. Nicolaescu, H. Lichter, Y. Xu, Evolution of Object Oriented Coupling

Metrics: A sampling of 25 years of research, IEEE/ACM 2nd International
Workshop on Software Architecture and Metrics (SAM) (2015) 48–54.

1375 [14] B. Kitchenham, Procedures for Performing Systematic Reviews, 2004.

[15] C. Wohlin, Guidelines for Snowballing In Systematic Literature Studies

and a Replication In Software Engineering, Proceedings of the 18th Inter-

57
 national Conference on Evaluation and Assessment in Software Engineer-
ing (EASE 14) (2014) 38:1–38:10.

1380 [16] L. Briand, P. Devanbu, W. Melo, An Investigation into Coupling Measures

for C++, Proceeding of the 1997 International Conference on Software
Engineering (1997) 412–421.

[17] D. Poshyvanyk, A. Marcus, R. Ferenc, T. Gyimóthy, Using information

retrieval based coupling measures for impact analysis, Empirical Software
1385 Engineering 14 (1) (2009) 5–32.

[18] J. Alghamdi, Measuring Software Coupling, in: Proceedings of the

6th WSEAS International Conference on Software Engineering, Parallel
and Distributed Systems, SEPADS’07, World Scientific and Engineering
Academy and Society (WSEAS), Stevens Point, Wisconsin, USA, ISBN
1390 978-960-8457-59-1, 6–12, URL http://dl.acm.org/citation.cfm?id=
1353801.1353803, 2007.

[19] G. Myers, Reliable software through composite design, Mason and Lip-
scomb, 1975.

[20] S. Schach, Object-Oriented and Classical Software Engineering, 8th edi-

1395 tion, McGraw-Hill, 2011.

[21] S. Henry, D. Kafura, Software Structure Metrics Based on Information

Flow, IEEE Transactions on Software Engineering SE-7 (5) (1981) 510–
518.

[22] E. Allen, T. Khoshgoftaar, Y. Chen, Measuring coupling and cohesion of

1400 software modules: an information-theory approach, Proceedings of the 7th
International Software Metrics Symposium, 2011. METRICS 2001 (2001)
124–134.

[23] E. B. Allen, S. Gottipati, R. Govindarajan, Measuring size, complexity,

and coupling of hypergraph abstractions of software: An information-
1405 theory approach, Software Quality Journal 15 (2) (2007) 179–212, ISSN

58
 1573-1367, doi:10.1007/s11219-006-9010-3, URL https://doi.org/10.
1007/s11219-006-9010-3.

[24] J. Eder, G. Kappel, M. Schrefl, Coupling and Cohesion in Object-Oriented

Systems, 1992.

1410 [25] S. Chidamber, C. Kemerer, A metrics suite for object oriented design,
IEEE Transactions on Software Engineering 20 (6) (1994) 476 – 493.

[26] M. Hitz, B. Montazeri, Measuring Coupling and Cohesion In Object-

Oriented Systems, Proceedings of International Symposium on Applied
Corporate Computing 35 (1995) 25–27.

1415 [27] L. Briand, S. Morasca, V. R. Basili, Property-based software engineering

measurement, IEEE Transactions on Software Engineering 22 (1) (1996)
68–86, ISSN 0098-5589.

[28] L. Briand, J. Daly, J. Wust, A unified framework for coupling measure-

ment in object-oriented systems, IEEE Transactions on Software Engi-
1420 neering 25 (1999) 91–121.

[29] W. Li, S. Henry, Object-Oriented Metrics that Predict Maintainability,

Journal of Systems and Software 23 (1993) 111–122.

[30] R. Martin, Object oriented design quality metrics: an analysis of depen-

dencies, vol. 2, 2006.

1425 [31] F. Abreu, R. Esteves, M. Goula̋o, Toward the Design Quality Evaluation
of Object-Oriented Software, 1995.

[32] F. Abreau, R. Carapuça, Object-Oriented Software Engineering: Measur-

ing and Controlling the Development Process, in: Proceedings of the 4th
International Conference on Software Quality, 1994.

1430 [33] Y. Lee, B. Liang, S. Wu, F. Wang, Measuring the Coupling and Cohesion
of an Object-Oriented Program Based On Information Flow, in: Proceed-
ings of the International Conference on Software Quality, 1995.

59
 [34] W. Li, Another Metric Suite for Object-oriented Programming, Journal
of System and Software 44 (2) (1998) 155–162, ISSN 0164-1212.

1435 [35] J. Rilling, W. J. Meng, O. Ormandjieva, Context driven slicing based cou-
pling measures, in: 20th IEEE International Conference on Software Main-
tenance, 2004. Proceedings., ISSN 1063-6773, 532–, doi:10.1109/ICSM.
2004.1357874, 2004.

[36] M. English, J. Buckley, T. Cahill, Fine-Grained Software Metrics in Prac-

1440 tice, in: First International Symposium on Empirical Software Engi-
neering and Measurement (ESEM 2007), ISSN 1949-3770, 295–304, doi:
10.1109/ESEM.2007.32, 2007.

[37] H. Li, A Novel Coupling Metric for Object-Oriented Software Systems,

in: 2008 IEEE International Symposium on Knowledge Acquisition and
1445 Modeling Workshop, 609–612, doi:10.1109/KAMW.2008.4810562, 2008.

[38] H. Y. Yang, E. Tempero, R. Berrigan, Detecting indirect coupling, in:

2005 Australian Software Engineering Conference, ISSN 1530-0803, 212–
221, doi:10.1109/ASWEC.2005.22, 2005.

[39] H. Y. Yang, E. Tempero, Indirect Coupling As a Criteria for Modularity,

1450 in: First International Workshop on Assessment of Contemporary Mod-
ularization Techniques (ACoM ’07), 10–10, doi:10.1109/ACOM.2007.5,
2007.

[40] S. Almugrin, W. Albattah, A. Melton, Using indirect coupling metrics to

predict package maintainability and testability, Journal of Systems and
1455 Software 121 (2016) 298 – 310, ISSN 0164-1212, doi:https://doi.org/10.
1016/j.jss.2016.02.024, URL http://www.sciencedirect.com/science/
article/pii/S016412121600056X.

[41] M. Tang, M. Kao, M. Chen, An empirical study on object-oriented met-

rics, in: Proceedings Sixth International Software Metrics Symposium
1460 (Cat. No.PR00403), 242–249, 1999.

60
 [42] G. Gui, P. D. Scott, New Coupling and Cohesion Metrics for Evaluation
of Software Component Reusability, in: 2008 The 9th International Con-
ference for Young Computer Scientists, 1181–1186, doi:10.1109/ICYCS.
2008.270, 2008.

1465 [43] A. Aloysius, L. Arockiam, Coupling Complexity Metric: A Cognitive Ap-

proach, International Journal of Information Technology and Computer
Science 4 (2012) 29–35.

[44] A. Mitchell, J. Power, An empirical investigation into the dimensions of

run-time coupling in Java programs, Proceedings of the 3rd international
1470 symposium on Principles and practice of programming in Java (2004) 9–
14.

[45] R. Geetika, P. Singh, Dynamic Coupling Metrics for Object Oriented Soft-
ware Systems: A Survey, SIGSOFT Softw. Eng. Notes 39 (2) (2014) 1–
8, ISSN 0163-5948, doi:10.1145/2579281.2579296, URL http://doi.acm.
1475 org/10.1145/2579281.2579296.

[46] E. Arisholm, Dynamic coupling measures for object-oriented software,

Proceeding of the 8th IEEE Symposium on Software Metrics (2002) 33–42.

[47] A. Mitchell, J. Power, Using object-level run-time metrics to study cou-

pling between objects, Proceedings of the 2005 ACM symposium on Ap-
1480 plied computing (SAC ’05) (2005) 1456–1452.

[48] S. Yacoub, H. Ammar, T. Robinson, Dynamic metrics for object oriented

design, Proceedings of the 6th Software Metrics Symposium (1999) 50–61.

[49] A. Zaidman, S. Demeyer, Analyzing large event traces with the help of
coupling metrics, in: Proceedings of the Fourth International Workshop
1485 on OO Reengineering, 2004.

[50] Y. Hassoun, R. Johnson, S. Counsell, A dynamic runtime coupling for

meta-level architectures, Proceedings of the 8th European Conference on
Software Maintenance and Reengineering, CSMR 2004 (2004) 339–346.

61
 [51] R. Gunnalan, M. Shereshevsky, H. H. Ammar, Pseudo dynamic metrics
1490 [software metrics], in: The 3rd ACS/IEEE International Conference on-
Computer Systems and Applications, 2005., ISSN 2161-5322, 117–, doi:
10.1109/AICCSA.2005.1387106, 2005.

[52] Y. Liu, A. Milanova, Static Analysis for Dynamic Coupling Measures,

in: Proceedings of the 2006 Conference of the Center for Advanced Stud-
1495 ies on Collaborative Research, CASCON ’06, IBM Corp., Riverton, NJ,
USA, doi:10.1145/1188966.1188980, URL http://dx.doi.org/10.1145/
1188966.1188980, 2006.

[53] J. Cleland-Huang, C. Chang, H. Kim, A. Balakrishnan, D. Nassar, H. Am-

mar, A. Mili, Requirements-based dynamic metrics in object-oriented sys-
1500 tems, 5th IEEE International Symposium on Requirements Engineering
(2001) 212–219.

[54] H. Abualese, P. Sumari, T. Al-Rousan, M. R. Al-Mousa, Utility classes

detection metrics for execution trace analysis, in: 2017 8th Interna-
tional Conference on Information Technology (ICIT), 469–474, doi:10.
1505 1109/ICITECH.2017.8080044, 2017.

[55] S. Deerwester, S. Dumais, G. Furnas, T. Landauer, R. Harshman, In-

dexing by Latent Semantic Analysis, Journal of the American Society for
Information Science 41 (1990) 391–407.

[56] B. Újházi, R. Ferenc, D. Poshyvanyk, T. Gyimóthy, New conceptual cou-

1510 pling and cohesion metrics for object-oriented systems, 10th IEEE Inter-
national Working Conference on Source Code Analysis and Manipulation
(SCAM’10) (2010) 33–42.

[57] M. Gethers, D. Poshyvanyk, Using Relational Topic Models to capture

coupling among classes in object-oriented software systems, 10th IEEE In-
1515 ternational Working Conference on Software Maintenance (ICSM) (2010)
1–10.

62
 [58] M. Revelle, M. Gethers, D. Poshyvanyk, Using structural and textual
information to capture feature coupling in object-oriented software, Em-
pirical Software Engineering 16 (2011) 773–811.

1520 [59] D. Poshyvanyk, Y. Guéhéneuc, A. Marcus, G. Antoniol, V. Rajlich, Fea-

ture Location Using Probabilistic Ranking of Methods Based on Execu-
tion Scenarios and Information Retrieval, IEEE Transactions on Software
Engineering 33 (2007) 420–432.

[60] H. Kagdi, M. Gethers, D. Poshyvanyk, M. L. Collard, Blending Concep-

1525 tual and Evolutionary Couplings to Support Change Impact Analysis in
Source Code, in: 2010 17th Working Conference on Reverse Engineering,
ISSN 2375-5369, 119–128, doi:10.1109/WCRE.2010.21, 2010.

[61] M. Gethers, A. Aryani, D. Poshyvanyk, Combining Conceptual and

Domain-Based Couplings to Detect Database and Code Dependencies,
1530 IEEE 12th International Working Conference on Source Code Analysis
and Manipulation (SCAM) (2012) 144–153.

[62] A. Aryani, I. Peake, M. Hamilton, Domain-based change propagation anal-

ysis: An enterprise system case study, IEEE International Conference on
Software Maintenance (ICSM) (2010) 1–9.

1535 [63] A. Aryani, F. Perin, M. Lungu, A. Mahmood, O. Nierstrasz, Can we pre-

dict depencencies using domain information?, 18th Working Conference
on Reverse Engineering (WCRE) (2011) 55–64.

[64] M. Rahman, A. Aryani, C. Roy, F. Perin, On the relationships between

domain-based coupling and code clones: an exploratory study, Proceed-
1540 ings of the 2013 International Conference on Software Engineering (2013)
1265–1268.

[65] H. Kagdi, M. Gethers, D. Poshyvanyk, Integrating conceptual and logi-

cal couplings for change impact analysis in software, Empirical Software
Engineering 18 (5) (2013) 933–969.

63
1545 [66] M. Alenezi, K. Magel, Empirical Evaluation of a New Coupling Met-
ric: Combining Structural and Semantic Coupling, International Jour-
nal of Computers and Applications 36 (1) (2014) 34–44, doi:10.2316/
Journal.202.2014.1.202-3902, URL https://www.tandfonline.com/doi/
abs/10.2316/Journal.202.2014.1.202-3902.

1550 [67] H. Gall, K. Hajek, M. Jazayeri, Detection of Logical Coupling Based on

Product Release History, Proceedings of the International Conference on
Software Maintenance, 1998 (1998) 190–198.

[68] H. Gall, M. Jazayeri, J. Krajewski, CVS Release History Data For Detect-
ing Logical Couplings, Proceedings of the 6th International Workshop on
1555 Principles of Software Evolution (2003) 13–23.

[69] A. Alali, B. Bartman, C. Newman, J. Maletic, A Preliminary Investigation

of Using Age and Distance Measures in Detection of Evolutionary Cou-
plings, 10th IEEE Working Conference on Mining Software Repositories
(MSR) (2013) 169–172.

1560 [70] M. D’Ambros, M. Lanza, R. Robbes, On the Relationship Between Change

Coupling and Software Defects, in: 2009 16th Working Conference on
Reverse Engineering, ISSN 1095-1350, 135–144, doi:10.1109/WCRE.2009.
19, 2009.

[71] L. Zou, M. Godfrey, A. Hassan, Detecting Interaction Coupling from

1565 Task Interaction Histories, 15th IEEE Internation Conference on Program
Comprehension, ICPC ’07 (2007) 135–144.

[72] F. Bantelay, M. B. Zanjani, H. Kagdi, Comparing and combining evolu-

tionary couplings from interactions and commits, in: 2013 20th Working
Conference on Reverse Engineering (WCRE), ISSN 1095-1350, 311–320,
1570 doi:10.1109/WCRE.2013.6671306, 2013.

[73] S. Kramer, H. Kaindl, Coupling and cohesion metrics for knowledge-based

64
 systems using frames and rules, ACM Transactions on Software Engineer-
ing and Methodology 13 (2004) 332–358.

[74] A. Orme, H. Tao, L. Etzkorn, Coupling metrics for ontology-based system,

1575 IEEE Software 23 (2006) 102–108.

[75] H. Jordan, R. Collier, Evaluating Agent-Oriented Programs: Towards

Multi-paradigm Metrics, International Workshop on Programming Multi-
Agent Systems (2010) 63–78.

[76] J. Garcia, F. Garcia, R. Theron, Visualizing Semantic Coupling among

1580 Entities in an OWL Ontology, Ontology, Conceptualization and Episte-
mology for Information Systems, Software Engineering and Service Sci-
ence, ONTOSE 2010 (2010) 90–106.

[77] J. García, F. García, R. Therón, Defining Coupling Metrics among Classes

in an OWL Ontology, in: N. García-Pedrajas, F. Herrera, C. Fyfe, J. M.
1585 Benítez, M. Ali (Eds.), Trends in Applied Intelligent Systems, Springer
Berlin Heidelberg, Berlin, Heidelberg, ISBN 978-3-642-13025-0, 12–17,
2010.

[78] C. Sant’Anna, A. Garcia, C. Chavez, C. Lucena, A. von Staa, On the

Reuse and Maintenance of Aspect-Oriented Software: An Assessment
1590 Framework, in: Proceedings of Brazilian Symposium on Software Engi-
neering, 19–34, 2003.

[79] M. Ceccato, P. Tonella, Measuring the Effects of Software Aspectization,

2004.

[80] H. Shen, J. Zhao, An evaluation of coupling metrics for aspect-oriented

1595 software, Tech. Rep., 2007.

[81] R. Burrows, F. C. Ferrari, A. Garcia, F. Taiani, An empirical evaluation

of coupling metrics on aspect-oriented programs, Proceedings of the 2010
ICSE Workshop on Emerging Trends in Software Metrics (WETSoM ’10)
(2010) 53–58.

65
1600 [82] M. L. Bernardi, G. A. D. Lucca, A metric model for aspects’ coupling, in:
WETSoM, 2010.

[83] B. Bennett, F. Mitropoulos, New metrics for assessing aspect coupling,

in: SoutheastCon 2016, 1–8, 2016.

[84] B. T. Bennett, Using hierarchical agglomerative clustering to locate po-

1605 tential aspect interference, in: SoutheastCon 2017, 1–8, 2017.

[85] J. Zhao, Measuring Coupling in Aspect-Oriented Systems, in: Information

Processing Society of Japan (IPSJ), 14–16, 2004.

[86] T. Tonelli Bartolomei, A. Garcia, C. Sant’Anna, E. Figueiredo, Towards

a Unified Coupling Framework for Measuring Aspect-Oriented Programs,
1610 in: 3rd International Workshop on Software Quality Assurance (SOQUA),
ACM Press, ACM Press, New York, NY, USA, ISBN 1-59593-584-3,
46–53, doi:http://doi.acm.org/10.1145/1188895.1188907, 2006.

[87] A. Kumar, R. Kumar, P. S. Grover, Generalized Coupling Measure for

Aspect-oriented Systems, SIGSOFT Softw. Eng. Notes 34 (3) (2009) 1–
1615 6, ISSN 0163-5948, doi:10.1145/1527202.1527209, URL http://doi.acm.
org/10.1145/1527202.1527209.

[88] K. Qian, J. Liu, F. Tsui, Decoupling Metrics for Services Composi-

tion, in: 5th IEEE/ACIS International Conference on Computer and
Information Science and 1st IEEE/ACIS International Workshop on
1620 Component-Based Software Engineering,Software Architecture and Reuse
(ICIS-COMSAR’06), 44–47, 2006.

[89] R. Sindhgatta, B. Sengupta, K. Ponnalagu, Measuring the Quality of

Service Oriented Design, Springer Berlin Heidelberg, Berlin, Heidelberg,
485–499, 2009.

1625 [90] A. A. M. Elhag, R. Mohamad, Metrics for evaluating the quality of service-
oriented design, in: 2014 8th. Malaysian Software Engineering Conference
(MySEC), 154–159, doi:10.1109/MySec.2014.6986006, 2014.

66
 [91] P. Quynh, H. Thang, Dynamic Coupling Metrics for Service –Oriented
Software, International Journal of Computer, Electrical, Automation,
1630 Control and Information Engineering 3 (2009) 795 – 800.

[92] X. Wang, Metrics for Evaluating Coupling and Service Granularity in

Service Oriented Architecture, in: 2009 International Conference on In-
formation Engineering and Computer Science, ISSN 2156-7379, 1–4, doi:
10.1109/ICIECS.2009.5362767, 2009.

1635 [93] S. Alahmari, E. Zaluska, D. C. D. Roure, A Metrics Framework for Eval-

uating SOA Service Granularity, in: 2011 IEEE International Conference
on Services Computing, 512–519, doi:10.1109/SCC.2011.98, 2011.

[94] T. Karhikeyan, J. Geetha, A metrics suite and fuzzy model for measuring
coupling in Service Oriented Architecture, in: 2012 International Confer-
1640 ence on Recent Advances in Computing and Software Systems, 254–259,
doi:10.1109/RACSS.2012.6212677, 2012.

[95] M. Perepletchikov, C. Ryan, K. Frampton, Z. Tari, Coupling Metrics

for Predicting Maintainability in Service-Oriented Designs, in: 2007 Aus-
tralian Software Engineering Conference (ASWEC’07), ISSN 1530-0803,
1645 329–340, doi:10.1109/ASWEC.2007.17, 2007.

[96] T. Erl, SOA: Principles of Service Design, The Prentice Hall Service Tech-
nology Series from Thomas Erl, Pearson Education, ISBN 9780132715836,
2007.

[97] C. Pautasso, E. Wilde, Why is the Web Loosely Coupled?: A Multi-

1650 faceted Metric for Service Design, in: Proceedings of the 18th Interna-
tional Conference on World Wide Web, WWW ’09, ACM, New York, NY,
USA, ISBN 978-1-60558-487-4, 911–920, doi:10.1145/1526709.1526832,
URL http://doi.acm.org/10.1145/1526709.1526832, 2009.

[98] A. Kazemi, A. Azizkandi, A. Rostampour, H. Haghihi, P. Jamshidi,

1655 F. Shams, Measuring the Conceptual Coupling of Services Using Latent

67
 Semantic Indexing, IEEE International Conference on Service Computing
(SCC) (2011) 504–511.

[99] B. Alshammari, C. Fidge, D. Corney, Security Metrics for Object-Oriented

Designs, 21st Australian Software Engineering Conference (ASWEC)
1660 (2010) 55–64.

[100] J. Jrjens, Secure Systems Development with UML, Springer-Verlag,

Berlin, Heidelberg, ISBN 3642056350, 9783642056352, 2010.

[101] J. Barnes, High Integrity Software: The SPARK Approach to Safety and
Security, Addison-Wesley Longman Publishing Co., Inc., Boston, MA,
1665 USA, ISBN 0321136160, 2003.

[102] S. Kamble, X. Jin, N. Niu, M. Simon, A Novel Coupling Pattern in Com-

putational Science and Engineering Software, in: 2017 IEEE/ACM 12th
International Workshop on Software Engineering for Science (SE4Science),
9–12, doi:10.1109/SE4Science.2017.10, 2017.

1670 [103] M. Ahmed, M. Shoaib, Novel Design Metrics to Measure Real Time En-
vironment Application Design, Journal of American Science 7 (2011) 222.

[104] D. Spinellis, Tool writing: a forgotten art? (software tools), IEEE Soft-
ware 22 (4) (2005) 9–11.

[105] S. Husein, A. Oxley, A Coupling and Cohesion Metrics Suite for Object-
1675 Oriented Software, in: Proceedings of the 2009 International Conference
on Computer Technology and Development - Volume 01, ICCTD ’09,
IEEE Computer Society, Washington, DC, USA, ISBN 978-0-7695-3892-1,
421–425, 2009.

[106] M. Eichberg, D. Germanus, M. Mezini, L. Mrokon, T. Schafer, QScope: an

1680 open, extensible framework for measuring software projects, in: Confer-
ence on Software Maintenance and Reengineering (CSMR’06), 10 pp.–122,
2006.

68
 [107] N. Kayarvizhy, S. Kanmani, An Automated Tool for Computing Object
Oriented Metrics Using XML, Springer Berlin Heidelberg, Berlin, Heidel-
1685 berg, 69–79, 2011.

[108] M. Scotto, A. Sillitti, G. Succi, T. Vernazza, A Relational Approach

to Software Metrics, in: Proceedings of the 2004 ACM Symposium on
Applied Computing, SAC ’04, ACM, New York, NY, USA, ISBN 1-
58113-812-1, 1536–1540, doi:10.1145/967900.968207, URL http://doi.
1690 acm.org/10.1145/967900.968207, 2004.

[109] M. Scotto, A. Sillitti, G. Succi, T. Vernazza, Non-invasive Product Metrics

Collection: An Architecture, in: Proceedings of the 2004 Workshop on
Quantitative Techniques for Software Agile Process, QUTE-SWAP ’04,
ACM, New York, NY, USA, 76–78, doi:10.1145/1151433.1151444, URL
1695 http://doi.acm.org/10.1145/1151433.1151444, 2004.

[110] M. Scotto, A. Sillitti, G. Succi, T. Vernazza, A non-invasive approach to

product metrics collection, Journal of Systems Architecture 52 (11) (2006)
668 – 675, agile Methodologies for Software Production.

[111] M. Wilhelm, S. Diehl, Dependency Viewer - A Tool for Visualizing

1700 Package Design Quality Metrics, in: 3rd IEEE International Work-
shop on Visualizing Software for Understanding and Analysis, 1–2, doi:
10.1109/VISSOF.2005.1684321, 2005.

[112] J. Alghamdi, R. Rufai, S. Khan, OOMeter: A Software Quality Assur-

ance Tool, in: Ninth European Conference on Software Maintenance and
1705 Reengineering, ISSN 1534-5351, 190–191, doi:10.1109/CSMR.2005.44,
2005.

[113] M. Barnett, C. Bird, J. Brunet, S. Lahiri, Helping Developers Help Them-

selves: Automatic Decomposition Of Code Review Changesets, Proceed-
ings of the 37th International Conference on Software Engineering 1 (1)
1710 (2015) 134–144.

69
 [114] B. Alshammari, C. Fidge, D. Corney, An Automated Tool for Assessing
Security-Critical Designs and Programs, in: WIAR 2012; National Work-
shop on Information Assurance Research, 1–10, 2012.

[115] M. R. Girgis, T. M. Mahmoud, R. R. Nour, UML class diagram metrics

1715 tool, in: 2009 International Conference on Computer Engineering Sys-
tems, 423–428, doi:10.1109/ICCES.2009.5383226, 2009.

[116] J. AlGhamdi, M. Elish, M. Ahmed, A tool for measuring in-

heritance coupling in object-oriented systems, Information Sciences
140 (3) (2002) 217 – 227, ISSN 0020-0255, doi:https://doi.org/10.
1720 1016/S0020-0255(01)00172-4, URL http://www.sciencedirect.com/
science/article/pii/S0020025501001724, software Engineering: Sys-
tems and Tools.

[117] V. Bidve, P. Sarasu, Tool for Measuring Coupling in Object- Oriented

Java Software 8 (2016) 812–820.

1725 [118] J. Offutt, A. Abdurazik, S. R. Schach, Quantitatively measuring object-

oriented couplings, Software Quality Journal 16 (4) (2008) 489–512, ISSN
1573-1367, doi:10.1007/s11219-008-9051-x, URL https://doi.org/10.
1007/s11219-008-9051-x.

[119] P. Rosner, S. Viswanathan, Visualization of Coupling and Program-

1730 ming to Interface for Object-Oriented Systems, in: 2008 12th Interna-
tional Conference Information Visualisation, ISSN 1550-6037, 575–581,
doi:10.1109/IV.2008.96, 2008.

[120] S. Sarvari, P. Singh, G. Sikka, Efficient and Scalable Collection of Dynamic

Metrics Using MapReduce, Asia-Pacific Software Engineering Conference
1735 (APSEC), 2015 (2015) 127–134.

[121] A. Dogra, H. Singh, P. Singh, Execution Trace Streaming Based Real Time
Collection of Dynamic Metrics Using PaaS, 8th Workshop on Emerging
Trends in Software Metrics (WETSoM) (2017) 43–48.

70
 [122] P. Singh, H. Singh, DynaMetrics: a runtime metric-based analysis tool for
1740 object-oriented software systems, ACM SIGSOFT Software Engineering
Notes 33 (2008) 1–6.

[123] T. Zimmermann, P. Weisgerber, S. Diehl, A. Zeller, Mining Version Histo-

ries to Guide Software Changes, in: Proceedings of the 26th International
Conference on Software Engineering, ICSE ’04, IEEE Computer Society,
1745 Washington, DC, USA, ISBN 0-7695-2163-0, 563–572, 2004.

[124] M. D’Ambros, M. Lanza, Reverse Engineering with Logical Coupling, in:

2006 13th Working Conference on Reverse Engineering, ISSN 1095-1350,
189–198, doi:10.1109/WCRE.2006.51, 2006.

[125] M. D’Ambros, M. Lanza, M. Lungu, Visualizing Co-Change Information

1750 with the Evolution Radar, IEEE Transactions on Software Engineering 35
(2009) 720–735.

[126] M. D’Ambros, M. Lanza, M. Lungu, The Evolution Radar: Visualizing

Integrated Logical Coupling Information, in: Proceedings of the 2006 In-
ternational Workshop on Mining Software Repositories, MSR ’06, ACM,
1755 New York, NY, USA, ISBN 1-59593-397-2, 26–32, doi:10.1145/1137983.
1137992, URL http://doi.acm.org/10.1145/1137983.1137992, 2006.

[127] A. Ying, G. Murphy, R. Ng, M. Chu-Carroll, Predicting Source Code

Changes by Mining Change History, IEEE Transcription Software Engi-
neering 30 (9) (2004) 574–586, ISSN 0098-5589, doi:10.1109/TSE.2004.52.

1760 [128] N. Hanakawa, Visualization for Software Evolution Based on Logical Cou-
pling and Module Coupling, in: 14th Asia-Pacific Software Engineering
Conference (APSEC’07), ISSN 1530-1362, 214–221, doi:10.1109/ASPEC.
2007.36, 2007.

[129] J. Garcia, F. Garcia, R. Therón, Modelling Relationships among Classes

1765 as Semantic Coupling in OWL Ontologies, 2011.

71
 [130] E. Figueiredo, A. Garcia, C. Sant’Anna, U. Kulesza, C. Lucena, Assessing
aspect-oriented artifacts: Towards a tool-supported quantitative method,
in: Proc. of the 9th ECOOP Workshop on Quantitative Approaches in
OO Software, 2005.

1770 [131] E. Figueiredo, A. Garcia, C. Lucena, AJATO: an AspectJ Assessment

Tool, Proceedings of European Conference on Object Oriented Program-
ming (ECOOP Demo) .

[132] J. Zhao, S. Zhang, H. Shen, An Empirical Study of Maintainability in

Aspect-Oriented System Evolution Using Coupling Metrics, in: 2008 2nd
1775 IFIP/IEEE International Symposium on Theoretical Aspects of Software
Engineering(TASE), vol. 00, 233–236, doi:10.1109/TASE.2008.17, URL
doi.ieeecomputersociety.org/10.1109/TASE.2008.17, 2008.

[133] A. S. Núñez-Varela, H. G. Pérez-González, F. E. Martínez-Pérez,

J. Cuevas-Tello, Building a User Oriented Application for Generic Source
1780 Code Metrics Extraction from a Metrics Framework, in: 2016 4th In-
ternational Conference in Software Engineering Research and Innovation
(CONISOFT), 27–32, doi:10.1109/CONISOFT.2016.13, 2016.

[134] P. Weißgerber, L. V. Klenze, M. Burch, S. Diehl, Exploring Evolutionary

Coupling in Eclipse, 2005.

1785 [135] T. Zimmermann, V. Dallmeier, K. Halachev, A. Zeller, eROSE: guiding

programmers in eclipse, in: OOPSLA Companion, 2005.

[136] A. Tahir, S. MacDonell, A systematic mapping study on dynamic metrics

and software quality, 28th IEEE International Conference on Software
Maintenance (ICSM) (2012) 326–335.

1790 [137] A. Sarimbekov, A. Sewe, W. Binder, P. Moret, M. Mezini, JP2: Call-site

aware calling context profiling for the Java Virtual Machine, Science of
Computer Programming 79 (Supplement C) (2014) 146–157.

72
 [138] R. Harrison, S. Counsell, R. Nithi, Coupling metrics for object-oriented
design, in: Proceedings Fifth International Software Metrics Sympo-
1795 sium. Metrics (Cat. No.98TB100262), 150–157, doi:10.1109/METRIC.
1998.731240, 1998.

[139] P. Joshi, R. K. Joshi, Microscopic coupling metrics for refactoring, in:

Conference on Software Maintenance and Reengineering (CSMR’06),
ISSN 1534-5351, 8 pp.–152, doi:10.1109/CSMR.2006.32, 2006.

1800 [140] M. English, T. Cahill, J. Buckley, Construct specific coupling measure-

ment for C++ software, Computer Languages, Systems and Structures
38 (4) (2012) 300 – 319, ISSN 1477-8424, doi:https://doi.org/10.1016/j.cl.
2012.06.002, URL http://www.sciencedirect.com/science/article/
pii/S1477842412000243.

1805 [141] A. Tripathi, D. S. Kushwaha, A metric for package level cou-

pling, CSI Transactions on ICT 2 (4) (2015) 217–233, ISSN 2277-
9086, doi:10.1007/s40012-015-0061-0, URL https://doi.org/10.1007/
s40012-015-0061-0.

[142] C. Rajaraman, M. R. Lyu, Some Coupling Measures for C++ Programs,

1810 in: Proc. TOOLS USA 92 Conference, 225–234, 1992.

[143] V. Dixit, R. Vishwkarma, Comparison of class-level versus object-level

static and dynamic coupling and cohesion measures in object oriented pro-
gramming, 11th International Conference on Wireless and Optical Com-
munication Networks (WOCN) (2014) 1–5.

1815 [144] Y. Hassoun, S. Counsell, R. Johnson, Dynamic coupling metric: proof of

concept, IEE Proceedings - Software 152 (6) (2005) 273–279, ISSN 1462-
5970, doi:10.1049/ip-sen:20045067.

[145] H. Washizaki, T. Nakagawa, Y. Saito, Y. Fukazawa, A Coupling-based

Complexity Metric for Remote Component-based Software Systems To-
1820 ward Maintainability Estimation, in: 2006 13th Asia Pacific Software En-

73
 gineering Conference (APSEC’06), ISSN 1530-1362, 79–86, doi:10.1109/
APSEC.2006.3, 2006.

[146] E. Tempero, P. Ralph, A Model for Defining Coupling Metrics, in: 2016
23rd Asia-Pacific Software Engineering Conference (APSEC), ISSN 1530-
1825 1362, 145–152, doi:10.1109/APSEC.2016.030, 2016.

[147] B. Kitchenham, S. L. Pfleeger, N. Fenton, Towards a framework for soft-

ware measurement validation, IEEE Transactions on Software Engineering
21 (12) (1995) 929–944, ISSN 0098-5589, doi:10.1109/32.489070.

[148] E. J. Weyuker, Evaluating Software Complexity Measures, IEEE Trans.

1830 Softw. Eng. 14 (9) (1988) 1357–1365, ISSN 0098-5589, doi:10.1109/32.
6178, URL https://doi.org/10.1109/32.6178.

[149] T. Baum, K. Schneider, A. Bacchelli, On The Optimal Order Of Read-

ing Source Code Changes for Review, IEEE International Conference on
Software Maintenance and Evolution (ICSME) (2017) 329–340.

1835 [150] T. Baum, O. Liskin, K. Niklas, K. Schneider, A Faceted Classification

Scheme for Change-Based Industrial Code Review Processes, 2016 IEEE
International Conference on Software Quality, Reliability and Security
(QRS) (2016) 74–85.

[151] L. Pascarella, D. Spadini, F. Palomba, M. Bruntink, A. Bacchelli, Infor-

1840 mation Needs in Contemporary Code Review, Proceedings of the ACM
on Human-Computer Interaction - CSCW 2018 .

[152] Y. Kamei, E. Shihab, B. Adams, A. E. Hassan, A. Mockus, A. Sinha,

N. Ubayashi, A large-scale empirical study of just-in-time quality assur-
ance, IEEE Transactions on Software Engineering 39 (6) (2013) 757–773.

1845 [153] M. Tufano, F. Palomba, G. Bavota, R. Oliveto, M. Di Penta, A. De Lucia,

D. Poshyvanyk, When and why your code starts to smell bad (and whether
the smells go away), IEEE Transactions on Software Engineering 43 (11)
(2017) 1063–1088.

74
 [154] F. Palomba, G. Bavota, M. Di Penta, R. Oliveto, D. Poshyvanyk,
1850 A. De Lucia, Mining version histories for detecting code smells, IEEE
Transactions on Software Engineering 41 (5) (2015) 462–489.

[155] F. Palomba, G. Bavota, M. Di Penta, F. Fasano, R. Oliveto, A. De Lucia,

On the diffuseness and the impact on maintainability of code smells: a
large scale empirical investigation, Empirical Software Engineering 23 (3)
1855 (2018) 1188–1221.

[156] A. Maiga, N. Ali, N. Bhattacharya, A. Sabané, Y. Guéhéneuc, E. Aimeur,

SMURF: A SVM-based Incremental Anti-pattern Detection Approach, in:
2012 19th Working Conference on Reverse Engineering, 466–475, 2012.

[157] F. Khomh, S. Vaucher, Y. Guéhéneuc, H. Sahraoui, BDTEX: A GQM-

1860 based Bayesian approach for the detection of antipatterns, Journal of Sys-
tems and Software 84 (4) (2011) 559 – 572.

[158] F. Arcelli Fontana, M. Zanoni, Code smell severity classification using

machine learning techniques, Knowledge-Based Systems 128 (2017) 43 –
58.

1865 [159] D. Di Nucci, F. Palomba, D. A. Tamburri, A. Serebrenik, A. De Lucia,

Detecting code smells using machine learning techniques: are we there
yet?, in: 2018 IEEE 25th International Conference on Software Analysis,
Evolution and Reengineering (SANER), IEEE, 612–621, 2018.

[160] F. Palomba, A. Panichella, A. De Lucia, R. Oliveto, A. Zaidman, A

1870 textual-based technique for Smell Detection, in: 2016 IEEE 24th Interna-
tional Conference on Program Comprehension (ICPC), 1–10, 2016.

[161] F. Palomba, A. Panichella, A. Zaidman, R. Oliveto, A. De Lucia, The

scent of a smell: An extensive comparison between textual and structural
smells, IEEE Transactions on Software Engineering .

1875 [162] M. Fowler, K. Beck, J. Brant, W. Opdyke, D. Roberts, Refactoring: im-

proving the design of existing code, Addison-Wesley Professional, 1999.

75
 [163] F. Khomh, M. Di Penta, Y. Guéhéneuc, G. Antoniol, An exploratory
study of the impact of antipatterns on class –change and fault –prone-
ness, Empirical Software Engineering 17 (3) (2012) 243–275, ISSN 1573-
1880 7616, doi:10.1007/s10664-011-9171-y, URL https://doi.org/10.1007/
s10664-011-9171-y.

[164] G. Catolino, F. Palomba, A. De Lucia, F. Ferrucci, A. Zaidman,

Developer-related Factors in Change Prediction: An Empirical Assess-
ment, in: Proceedings of the 25th International Conference on Program
1885 Comprehension, ICPC ’17, IEEE Press, Piscataway, NJ, USA, 186–195,
2017.

[165] S. Eski, F. Buzluca, An Empirical Study on Object-Oriented Metrics

and Software Evolution in Order to Reduce Testing Costs by Predicting
Change-Prone Classes, in: 2011 IEEE Fourth International Conference on
1890 Software Testing, Verification and Validation Workshops, 566–571, 2011.

[166] M. O. Elish, M. Al-Rahman Al-Khiaty, A suite of metrics for quantify-

ing historical changes to predict future change –prone classes in object
–oriented software, in: J. Softw.: Evol. and Proc., 407–437, 2013.

[167] G. Catolino, F. Palomba, A. De Lucia, F. Ferrucci, A. Zaidman, Enhanc-

1895 ing Change Prediction Models using Developer-Related Factors, Journal
of Systems and Software 143 (9) (2018) 14–28.

76
 Appendix A. List of selected ScienceDirect Journals

• AASRI Procedia

• Advances in Engineering Software

1900 • Astronomy and Computing

• Computer Fraud and Security

• Computer Languages

• Computer Languages, Systems and Structures

• Computer Methods and Programs in Biomedicine

1905 • Computer Programs in Biomedicine

• Computer Standards and Interfaces

• Data Processing

• Digital Investigation

• Egyptian Journal of Basic and Applied Sciences

1910 • Entertainment Computing

• Environmental Modelling and Software

• Environmental Software

• Euromicro Newsletter

• Future Computing and Informatics Journal

1915 • Future Generation Computer Systems

• Information and Software Technology

• Information Systems

• Integration

77
 • Intelligent Data Analysis

1920 • Journal of Computational Science

• Journal of Innovation in Digital Ecosystems

• The Journal of Logic and Algebraic Programming

• The Journal of Logic Programming

• Journal of Logical and Algebraic Methods in Programming

1925 • Journal of Parallel and Distributed Computing

• Journal of Systems Architecture

• Journal of Systems and Software

• Journal of Web Semantics

• Microprocessing and Microprogramming

1930 • Microprocessors

• Microprocessors and Microsystems

• Network Security

• Performance Evaluation

• Robotics

1935 • Science of Computer Programming

• SoftwareX

78