The document discusses the DRY (Don't Repeat Yourself) principle which states that every piece of knowledge in a system should have a single representation to avoid code duplication. It describes why duplication is bad, such as recurring bugs and increased maintenance. There are different types of duplication like imposed, inadvertent, impatient, and interdeveloper. Ways to avoid duplication include thorough code reviews and conventions. While avoiding duplication is important, premature optimization should be avoided, and duplication may be cheaper than the wrong abstraction. The key takeaway is that following the DRY principle enhances coding skills and code quality.

1. DRY

2. Agenda
● The DRY principle
● Why code duplication is bad?
● Types of duplication
● Ways to fight duplication
● WET

3. DRY
OR
DIE
Don't Repeat Yourself
?

4. “..covers topics ranging
from personal
responsibility and career
development to
architectural techniques
for keeping your code
flexible and easy to adapt
and reuse.”

5. The DRY Principle
Every piece of knowledge must have a single,
unambiguous, authoritative representation
within a system.

6. Why code duplication is bad?
● Recurring bug fixes
● More code to maintain
● Strong possibility for logical contradictions
● Information loss
● Conveys a sense of carelessness and lack of
responsibility (Broken Window Theory)

7. Types of duplication
● Imposed duplication
● Inadvertent duplication
● Impatient duplication
● Interdeveloper duplication

8. ● Imposed duplication
Types of duplication
Developers feel they have no choice — the environment seems to
require duplication.
Solutions:
- Protobuf as an example for code duplication elimination.
- Swagger as an example for documentation and code duplication elimination.

9. ● Inadvertent Duplication
Types of duplication
Developers don't realize that they are duplicating information.
Smells:
- Same nature of a change is spread across files
- Two fields that represents the same knowledge
- Two different methods to retrieve the same data

10. ● Impatient duplication
Types of duplication
Developers get lazy and duplicate because it seems easier.
“Short cuts make long delays” (J.R.R. Tolkien)

11. ● Interdeveloper duplication
Types of duplication
Multiple people on a team duplicate a piece of information.
Solutions:
- Strong design and architecture to express division of responsibilities.
- Good communication within a team and across teams.
- Make it easy to reuse - if it isn't easy, people won't do it.

12. Ways to fight duplication
● Thorough code review
● Naming, style and conventions will help
identify code duplication

13. WET Write Everything
Twice
We Enjoy Typing
You can ask yourself "Haven't I written this
before?" two times, but never three.

14. WET
● Premature optimization is evil
● Fear of DRY abstractions which does not
make sense in the domain
● Duplication is far cheaper than the wrong
abstraction (Sandy Matz)

15. Takeaways
Use DRY principle to enhance your coding
and code reviews skills to protect your
software.