20 research outputs found
Code Smell Detection Techniques and Process: A Review
A code smell is a hint that something has turned out badly some place in your code. The idea of code smells was introduced to characterize various different types of design shortcomings in code. Code and design smells are poor solutions to recurring implementation and design problems. They may hinder the evolution of a system by making it hard for software engineers to carry out changes. In this paper, we reviewed code smell detection tool like: D�cor, InFusion, JDeodorant, PMD, Stench Blossom, etc. Furthermore, we discussed various code smells detecting techniques. Code clones are indistinguishable fragment of source code which may be embedded deliberately or inadvertently. Reusing code pieces through reordering with or without minor adjustments is general undertaking in programming advancement. We�ve examined several papers to explore various tools and techniques used for code smell. In addition, we reviewed the process of code smell detection
Towards Actionable Visualization for Software Developers
Abundant studies have shown that visualization is advantageous for software developers, yet adopting visualization during software development is not a common practice due to the large effort involved in finding an appropriate visualization. Developers require support to facilitate that task. Among 368 papers in SOFTVIS/VISSOFT venues, we identify 86 design study papers about the application of visualization to relieve concerns in software development. We extract from these studies the task, need, audience, data source, representation, medium and tool; and we characterize them according to the subject, process and problem domain. On the one hand, we support software developers to put visualization in action by mapping existing visualization techniques to particular needs from different perspectives. On the other hand, we highlight the problem domains that are overlooked in the field and need more support
Exploranative Code Quality Documents
Good code quality is a prerequisite for efficiently developing maintainable
software. In this paper, we present a novel approach to generate exploranative
(explanatory and exploratory) data-driven documents that report code quality in
an interactive, exploratory environment. We employ a template-based natural
language generation method to create textual explanations about the code
quality, dependent on data from software metrics. The interactive document is
enriched by different kinds of visualization, including parallel coordinates
plots and scatterplots for data exploration and graphics embedded into text. We
devise an interaction model that allows users to explore code quality with
consistent linking between text and visualizations; through integrated
explanatory text, users are taught background knowledge about code quality
aspects. Our approach to interactive documents was developed in a design study
process that included software engineering and visual analytics experts.
Although the solution is specific to the software engineering scenario, we
discuss how the concept could generalize to multivariate data and report
lessons learned in a broader scope.Comment: IEEE VIS VAST 201
A User Feedback Centric Approach for Detecting and Mitigating God Class Code Smell Using Frequent Usage Patterns
Code smells are the fragments in the source code that indicates deeper problems in the underlying software design. These code smells can hinder software evolution and maintenance. Out of different code smell types, the God Class (GC) code smell is one of the many important code smells that directly affects the software evolution and maintenance. The GC is commonly defined as a much larger class in systems that either know too much or do too much as compared to other classes in the system. God Classes are generally accidentally created overtime during software evolution because of the incremental addition of functionalities to it. Generally, a GC indicates a bad design choice and it must be detected and mitigated in order to enhance the quality of the underlying software. However, sometimes the presence of a GC is also considered a good design choice, especially in compiler design, interpreter design and parser implementation. This makes the developer’s feedback important for the correct classification of a class as a GC or a normal class. Therefore, this paper proposes a new approach that detects and proposes refactoring opportunities for GC code smell. The proposed approach makes use of different code metrics in combination along with utilizing user feedback as an important aspect while correctly identifying the GC code smell. The proposed approach that considers combined use of code metrics, is based on two newly proposed code metrics in this paper. The first newly proposed metric is a new approach of measuring the connectivity of a given class with other classes in the system (also termed as coupling). The second newly proposed code metric is proposed to measure the extent to which a given classes make use of foreign member variables. Finally, the proposed approach is also empirically evaluated on two standard open-source commonly used software systems. The obtained result indicates that the proposed approach is capable of correctly identifying the GC code smell
A human-centric approach for adopting bug inducing commit detection using machine learning models
When developing new software, testing can take up half of the resources. Although a considerable amount
of work has been done to automate software testing, fixing bugs after adding them to the source repository is
still a costly task from both management and financial perspectives. In recent times, the research community
has proposed various methodologies to detect bugs just-in-time at the commit level. Unfortunately, this
work, including state-of-the-art techniques, do not provide real-time solutions for the problem. Such a
limitation restricts developers from utilizing them in their day-to-day programming tasks. Our study focuses
on providing solutions that deliver real-time support to the developers by warning them about potential
bug-inducing commits. Such support can help developers by preventing them from adding a bug-inducing
commit to the source repository. Keeping this goal in mind, we conducted a developer survey to understand
the expectations of developers for bug-inducing commit detection tools. Motivated by their responses, we
built a GUI-based plug-in that warns the developers when they attempt to perform a potential buggy commit.
We accomplished this by training machine learning models on relevant features. We also built a command-line
tool for the developers who prefer to use a command-line interface. Our proposed solution has been designed
to work with various machine learning models (e.g. random forest, decision tree, and logistic regression) and
IDEs (e.g. Visual Studio, PyCharm, and WebStorm). It enables developers to work with a familiar interface
without leaving the IDE. As a proof of concept, we implemented a VSCode plug-in and an accompanying
command-line tool. Developers can customize these tools by choosing among various machine learning models
and features. Such customizability empowers the developers to understand the toolchain better and lets them
fit it into their specific use cases. Our user study shows that the toolchain offers satisfactory performance
in detecting bug-inducing commits and provides a sound user experience. The decision tree model achieved
the best performance with a 79% accuracy and an f1-score of 0.70 among the tested models. In addition,
we performed a user study with developers working in the software industries to validate the usability of
our toolchain. We found that the users can detect whether a commit is bug-inducing or not within a short
period of time. Furthermore, they prefer our tool over the state-of-the-art to detect potential bugs before
the commit operation. Alongside contributing a new multi-UI toolchain, our work enriches the research
community’s knowledge regarding developer usability of real-time bug detection tools