In computer programming, code smell is any characteristic in the program source code that may indicate a deeper problem. According to Martin Fowler, "odor codes are indicative of the surface that usually corresponds to deeper problems in the system". Another way to look at odors is to pay attention to the principle and quality: "Odor is a particular structure in code that denotes violations of fundamental design principles and negatively impacts design quality". Code smell is usually not a bug; they are technically incorrect and do not prevent the program from functioning. Instead, they show weaknesses in design that can slow development or increase the risk of bugs or future failures. Bad code odor can be an indicator of factors that contribute to technical debt. Robert C. Martin calls a list of codes that smell "value systems" for software work.
Often the deeper problems implied by the code smell can be found when the code undergoes a short feedback cycle, where it is factored in small controlled steps, and the resulting design is checked to see if there is any further code smell which in turn indicates the need for more refactoring. From a programmer's point of view filled with refactoring, the code smell is heuristic to indicate when to refactor, and what specific refactoring techniques to use. Thus, the code smell is the driver for refactoring.
A 2015 study using automated analysis for half a million source code commits and a manual check of 9,164 commitments determined to show "smell code" found that:
- There is empirical evidence for the consequences of "technical debt", but there is only anecdotal evidence of how , when , or why happen.
- "The common wisdom shows that urgent care activities and pressure to provide temporary features prioritizing time to market for code quality are often the cause of the odor."
The term "smell code" seems to have been created by Kent Beck at WardsWiki in the late 1990s. The use of the term increases after it is displayed in the book Refactoring: Improving the Design of Existing Codes by Martin Fowler. This is also a term used by agile programmers.
Determining what is and not a code smell is subjective, and varies by language, developer, and development methodology. There are tools, such as Checkstyle, PMD, and FindBugs for Java source code, to automatically check for some types of smell codes.
Video Code smell
Generic code smells
Application level odor:
- Duplicate code : identical or very similar codes exist in more than one location.
- Created complexity : the forced use of complex design patterns where a simpler design will suffice.
- Rifle operation : one change needs to be applied to multiple classes at the same time.
Grade level smell:
- Large classes : classes that have grown too large. See God's things.
- Envy feature : a class that uses other class methods in excess.
- Inappropriate intimacy : a class that is dependent on other class implementation details.
- Reject the testament : a class that overrides the base class method in such a way that the base class contract is not respected by the derived class. See Liskov's substitution principle.
- Lazy class/freeloader : a class that is too small.
- Excessive literal usage : this should be encoded as named constants, to improve readability and to avoid programming errors. In addition, literals can and should be externalized into resource files/scripts if possible, to facilitate localization of software if it is intended to be placed in different areas.
- cyclomatic complexity : too many branches or loops; this may indicate a function needs to be broken down into smaller functions, or that it has the potential for simplification.
- Downcasting : the type of player violating the abstraction model; abstractions may have to be reactor or eliminated.
- Orphan or constant class variables : a class that usually has a set of constants that belong elsewhere where they must be owned by one of the other member classes.
- Data clump : Occurs when a group of variables is shared across different parts of the program. In general, this indicates that it would be more appropriate to formally group the various variables together into one object, and only share this object only.
Odor level method:
- Too many parameters : long list of hard to read parameters, and making calls and testing functions complicated. This may indicate that the purpose of the function is poorly understood and that the code should be reforced so that responsibility is provided in a more orderly manner.
- Long method : methods, functions, or procedures that have grown too large.
- A very long identifier : in particular, the use of a naming convention to provide disambiguation that must be implicit in the software architecture.
- Excessive short identifier : variable names should reflect function unless the functionality is clear.
- Excessive data return : a function or method that returns more than what each caller needs.
- Extremely long code line (or God Line): A very long line of code, making the code hard to read, understand, debug, refactor, or even identify possible reuse of software. Example:
new XYZ (s).doSomething (buildParam1 (x), buildParam2 (x), buildParam3 (x), a Math.sin (x) * Math.tan (x * yz)).doAnythingElse ( ). build (). sendRequest ();
Maps Code smell
See also
- Design smell
- Anti-pattern
- List of tools for static code analysis
- Decay software
References
Further reading
-
Garousi, Vahid; KÃÆ'¼ÃÆ'§ÃÆ'¼k, Bar ?? (2018). "The smell of software testing code: Survey of knowledge in industry and academia". System and Software Journal . 138 : 52-81. doi: 10.1016/j.jss.2017.12.013. - Sharma, Tushar; Spinellis, Diomidis (2018). "Survey of odorless software". System and Software Journal . 138 : 158-173. doi: 10.1016/j.jss.2017.12.034.
External links
- CodeSmell on c2.com
- The code taxonomy smells
- An overview of lots of smell codes
- CodeSmell
- Boundy, David, Cancer software: seven early warning signs or here, ACM SIGSOFT Software Engineering Notes, Vol. 18 No. 2 (April 1993), Association for Computing Machines, New York, NY, USA
Source of the article : Wikipedia
0 Comments