This document discusses a project that aims to detect code smells in Android applications using machine learning. It will focus on specific Android code smells like leaking inner classes and unclosed closables. The project will analyze the number and types of smells present. Then machine learning algorithms will be applied to determine limiting criteria for code smells that pose threats. The goal is to minimize potential threats and create more efficient software systems.

1. AMITY SCHOOL OF ENGINEERING AND
TECHNOLOGY, DELHI
An institution of Ritnand Balved Education Foundation (RBEF)
Synopsis On
Android Smell Analysis using
Machine Learning
Branch: Computer Science and Engineering (CSE)
Team Members:-
Mentor:-
Ms. Aakanshi Gupta
Kritika Phulli 01610402716 kritika1298phulli@gmail.com 14
Nidhi Kumari
Chauhan
02110402716 nidhikchauhan0411@gmail.com 19
Deepanshu
Sharma
35210402716 ping.deepanshusharma@gmail.com 36
Vishal Bhat 41910402716 vishalbhat83@gmail.com 60

3. INTRODUCTION
Research in software engineering is concerned with the enhancement and automation of the
processes of improving software designs. While there is a broad consensus on the problems
associated with software development, a specific understanding of the software engineering
problem and the appropriate solutions are inevitably driven by the target application domain
in software designing. In the software development community, there is a general belief that
such suboptimal design decisions, which can be identified in source code as code smells,
negatively impact software quality, e.g. the rate of identified bugs in post-release software.
Consequently, the presence of code smells in a software project could be a predictor of
upcoming issues related to low quality software. The methods and approaches applied to
control and eventually remedy source code affected by code smells, constitute an important
research field in software engineering. Developers are typically trained to look out for logical
errors that have been accidentally introduced to their code. Such errors will range from
forgotten edge cases that have not been handled to logical bugs that cause entire systems
to crash. But what about the other issues that don’t affect the way the system works?
Considering the design issues that make the system hard to maintain, and increase the
chance of bugs in the future contributes to increased maintenance costs. Code smells are
symptoms in source code that are indicative of bad style and/or design. They violate good
practices and design principles, affecting understanding, maintenance and promoting a
negative impact on software quality and ease of evolution. They are signals that your code
should be refactored in order to improve extendibility, readability, and supportability.
Code smells are usually not bugs – they are not technically incorrect and do not currently
prevent the program from functioning. They indicate weaknesses in design that may be
slowing down development or increasing risk of bugs or failure in the future. Code smells
can be an indicator of factors that contribute to technical debt.
In recent years, mobile applications have grown to become a large part of the software
industry. According to Gartner1, in 2016 more than 300 billion apps will be downloaded.
Another Gartner2 report shows that in 2015, Android had more than 78% of the world market
share of smart phones. Based on higher usage of Android Application, in this project, we
focus on Android Specific Code Smells that hamper the Android code to consume more
energy.

4. METHODOLOGY
Code smells are associated with poor coding practices that cause long-term maintainability
problems and mask bugs. Despite mobile being a fast growing software sector, code smells
in mobile applications have been understudied. We do not know how code smells in mobile
applications compare to those in desktop applications, and how code smells are affecting the
design of mobile applications. Without such knowledge, application developers, tool builders,
and researchers cannot improve the practice and state of the art of mobile development.
Researchers and practitioners widely recognized code smells as a harmful source of
maintenance issues which result in a lower productivity and higher rework for developers.
For these reasons, researchers have been particularly active in the definition of techniques
for detecting code smells as well as in the understanding of the analysis .These Android
specific smells may threat several non-functional attributes of mobile apps, such as security,
data integrity, and source code quality.
While the catalogue by Reimann et al. proposes a set of 30 design flaws related to both
implementation and UI design, in this project, we focus our attention solely on the smells
characterizing a problem in the source code. These Android specific code smells include:
Leaking Inner Class (LIC), Member Ignoring Method (MIM), No Low Memory Resolver
(NLMR), Slow Loop (SL), Unclosed Closable (UC), Debuggable Release (DR) etc.
The aim is to detect some of the smells in the Android Application’s source code which are
based on Java Programming Language and analyse the number and type of smells present
in each of its instances. Once smells are detected and analysed, we intend to apply Machine
Learning Algorithms to find a limiting criteria to the code smells that pose a threat in software
designing with the help of visualising the datasets and rule mining. The outcome is supposed
to minimize the potential threats in this growing era of software designing and Engineering
which would result in more efficient software systems.

5. REFERENCES
 M. Abbes, F. Khomh, Y.-G. Gu´eh´eneuc, and G. Antoniol, “An empirical study
of the impact of two antipatterns, Blob and Spaghetti Code, on program
comprehension,” in 15th European Conference on Software Maintenance and
Reengineering, CSMR. IEEE, 2011, pp. 181–190.
 A. Yamashita and L. Moonen, “Exploring the impact of inter-smell relations on
software maintainability: An empirical study,” in Proceedings of the International
Conference on Software Engineering (ICSE). IEEE, 2013, pp. 682–691.
 Transactions on Software Engineering, vol. 36, no. 1, pp. 20–36, 2010.
 F. Palomba, G. Bavota, M. Di Penta, R. Oliveto, D. Poshyvanyk, and A. De
Lucia, “Mining version histories for detecting code smells,” IEEE Transactions
on Software Engineering, vol. 41, no. 5, pp. 462–489, May 2015