scholarly journals On the Impact of Bad Smell Agglomerations on Software Quality

2019 ◽  
Author(s):  
Amanda Damasceno Santana ◽  
Eduardo Figueiredo
Keyword(s):  
Data Mining ◽  
Correlation Analysis ◽  
Software Quality ◽  
Source Code ◽  
System Quality ◽  
Large Dataset ◽  
External Behavior ◽  
Code Quality ◽  
The Impact ◽  
Open Source Systems

When a system evolution is not planned, developers can take decisions that degrade the system quality. To cope with this problem, refactoring can be applied to the source code aiming to increase code quality without modifying the software external behavior. To know when to refactor, the concept of bad smells can be used. Bad smells are snippets of source code that suggest the need of refactoring. However, bad smells does not always appear isolated. The aim of this study is to understand the impact of bad smell agglomerations on the software quality by evaluating a large dataset of open source systems. To achieve our goal, we plan to use data mining techniques complemented with correlation analysis of the dataset.

scholarly journals Exploring the Connection between Design Smells and Security Vulnerabilities

2020 ◽  
Vol 9 (8) ◽  
pp. 449-452
Keyword(s):  
Software Quality ◽  
Software Design ◽  
Source Code ◽  
Security Issue ◽  
Security Vulnerabilities ◽  
Design Problems ◽  
Security Issues ◽  
Design Smells ◽  
Code Quality ◽  
Open Source Systems

Software quality aims at having quality as part of all aspects of the developed software. Design smells are considered enemies of the software source code quality. There are verities of design problems with different terminologies. Researchers and practitioners accept it as true that whenever there is a design smell, there is a security issue or concern. In this work, we want to explore the connection between design smells and security vulnerabilities. This work provides experimental evidence about this connection. We conducted an empirical study to explore the connection between design smells and security issues by evaluating four C# open-source systems. We found interesting results that show classes with design smells have more chances of having security issues.

Why Do Developers Reject Refactorings in Open-Source Projects?

2022 ◽  
Vol 31 (2) ◽  
pp. 1-23
Author(s):  
Jevgenija Pantiuchina ◽  
Bin Lin ◽  
Fiorella Zampetti ◽  
Massimiliano Di Penta ◽  
Michele Lanza ◽  
...  
Keyword(s):  
Open Source ◽  
Software Quality ◽  
Good Practice ◽  
Source Code ◽  
Code Review ◽  
Code Quality ◽  
Shed Light

Refactoring operations are behavior-preserving changes aimed at improving source code quality. While refactoring is largely considered a good practice, refactoring proposals in pull requests are often rejected after the code review. Understanding the reasons behind the rejection of refactoring contributions can shed light on how such contributions can be improved, essentially benefiting software quality. This article reports a study in which we manually coded rejection reasons inferred from 330 refactoring-related pull requests from 207 open-source Java projects. We surveyed 267 developers to assess their perceived prevalence of these identified rejection reasons, further complementing the reasons. Our study resulted in a comprehensive taxonomy consisting of 26 refactoring-related rejection reasons and 21 process-related rejection reasons. The taxonomy, accompanied with representative examples and highlighted implications, provides developers with valuable insights on how to ponder and polish their refactoring contributions, and indicates a number of directions researchers can pursue toward better refactoring recommenders.

scholarly journals On the Relationship between Self-Admitted Technical Debt Removals and Technical Debt Measures

Algorithms ◽  
2020 ◽  
Vol 13 (7) ◽  
pp. 168
Author(s):  
Lerina Aversano ◽  
Martina Iammarino ◽  
Mimmo Carapella ◽  
Andrea Del Vecchio ◽  
Laura Nardi
Keyword(s):  
Open Source ◽  
Software Quality ◽  
Source Code ◽  
Objective Measure ◽  
Software Project ◽  
Technical Debt ◽  
Effective Reduction ◽  
The Subject ◽  
The Impact ◽  
The Relationship

The technical debt (TD) in a software project refers to the adoption of an inadequate solution from its design to the source code. When developers admit the presence of technical debt in the source code, through comments or commit messages, it is called self-admitted technical debt (SATD). This aspect of TD has been the subject of numerous research studies, which have investigated its distribution, the impact on software quality, and removal. Therefore, this work focuses on the relationship between SATD and TD values. In particular, the study aims to compare the admitted technical debt with respect to its objective measure. In fact, the trends of TD values during SATD removals have been studied. This was done thanks to the use of an SATD dataset and their related removals in four open source projects. Instead, the SonarQube tool was used to measure TD values. Thanks to this work, it turned out that SATD removals in a few cases correspond to an effective reduction of TD values, while in numerous cases, the classes indicated are removed.

scholarly journals An Integrated Model for Information Retrieval Based Change Impact Analysis

2018 ◽  
Vol 2018 ◽  
pp. 1-13 ◽  
Author(s):  
Wei Wang ◽  
Yun He ◽  
Tong Li ◽  
Jiajun Zhu ◽  
Jinzhuo Liu
Keyword(s):  
Information Retrieval ◽  
Impact Analysis ◽  
Source Code ◽  
Integrated Approach ◽  
Change Impact Analysis ◽  
Cut Points ◽  
Change Impact ◽  
The Individual ◽  
The Impact ◽  
Open Source Systems

The paper presents an approach to combine multiple existing information retrieval (IR) techniques to support change impact analysis, which seeks to identify the possible outcomes of a change or determine the necessary modifications for affecting a desired change. The approach integrates a bag-of-words based IR technique, where each class or method is abstracted as a set of words, and a neural network based IR technique to derive conceptual couplings from the source code of a software system. We report rigorous empirical assessments of the changes of three open source systems: jEdit, muCommander, and JabRef. The impact sets obtained are evaluated at the method level of granularity, and the results show that our integrated approach provides statistically significant improvements in accuracy across several cut points relative to the accuracies provided by the individual methods employed independently. Improvements in F-score values of up to 7.3%, 10.9%, and 17.3% are obtained over a baseline technique for jEdit, muCommander, and JabRef, respectively.

scholarly journals Understanding the Impact of Development Efforts in Code Quality

2021 ◽  
Vol 27 (10) ◽  
pp. 1096-1127
Author(s):  
Ricardo Perez-Castillo ◽  
Mario Piattini
Keyword(s):  
Software Quality ◽  
Clustering Algorithm ◽  
Relative Weight ◽  
Inverse Correlation ◽  
Project Managers ◽  
Development Effort ◽  
Software Product ◽  
Multiple Case ◽  
Code Quality ◽  
The Impact

Today, there is no company that does not attempt to control or assure software quality in a greater or lesser extent. Software quality has been mainly studied from the perspectives of the software product and the software process. However, there is no thorough research about how code quality is affected by the software development projects’ contexts. This study analyses how the evolution of the development effort (i.e., the number of developers and their contributions) influences the code quality (i.e., the number of bugs, code smells, cloning, etc). This paper presents a multiple case study that analyses 13 open-source projects from GitHub and SonarCloud, and retrieves more than 95,000 commits and more than 25,000 quality measures. The insights are that more developers or higher number of commits does not necessary influence worse quality levels. After applying a clustering algorithm, it is detected an inverse correlation in some cases where specific efforts were made to improve code quality. The size of commits and the relative weight of developers in their teams might also affect measures like complexity or cloning. Project managers can therefore understand the mentioned relationships and consequently make better decisions based on the information retrieved from code repositories.

scholarly journals The Impact of Code Smells on Software Bugs: A Systematic Literature Review

Information ◽  
2018 ◽  
Vol 9 (11) ◽  
pp. 273 ◽  
Author(s):  
Aloisio Cairo ◽  
Glauco Carneiro ◽  
Miguel Monteiro
Keyword(s):  
Literature Review ◽  
Open Source ◽  
Systematic Literature Review ◽  
Open Source Software ◽  
Source Code ◽  
Code Smells ◽  
Software Projects ◽  
Software Bugs ◽  
Code Quality ◽  
The Impact

Context: Code smells are associated to poor design and programming style, which often degrades code quality and hampers code comprehensibility and maintainability. Goal: identify published studies that provide evidence of the influence of code smells on the occurrence of software bugs. Method: We conducted a Systematic Literature Review (SLR) to reach the stated goal. Results: The SLR selected studies from July 2007 to September 2017, which analyzed the source code of open source software projects and several code smells. Based on evidence of 16 studies covered in this SLR, we conclude that 24 code smells are more influential in the occurrence of bugs relative to the remaining smells analyzed. In contrast, three studies reported that at least 6 code smells are less influential in such occurrences. Evidence from the selected studies also point out tools, techniques, and procedures that should be applied to analyze the influence of the smells. Conclusions: To the best of our knowledge, this is the first SLR to target this goal. This study provides an up-to-date and structured understanding of the influence of code smells on the occurrence of software bugs based on findings systematically collected from a list of relevant references in the latest decade.

scholarly journals The Impact of Code Smells on Software Bugs: a Systematic Literature Review

2018 ◽  
Author(s):  
Aloisio Cairo ◽  
Glauco Carneiro ◽  
Miguel Monteiro
Keyword(s):  
Literature Review ◽  
Open Source ◽  
Systematic Literature Review ◽  
Source Code ◽  
Code Smells ◽  
Software Bugs ◽  
Stated Goal ◽  
Code Quality ◽  
The Impact

Context: Code smells are associated with poor design and programming style that often degrades code quality and hampers code comprehensibility and maintainability. Goal: Identify reports from the literature that provide evidence of the influence of code smells on the occurrence of software bugs. Method: We conducted a Systematic Literature Review (SLR) to reach the~stated goal. Results: The SLR includes selected studies from July 2007 to September 2017 which analyzed the source code for open source and proprietary projects, as well, as several code smells and anti-patterns. The results of this SLR show that 24 code smells are more influential in the occurrence of bugs according to 16 studies. In contrast, three studies reported that at least 6 code smells are less influential in such occurrences. Evidence from the selected studies also point out tools, techniques and procedures applied to analyze the influence. Conclusion: To the best of our knowledge, this is the first SLR to target this goal. This study provides an up-to-date and structured understanding of the influence of code smells on the occurrence of software bugs based on findings systematically collected from a list of relevant references in the latest decade.

Sign in / Sign up

Export Citation Format

Share Document