This document discusses code smells, which are symptoms of poor code quality and design. It identifies several common code smells like rigidity, fragility, immobility, viscosity, needless complexity, needless repetition, and opacity. It then discusses principles of writing clean code like loose coupling, high cohesion, keeping changes local, and making code easy to remove to avoid these code smells. Clean code following these principles is easier to understand, change, and has fewer bugs.

1. Death of a coder CODER

2. Why should we talk about it ?

3. Code smell !
“BadCode Smells are symptoms of poor
design or implementation choices”
-Martin Fowler

4. Symptoms of smelling code
• Rigidity
• Fragility
• Immobility
• Viscosity ( Design / Environment )
• Needless complexity
• Needless repetition
• Opacity

5. Rigidity
• The code which is difficult to change.
• Cascading of change in the dependent modules.
• Impact of change cannot be predicted.
• Thus it can’t be estimated.
• Time and cost can’t be quantified.

6. Fragility
• Breaks at many places when changed.
• Errors appear in the areas, unrelated to the changed areas.
• Quality is unpredictable.
• Loss of credibility of the development team.
• Sometime breakage increases with time.

7. Immobility
• Inability to reuse Software Component.
• Lack of reusable modules.
• Desirable parts of the system depending on undesirable part.
• Thus it can’t be estimated.
• Work and risk of extracting greater than cost of writing it from
scratch.

8. Viscosity ( Design / Environment )
• Taking a shortcut and introducing technical debt requires less
effort than doing it right.
• Building , testing and other tasks take a long time.Therefore these
activities are not executed properly by everyone and technical
debt is introduced.

9. Needless complexity
• Preparing for unknown extensions / Over flexible.
• Bad algorithms.
• Bad / Out-dated assumptions about system priorities.

10. Needless repetition
• Cut / Copy and Paste - Evil in software industry.
• How many places does the same processing occur ?
• That is the number of places that changes / fix must be made.
• The same code with minor change, makes the minor change easy
to miss.

11. Opacity
• How clear is the code ?
• Code is hard to change.
• Any change takes additional time to first understand and than
change.
• More defects are introduced, due to not understanding the side
effects.

12. Clean code
• Writing clean code from the start of the project is an investment.
• Initial cost of change is a bit higher , but is paid back quite soon.
• In clean code bugs cannot hide.
• Code becomes easy to understand, and minimizes the risk of
introducing defects.

13. Principles of clean code
• Loose coupling
• High cohesion
• Change is local.
• It is easy to remove.

14. Loose coupling
• Two classes / modules are coupled when at least one of them uses
the other.
• The less these items knows about each other , the loosely they are
coupled.
• More loosely coupled the items, easier is to replace and modify them.

15. High cohesion
• Cohesion refers to the degree to which the elements of a
module/class belong together.
• It bind all related code together as far as possible.
• It has to do with the elements within the module/class.

16. Change is local
• Keeping changes local means, that there are boundary in the design
which changes do not cross.
• While maintaining a system, keeping changes local reduces involved
cost and risks.

17. It is easy to remove
• Removing elements is important so that the overall design can be
kept as simple as possible.
• When a code block gets complicated, it has to be removed and
replaced with one or more simple blocks.

18. ThankYou !!