4,192 research outputs found
A Domain Analysis to Specify Design Defects and Generate Detection Algorithms
Quality experts often need to identify in software systems design defects, which are recurring design problems, that hinder development\ud
and maintenance. Consequently, several defect detection approaches\ud
and tools have been proposed in the literature. However, we are not\ud
aware of any approach that defines and reifies the process of generating\ud
detection algorithms from the existing textual descriptions of defects.\ud
In this paper, we introduce an approach to automate the generation\ud
of detection algorithms from specifications written using a domain-specific\ud
language. The domain-specific is defined from a thorough domain analysis.\ud
We specify several design defects, generate automatically detection\ud
algorithms using templates, and validate the generated detection\ud
algorithms in terms of precision and recall on Xerces v2.7.0, an\ud
open-source object-oriented system
From a Domain Analysis to the Specification and Detection of Code and Design Smells
Code and design smells are recurring design problems in software systems that must be identified to avoid their possible negative consequences\ud
on development and maintenance. Consequently, several smell detection\ud
approaches and tools have been proposed in the literature. However,\ud
so far, they allow the detection of predefined smells but the detection\ud
of new smells or smells adapted to the context of the analysed systems\ud
is possible only by implementing new detection algorithms manually.\ud
Moreover, previous approaches do not explain the transition from\ud
specifications of smells to their detection. Finally, the validation\ud
of the existing approaches and tools has been limited on few proprietary\ud
systems and on a reduced number of smells. In this paper, we introduce\ud
an approach to automate the generation of detection algorithms from\ud
specifications written using a domain-specific language. This language\ud
is defined from a thorough domain analysis. It allows the specification\ud
of smells using high-level domain-related abstractions. It allows\ud
the adaptation of the specifications of smells to the context of\ud
the analysed systems.We specify 10 smells, generate automatically\ud
their detection algorithms using templates, and validate the algorithms\ud
in terms of precision and recall on Xerces v2.7.0 and GanttProject\ud
v1.10.2, two open-source object-oriented systems.We also compare\ud
the detection results with those of a previous approach, iPlasma
Finding Bad Code Smells with Neural Network Models
Code smell refers to any symptom introduced in design or implementation phases in the source code of a program. Such a code smell can potentially cause deeper and serious problems during software maintenance. The existing approaches to detect bad smells use detection rules or standards using a combination of different object-oriented metrics. Although a variety of software detection tools have been developed, they still have limitations and constraints in their capabilities. In this paper, a code smell detection system is presented with the neural network model that delivers the relationship between bad smells and object-oriented metrics by taking a corpus of Java projects as experimental dataset. The most well-known object-oriented metrics are considered to identify the presence of bad smells. The code smell detection system uses the twenty Java projects which are shared by many users in the GitHub repositories. The dataset of these Java projects is partitioned into mutually exclusive training and test sets. The training dataset is used to learn the network model which will predict smelly classes in this study. The optimized network model will be chosen to be evaluated on the test dataset. The experimental results show when the modelis highly trained with more dataset, the prediction outcomes are improved more and more. In addition, the accuracy of the model increases when it performs with higher epochs and many hidden layers
Smell's puzzling discrepancy: Gifted discrimination, yet pitiful identification
Mind &Language, Volume 35, Issue 1, Page 90-114, February 2020
Towards Semantic Detection of Smells in Cloud Infrastructure Code
Automated deployment and management of Cloud applications relies on
descriptions of their deployment topologies, often referred to as
Infrastructure Code. As the complexity of applications and their deployment
models increases, developers inadvertently introduce software smells to such
code specifications, for instance, violations of good coding practices, modular
structure, and more. This paper presents a knowledge-driven approach enabling
developers to identify the aforementioned smells in deployment descriptions. We
detect smells with SPARQL-based rules over pattern-based OWL 2 knowledge graphs
capturing deployment models. We show the feasibility of our approach with a
prototype and three case studies.Comment: 5 pages, 6 figures. The 10 th International Conference on Web
Intelligence, Mining and Semantics (WIMS 2020
A study to explore smellscape: from understanding and interpretation to evaluation and design in urban intermodal transit spaces in UK and China
This study aims to generate a systematic approach to exploring smellscape, from understanding and interpretation to evaluation and design in a specific type of public space - urban intermodal transit spaces, that large numbers of people visit every day, and which have intensive traffic flows and various functions. Taken Grounded Theory as a methodological approach, this study took one typical case from each country, Wuchang Railway Transit Centre and Sheffield Railway Station and Bus Interchange, to explore smellscapes in intermodal transit spaces in China and UK. An analytic procedure has been generated from the studied cases explaining people’s perception of smell environments through key elements in the concept, influenced by eleven perceptual patterns. This analysis answers the question of how to understand and interpret smellscape. In terms of people’s assessment of the pleasantness of smellscape, nine indicators were identified, which have been developed into a framework for measuring smellscape quality and classifying different types of smellscapes. The most dominant type of pleasantness in urban intermodal transit spaces is mainly influenced by cleanness and freshness. The perceptual process and evaluation criteria help with understanding and analysing existing smellscapes, and also inform the design objective for achieving a pleasant smellscape in target spaces. In terms of designing a pleasant smellscape in the target context, a design framework has been constructed at three scales with design methods and examples, responding to identified components from smells and smell sources, individual differences, physical environmental settings and contextual issues. This also gives an example of integrating smellscape design into a traditional design framework for a specified functional public space at the macro, midi and micro levels
Contemporary Approach for Technical Reckoning Code Smells Detection using Textual Analysis
Software Designers should be aware of address design smells that can evident as results of design and decision. In a software project, technical debt needs to be repaid habitually to avoid its accretion. Large technical debt significantly degrades the quality of the software system and affects the productivity of the development team. In tremendous cases, when the accumulated technical reckoning becomes so enormous that it cannot be paid off to any further extent the product has to be abandoned. In this paper, we bridge the gap analyzing to what coverage abstract information, extracted using textual analysis techniques, can be used to identify smells in source code. The proposed textual-based move toward for detecting smells in source code, fabricated as TACO (Textual Analysis for Code smell detection), has been instantiated for detecting the long parameter list smell and has been evaluated on three sampling Java open source projects. The results determined that TACO is able to indentified between 50% and 77% of the smell instances with a exactitude ranging between 63% and 67%. In addition, the results show that TACO identifies smells that are not recognized by approaches based on exclusively structural information
Code smells detection and visualization: A systematic literature review
Context: Code smells (CS) tend to compromise software quality and also demand
more effort by developers to maintain and evolve the application throughout its
life-cycle. They have long been catalogued with corresponding mitigating
solutions called refactoring operations. Objective: This SLR has a twofold
goal: the first is to identify the main code smells detection techniques and
tools discussed in the literature, and the second is to analyze to which extent
visual techniques have been applied to support the former. Method: Over 83
primary studies indexed in major scientific repositories were identified by our
search string in this SLR. Then, following existing best practices for
secondary studies, we applied inclusion/exclusion criteria to select the most
relevant works, extract their features and classify them. Results: We found
that the most commonly used approaches to code smells detection are
search-based (30.1%), and metric-based (24.1%). Most of the studies (83.1%) use
open-source software, with the Java language occupying the first position
(77.1%). In terms of code smells, God Class (51.8%), Feature Envy (33.7%), and
Long Method (26.5%) are the most covered ones. Machine learning techniques are
used in 35% of the studies. Around 80% of the studies only detect code smells,
without providing visualization techniques. In visualization-based approaches
several methods are used, such as: city metaphors, 3D visualization techniques.
Conclusions: We confirm that the detection of CS is a non trivial task, and
there is still a lot of work to be done in terms of: reducing the subjectivity
associated with the definition and detection of CS; increasing the diversity of
detected CS and of supported programming languages; constructing and sharing
oracles and datasets to facilitate the replication of CS detection and
visualization techniques validation experiments.Comment: submitted to ARC
- …