A Study of Bad Smells in Code

Transcription

1 International Journal for Science and Emerging ISSN No. (Online): Technologies with Latest Trends 7(1): (2013) ISSN No. (Print): A Study of Bad Smells in Code Gurpreet Singh* and Vinay Chopra** *M.Tech Student Department of Computer Science and Engineering, D A V I E T. **Asst. Prof. Department of Department of Computer Science and Engineering, D A V I E T. Jalandhar, Punjab, India (Received 16 April 2013 Accepted 22 April 2013) Abstract- Software development is an area which is into action for the last fifteen to twenty years. As rapidly as the software development took place, with the same ratio the trend of analysing the code raised. Code smells are structural characteristics of software that may indicate a code or design problem that makes software hard to evolve and maintain, and may trigger refactoring of code. The presence of code and design smells can have a severe impact on the quality of a program. In this paper it is reviewed that what the researchers had done so far on code smells, how code smells affect certain quality attributes and what are the relevant areas for further improvement. Keywords-Code Smell, Refactoring, Code Smell Detection, Software Quality, Software Evolution, Maintainability. I Introduction The concept of code smell was introduced fowler and beck [1] as an indicator of problems within in the design or code of software by presenting an informal definition of 22 code smells that provide a set of characteristics used as indicator for design flaws with respect to the maintainability of software system. Code smells are structural characteristics of software that may indicate a code or design problem that makes software hard to evolve and maintain, and may trigger refactoring of code [2]. In computer programming, code smell is any symptom in the source code of a program that possibly indicates a deeper problem. Code smells are usually not bugs-they are not technically incorrect and don't currently prevent the program from functioning. Instead, they indicate weaknesses in design that may be slowing down development or increasing the risk of bugs or failures in the future [3]. A code smell can be said as the drawback of the code. The code should not just be sufficient cable of producing the appropriate result but also it should be written in such a format that, it should take minimum effort to produce the appropriate result [4]. Code smell generally indicates that the code should be refactored or the overall design should be re-examined.

2 17 Singh and Chopra II Common Code Smells Following are the summary of bad smells given by Fowler et.al [1]. Duplicated code: means that the same code structure appears in more than one place. Long method: is a method that is too long, so it is difficult to understand, change, or extend. Large class: means that a class is trying to do too much. These classes have too many instances, variables or methods. God class: usually called also design flaw, refer to class that tends to centralise the intelligence of the system. Long parameter list: a long list of parameters in a procedure or function make readability and code quality worse. Feature envy: means that a method is more interested in other class (es) than the one where it is currently located. This method is in the wrong place since it is more tightly coupled to the other class than to the one where it is currently located. Contrived complexity: forced usage of overly complicated design patterns where simpler design would suffice. Complex conditionals: branches that check lots of unrelated conditions and edge cases that don't seem to capture the meaning of a block of code. Primitive obsession: the smell represents a case where primitives are used instead of small classes. Switch statement: the smell means a case where type codes or runtime class type detection are used instead of polymorphism. Data clumps: the smell means that software has data items that often appear together. Temporary fields: the smell means that class has a variable which is only used in some situation. Refused bequest: the smell means that a child class does not fully support all the methods or data it inherits. Lazy class: a class that is doing nothing enough and should be removed. Data class: a class that contain data, but hardly any logic for it. Middle man: it means that a class is delegating most of its tasks to subsequent classes. Divergent change: the smell means that one class need to be continuously changed for different reasons.

3 Singh and Chopra 18 III Drawbacks of Code Smell A major challenge in the modern information society is ensuring the maintainability of increasingly large and complex software systems. Code smells are assumed to indicate bad design that leads to less maintainable code [2]. The software life cycle comprises two major parts; the initial development, followed by the active maintenance and evolution to adapt to user needs. For most other industries, development cost is the major part of the lifetime cost of a project. However for software development it has been found that maintenance and evolution are also critical activities from the cost perspective and might comprise up to 80% of the overall cost and effort [4]. Maintenance costs often can be inflated through poor software design, code incomprehensibility, sloppy and error prone practices, inflexible design structures, bad assumptions etc. Hence, Code smells can make code difficult to understand, alter and enhance. The resources are utilized non-optimally and more memory is consumed that increases effort and time. IV Related Work Fowler et.al [1] gave definitions for 22 different code smells and introduced a technique called refactoring. Refactoring is the process of changing a software system in such a way that it does not alter the external behaviour of code yet improves its internal structure. It is disciplined way to clean up code that minimizes the chances of introducing bugs. They explained how to do refactoring in controlled and efficient manner, and how to go about reworking a bad design into good one. Van Emden, E. et.al [5] presented an approach for automatic detection and visualization of code smell and discussed how this approach can be used in the design of a software inspection tool. They built a prototype named jcosmo in java source code as tool for their approach. Early feedback enables early correction, thereby lowering the development costs and increasing the chances for success. Mantyla, M. et.al [6] authors present a taxonomy that categorise similar bad smells into six classes that is, Bloaters, Object-oriented abusers, Change preventers, Dispensable, Encapsulators, Couplers. It makes the smell more understandable and recognises the relationship between smells. Mantyla [7] studied how code smells evolve over time and how code smell influence the behaviour of infected system element. The analysis was helpful in building tool support.

4 19 Singh and Chopra Khomh, F. et.al [8] proposed a Bayesian approach to manage the uncertainty on whether a class in a program is a smell or not. Bayesian belief networks (BBNs) have been used to specify smell and to detect them in programs. There exist many approaches to specify and detect smells. Most of these approaches are manual [9] or based on rules [10][11][12]Manually detecting bad smells is a time consuming process and strongly depends on developers programming experience. As a consequence, recently, several tools and methodologies have been introduced for automatic detecting bad smells. Most of these methods are metrics based which identify bad smells using different compositions of software metrics. However, Moha et.al. [13] argue that these metric-based methods are insufficient to precisely identify bad smell. Zhang et.al. [14] proposes a pattern based approach to detect bad smells. Their approach defines bad smells as patterns of source code, so that bad smells can be identified through examining these patterns in source code. IV Conclusion and Future Work After studying various research papers on code smells, it is found that code smells affects the quality of software system. A code smell is a hint or the description of a symptom that something has gone wrong somewhere in your code. Numbers of tools has been built for the detection of code smells and were validated on different open source software system. Early feedback enables early correction, thereby lowering the development costs and increasing the chances for success. Code Smells are triggers that make you think, Are you still doing a right thing. Not much of work has been done in automatic removal of code smells. The future work can be done on building a tool that can automatically detect and correct the code smells. V References [1] Fowler, M. and K. Beck, Refactoring: improving the design of existing code. 1999: Addison-Wesley Professional. [2] Fontana, F.A. and Braione, P. and Zanoni, M. Automatic detection of bad smells in code: An experimental assess, Journal of Object Technology, Vol.11 No.2, [3] Web Reference for code smell: [4] Alkhatib, G., The maintenance problem of application software: An empirical analysis, Journal of Software Maintenance: Research and Practice, Vol.4 No.2, pp , 1992, Wiley Online Library. [5] Van Emden, E. and Moonen, L. Java quality assurance by detecting code smells Proceedings of IEEE Ninth Working Conference on Reverse Engineering, pp , 2002.

5 20 Singh and Chopra [6] Mantyla, M. and Vanhanen, J. and Lassenius, C. A taxonomy and an initial empirical study of bad smells in code, International Conference on Software Maintenance, IEEE, pp , [7] M. V. M antyl a. An experiment on subjective evolvability evaluation of object-oriented software: explaining factors and interrater agreement. In Proceedings of the International Symposium on Empirical Software Engineering, pp , [8] Khomh, F. and Vaucher, S. and Gueheneuc, Y.G. and Sahraoui, H. A bayesian approach for the detection of code and design smells, 9th International Conference on Quality Software, IEEE, pp , [9] G. Travassos, F. Shull, M. Fredericks, and V. R. Basili Detecting defects in objectoriented designs: using reading techniques to increase software quality, in Proceedings of the 14 th Conference on Object-Oriented Programming, Systems, Languages, and Applications, pp , ACM Press, [10] E. H. Alikacem and H. Sahraoui. Generic metric extraction framework. In Proceedings of the 16th International Workshop on Software Measurement and Metrik Kongress (IWS-M/MetriKon), pp , [11] R. Marinescu. Detection strategies: Metrics-based rules for detecting design laws, in Proceedings of the 20th International Conference on Software Maintenance, pp , IEEE Computer Society Press, [12] M. J. Munro. Product metrics for automatic identification of bad smell design problems in java source-code, in Proceedings of the 11th International Software Metrics Symposium IEEE Computer Society Press, [13] N. Moha, Y.-G.Gueheneuc, and P. Leduc, Automatic Generation of Detection Algorithm for Design Defects, presented at Automated Software Engineering, ASE, 21 st IEEE/ACM international Conference, [14] Zhang, M. and Baddoo, N. and Wernick, P. and Hall, T. Improving the precision of fowler's definitions of bad smells 32nd Annual IEEE Software Engineering Workshop, pp , 2008.