Exploring architecture blueprints for prioritizing critical code anomalies: Experiences and tool support

Everton Guimaraes, S. Vidal, A. Garcia, J. A. Diaz Pace, C. Marcos

Research output: Contribution to journalArticle

2 Citations (Scopus)

Abstract

The manifestation of code anomalies in software systems often indicates symptoms of architecture degradation. Several approaches have been proposed to detect such anomalies in the source code. However, most of them fail to assist developers in prioritizing anomalies harmful to the software architecture of a system. This article presents an investigation on how developers, when supported by architecture blueprints, are able to prioritize architecturally relevant code anomalies. First, we performed a controlled experiment where participants explored both blueprints and source code to reveal architecturally relevant code anomalies. Although the use of blueprints has the potential to improve code anomaly prioritization, the participants often made several mistakes. We found these mistakes might occur because developers miss relationships between implementation and blueprint elements when they prioritize anomalies in an ad hoc manner. Furthermore, the time spent on the prioritization process was considerably high. Aiming to improve the accuracy and effectiveness of the process, we provided means to automate the prioritization process. In particular, we explored 3 prioritization criteria, which establish different ways of relating the blueprint elements with code anomalies. These criteria were implemented in the JSpIRIT tool. The approach was evaluated in the context of 2 applications with satisfactory precision results.

Original languageEnglish (US)
Pages (from-to)1077-1106
Number of pages30
JournalSoftware - Practice and Experience
Volume48
Issue number5
DOIs
StatePublished - May 1 2018

Fingerprint

Blueprints
Software architecture
Degradation
Experiments

All Science Journal Classification (ASJC) codes

  • Software

Cite this

Guimaraes, Everton ; Vidal, S. ; Garcia, A. ; Diaz Pace, J. A. ; Marcos, C. / Exploring architecture blueprints for prioritizing critical code anomalies : Experiences and tool support. In: Software - Practice and Experience. 2018 ; Vol. 48, No. 5. pp. 1077-1106.
@article{a3eaa51ffa2646fcbf3bc0ebbcc8c9a4,
title = "Exploring architecture blueprints for prioritizing critical code anomalies: Experiences and tool support",
abstract = "The manifestation of code anomalies in software systems often indicates symptoms of architecture degradation. Several approaches have been proposed to detect such anomalies in the source code. However, most of them fail to assist developers in prioritizing anomalies harmful to the software architecture of a system. This article presents an investigation on how developers, when supported by architecture blueprints, are able to prioritize architecturally relevant code anomalies. First, we performed a controlled experiment where participants explored both blueprints and source code to reveal architecturally relevant code anomalies. Although the use of blueprints has the potential to improve code anomaly prioritization, the participants often made several mistakes. We found these mistakes might occur because developers miss relationships between implementation and blueprint elements when they prioritize anomalies in an ad hoc manner. Furthermore, the time spent on the prioritization process was considerably high. Aiming to improve the accuracy and effectiveness of the process, we provided means to automate the prioritization process. In particular, we explored 3 prioritization criteria, which establish different ways of relating the blueprint elements with code anomalies. These criteria were implemented in the JSpIRIT tool. The approach was evaluated in the context of 2 applications with satisfactory precision results.",
author = "Everton Guimaraes and S. Vidal and A. Garcia and Diaz Pace, {J. A.} and C. Marcos",
year = "2018",
month = "5",
day = "1",
doi = "10.1002/spe.2563",
language = "English (US)",
volume = "48",
pages = "1077--1106",
journal = "Software - Practice and Experience",
issn = "0038-0644",
publisher = "John Wiley and Sons Ltd",
number = "5",

}

Exploring architecture blueprints for prioritizing critical code anomalies : Experiences and tool support. / Guimaraes, Everton; Vidal, S.; Garcia, A.; Diaz Pace, J. A.; Marcos, C.

In: Software - Practice and Experience, Vol. 48, No. 5, 01.05.2018, p. 1077-1106.

Research output: Contribution to journalArticle

TY - JOUR

T1 - Exploring architecture blueprints for prioritizing critical code anomalies

T2 - Experiences and tool support

AU - Guimaraes, Everton

AU - Vidal, S.

AU - Garcia, A.

AU - Diaz Pace, J. A.

AU - Marcos, C.

PY - 2018/5/1

Y1 - 2018/5/1

N2 - The manifestation of code anomalies in software systems often indicates symptoms of architecture degradation. Several approaches have been proposed to detect such anomalies in the source code. However, most of them fail to assist developers in prioritizing anomalies harmful to the software architecture of a system. This article presents an investigation on how developers, when supported by architecture blueprints, are able to prioritize architecturally relevant code anomalies. First, we performed a controlled experiment where participants explored both blueprints and source code to reveal architecturally relevant code anomalies. Although the use of blueprints has the potential to improve code anomaly prioritization, the participants often made several mistakes. We found these mistakes might occur because developers miss relationships between implementation and blueprint elements when they prioritize anomalies in an ad hoc manner. Furthermore, the time spent on the prioritization process was considerably high. Aiming to improve the accuracy and effectiveness of the process, we provided means to automate the prioritization process. In particular, we explored 3 prioritization criteria, which establish different ways of relating the blueprint elements with code anomalies. These criteria were implemented in the JSpIRIT tool. The approach was evaluated in the context of 2 applications with satisfactory precision results.

AB - The manifestation of code anomalies in software systems often indicates symptoms of architecture degradation. Several approaches have been proposed to detect such anomalies in the source code. However, most of them fail to assist developers in prioritizing anomalies harmful to the software architecture of a system. This article presents an investigation on how developers, when supported by architecture blueprints, are able to prioritize architecturally relevant code anomalies. First, we performed a controlled experiment where participants explored both blueprints and source code to reveal architecturally relevant code anomalies. Although the use of blueprints has the potential to improve code anomaly prioritization, the participants often made several mistakes. We found these mistakes might occur because developers miss relationships between implementation and blueprint elements when they prioritize anomalies in an ad hoc manner. Furthermore, the time spent on the prioritization process was considerably high. Aiming to improve the accuracy and effectiveness of the process, we provided means to automate the prioritization process. In particular, we explored 3 prioritization criteria, which establish different ways of relating the blueprint elements with code anomalies. These criteria were implemented in the JSpIRIT tool. The approach was evaluated in the context of 2 applications with satisfactory precision results.

UR - http://www.scopus.com/inward/record.url?scp=85041236239&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=85041236239&partnerID=8YFLogxK

U2 - 10.1002/spe.2563

DO - 10.1002/spe.2563

M3 - Article

AN - SCOPUS:85041236239

VL - 48

SP - 1077

EP - 1106

JO - Software - Practice and Experience

JF - Software - Practice and Experience

SN - 0038-0644

IS - 5

ER -