This document discusses using machine learning to analyze code smells in Android applications. It defines code smells as symptoms in source code that indicate poor design and coding practices that can negatively impact maintainability. The methodology analyzes specific Android code smells like leaking inner classes and unclosed closables in Android app source code. Machine learning algorithms will then be applied to identify patterns in the detected code smells to minimize potential threats to software design and development.

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:-
Kritika Phulli 01610402716 kritika1298phulli@gmail.com 14
Nidhi Kumari 02110402716 nidhikchauhan0411@gmail.com 19
Chauhan
Deepanshu 35210402716 ping.deepanshusharma@gmail.com 36
Sharma
Vishal Bhat 41910402716 vishalbhat83@gmail.com 60
Mentor:-
Ms. Aakanshi Gupta

2. 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.

3. 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. Oncesmells 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 outcomeis supposed to minimize
the potential threats in this growing era of software designing and Engineering which would
result in more efficient software systems.

4. 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