Identifying Design Problems in the Source Code: A Grounded Theory

@article{Sousa2018IdentifyingDP,
  title={Identifying Design Problems in the Source Code: A Grounded Theory},
  author={Leonardo da Silva Sousa and Anderson Oliveira and Willian Nalepa Oizumi and Simone Diniz Junqueira Barbosa and Alessandro F. Garcia and Jaejoon Lee and Marcos Kalinowski and Rafael Maiani de Mello and Baldoino Fonseca dos Santos Neto and Roberto Felicio Oliveira and Carlos J. P. Lucena and Rodrigo de Barros Paes},
  journal={2018 IEEE/ACM 40th International Conference on Software Engineering (ICSE)},
  year={2018},
  pages={921-931}
}
The prevalence of design problems may cause re-engineering or even discontinuation of the system. Due to missing, informal or outdated design documentation, developers often have to rely on the source code to identify design problems. Therefore, developers have to analyze different symptoms that manifest in several code elements, which may quickly turn into a complex task. Although researchers have been investigating techniques to help developers in identifying design problems, there is little… 

Figures and Tables from this paper

On the identification of design problems in stinky code: experiences and tool support
TLDR
The first study showed that most developers may be unable to identify design problems in stinky code without proper tool support, and the second study helped refine the features of Organic for better supporting developers in reflecting upon stinkier code.
On the Prioritization of Design-Relevant Smelly Elements: A Mixed-Method, Multi-Project Study
TLDR
These heuristics are promising to support developers in prioritizing design-relevant smelly elements, and are suitable for an effective prioritization across multiple projects.
Removal of Design Problems through Refactorings: Are We Looking at the Right Symptoms?
TLDR
A case study involving two C# systems is reported, evaluating the impact of refactoring, focused on removing design problems, on the density and diversity of symptoms, and results indicate that refactored classes usually present higher density and Diversity of symptoms.
Predicting Design Impactful Changes in Modern Code Review: A Large-Scale Empirical Study
TLDR
By analyzing 57,498 reviewed code changes from seven open-source systems, an investigation on prediction of design impactful changes in modern code review shows that Random Forest and Gradient Boosting are the best algorithms, and observes that the use of technical features results in more precise predictions.
An Exploratory Study on Refactoring Documentation in Issues Handling
TLDR
This study aims at exploring developer-reported refactoring changes in issues to better understand what developers consider to be problematic in their code and how they handle it, and envision the findings enabling tool builders to support developers with automated documentation of refactored changes in issue.
How do Code Smell Co-occurrences Removal Impact Internal Quality Attributes? A Developers’ Perspective
TLDR
The refactorings employed by developers during the removal of 60 code smells co-occurrences, during 3 months in 5 closed-source projects are analyzed to address the gap in information about the impact of removing code smells via software refactoring on internal quality attributes.
How Does Modern Code Review Impact Software Design Degradation? An In-depth Empirical Study
TLDR
The results show that the majority of code reviews had little to no design degradation impact in the analyzed projects, and the practices of long discussions and high proportion of review disagreement in code reviews were found to increase design degradation.
When Are Smells Indicators of Architectural Refactoring Opportunities: A Study of 50 Software Projects
TLDR
It is concluded that smells can be used as indicators of architectural refactoring opportunities when the affected source code is deteriorated, i.e., the code hosting two or more smells.
...
1
2
3
4
...

References

SHOWING 1-10 OF 55 REFERENCES
How Do Software Developers Identify Design Problems?: A Qualitative Analysis
TLDR
A qualitative analysis on how developers identify design problems in two different scenarios: when they are either familiar or unfamiliar with the analyzed systems, and noticed that developers often search for multiple indicators during the identification of each design problem.
Identifying Architectural Problems through Prioritization of Code Smells
TLDR
This work presents and evaluates a suite of criteria for prioritizing groups of code smells as indicators of architectural problems in evolving systems and provides evidence that one of the proposed criteria helped to correctly prioritize more than 80 architectural problems, alleviating tedious manual inspections of the source code vis-a-vis with the architecture.
Do They Really Smell Bad? A Study on Developers' Perception of Bad Code Smells
TLDR
This study showed to developers code entities -- belonging to three systems -- affected and not by bad smells, and asked them to indicate whether the code contains a potential design problem, and if any, the nature and severity of the problem.
Code Anomalies Flock Together: Exploring Code Anomaly Agglomerations for Locating Design Problems
TLDR
This paper hypothesizes that code anomalies tend to ``flock together'' to realize a design problem, and analyzes to what extent groups of inter-related code anomalies, named agglomerations, suffice to locate design problems.
Diagnosing design problems in object oriented systems
TLDR
This paper makes a clear distinction between structural problems and structural symptoms (also known as code smells), and presents a novel, causal approach to restructuring object oriented systems, showing high potential for increased levels of automation in the restructuring process, and consequently a decrease in maintenance costs.
JSpIRIT: a flexible tool for the analysis of code smells
TLDR
A flexible tool to prioritize technical debt in the form of code smells, which is flexible to allow developer to add new smell detection strategies and to prioritize smells, and groups of smells, based on the confguration of their manifold criteria.
Do code smells reflect important maintainability aspects?
  • A. Yamashita, L. Moonen
  • Computer Science
    2012 28th IEEE International Conference on Software Maintenance (ICSM)
  • 2012
TLDR
This paper reports on an empirical study that investigates the extent to which code smells reflect factors affecting maintainability that have been identified as important by programmers.
Automatic detection of design problems in object-oriented reengineering
  • Oliver Ciupke
  • Computer Science
    Proceedings of Technology of Object-Oriented Languages and Systems - TOOLS 30 (Cat. No.PR00278)
  • 1999
TLDR
This work presents a technique for analyzing legacy code, specifying frequent design problems as queries and locating the occurrences of these problems in a model derived from source code, and shows that the task of problem detection in reengineering can be automated to a large degree.
Theory-oriented software engineering
Software Design and Architecture The once and future focus of software engineering
TLDR
Directions for design research are outlined, including: (a) drawing lessons, inspiration, and techniques from design fields outside of computer science, (b) emphasizing the design of application "character" (functionality and style) as well as the application's structure, and (c) expanding the notion of software to encompass the designof additional kinds of intangible complex artifacts.
...
1
2
3
4
5
...