Comfortable code
•
0 likes•211 views
The document discusses best practices for code quality. It recommends writing tests first to ensure code is testable, encapsulated, cohesive, and decoupled. It also recommends separating object construction from use, favoring delegation over inheritance, and refactoring code as needed. The goal is to produce code that is testable, has no redundancy, strong encapsulation and cohesion, correct coupling, and readability.
More Related Content
Viewers also liked
Similar to Comfortable code
Similar to Comfortable code (20)
More from Remus Langu
Recently uploaded
Recently uploaded (20)
Comfortable code
- 2. Comfortable Code Author: Remus Langu Date: 26.09.2013
- 3. Senior Developer Family Man | Orthodox Christian About Me
- 4. Agenda Introduction Code Qualities Code Quality Practices Conclusion
- 5. Introduction Why Do We Think about Code Quality?
- 6. Code Qualities Testability No Redundancy Encapsulation Strong Cohesion Correct Coupling Readability Focus
- 7. Separate Use from Construction Demo
- 8. Separate Use from Construction Promotes Testability – factories making all construction decisions can return ‘test versions’ of objects Promotes Encapsulation of design Promotes Cohesion – separate users by builders Helps keep clients Decoupled from the specific classes they are using, since they do not have to build them Aids Focus – the construction of objects are concentrated in one or more related places
- 9. Encapsulate by Convention, Reveal by Need Ease Testing – encapsulated code needs no unit tests Encapsulating Construction helps No Redundancy Ensures the greatest level of Encapsulation possible Leads to Correct Coupling – that which is hidden cannot possibly be coupled to
- 10. Encapsulate by Convention, Reveal by Need Demo
- 11. Write Tests First Best way to ensure Testability Helps avoid Redundancy – redundant test reveal redundant feature Helps you determine what can and cannot be Encapsulated Increases Cohesion - it is easier to write tests for classes with one responsibility Promotes Decoupling naturally Tends to improve Readability – code is written with a clear idea of what is supposed to do; refactoring Testing all the variations of a concept, they will tend to be Focused, because it is easier to test them if they are Demo
- 12. Code by Intention Demo
- 13. Code by Intention Improves Testability - a well-defined intention is easier to test Eliminates Redundancies Promotes Encapsulation - less-complex methods encapsulate their local variables from each other Increases Cohesion - if the intention is about one thing Assists Correct Coupling - the calling routine is written only to the interface Improves Readability - methods are well-named
- 14. Write Clearly Ensure that people understand what the method/class does Use intention revealing names Follow coding standards Improves Testability – clearer code is easier to understand and will make clearer tests
- 15. Avoid Redundancy Easier when considering Testability up front Ensures No Redundancy, obviously Keeps Focus from degrading
- 17. Pull Out Things That Vary Demo
- 18. Pull Out Things That Vary Promotes Encapsulation of type behind an interface Increases Cohesion by eliminating varying function Helps keep Correct Coupling – eliminates the opportunity to couple to state or private functions of the client class
- 19. Refactor Code as Needed It is part of TDD Often results in elimination of Redundancy of state or behavior – ‘Pull up Method’, ‘Pull up Field’, ‘Form Template Method’ Often strengthens Encapsulation Improves Cohesion – ‘Extract Method’, ‘Move Method’ Improves Coupling – ‘Replace Conditional with Polymorphism’ Tends to improve Readability – generally simplifies and beautifies code
- 20. Treat Conceptually Similar Things the Same Way
- 21. Treat Conceptually Similar Things the Same Way Improves Testability – test individual pieces, how they react and how you decide which pieces you have Improves Encapsulation – the different implementations of variations Improves Correct Coupling – client is no longer coupled to the specific types Improves Focus – it relates the different implementations together with their common interface
- 22. Favor Delegation over Class Inheritance
- 23. Favor Delegation over Class Inheritance
- 24. Favor Delegation over Class Inheritance Improves Testability – separate classes can be tested apart from the client classes Helps eliminate Redundancy – allows for reuse of pulled out objects Promotes the Encapsulation of type – variations are hidden Increase class Cohesion Eliminates the possibility of inheritance Coupling
- 25. Other Best Practice Do Not Do More Than You Need: Save time to work on things you do need Smarter to implement at the point in the future when it is needed Allows you to focus on those things you do need to do If do you need it later, more of the system will be built that should make writing the function easier
- 26. Conclusion Testability could be achieved with: Write Tests First Code by Intention Write Clearly Encapsulate by Convention, Reveal by Need Avoid Redundancy Treat Conceptually Similar Things the Same Way Favor Composition over Class Inheritance Separate Use from Construction Refactor Code as Needed
- 27. Conclusion No Redundancy could be achieved with: Write Tests First Code by Intention Encapsulate by Convention, Reveal by Need Avoid Redundancy Favor Composition over Class Inheritance Refactor Code as Needed
- 28. Conclusion Encapsulation could be achieved with: Write Tests First Code by Intention Encapsulate by Convention, Reveal by Need Pull Out Things That Vary Treat Conceptually Similar Things the Same Way Favor Composition over Class Inheritance Separate Use from Construction Refactor Code as Needed
- 29. Conclusion Strong Cohesion could be achieved with: Write Tests First Code by Intention Pull Out Things That Vary Favor Composition over Class Inheritance Separate Use from Construction Refactor Code as Needed
- 30. Conclusion Correct Coupling could be achieved with: Write Tests First Code by Intention Encapsulate by Convention, Reveal by Need Pull Out Things That Vary Treat Conceptually Similar Things the Same Way Favor Composition over Class Inheritance Separate Use from Construction Refactor Code as Needed
- 31. Conclusion Readability could be achieved with: Write Tests First Code by Intention Write Clearly Refactor Code as Needed
- 32. Conclusion Focus could be achieved with: Write Tests First Encapsulate by Convention, Reveal by Need Avoid Redundancy Treat Conceptually Similar Things the Same Way Separate Use from Construction
- 33. Recommendation Essential Skills for the Agile Developer: A Guide to Better Programming and Design (29 Aug 2011), by Alan Shalloway , Scott Bain, Ken Pugh, Amir Kolsky Comfort Code: Another delicious presentation http://vimeo.com/49476115
- 34. ANY QUESTIONS ?
- 35. Remus-Constantin Langu | Senior Developer Email: remus.langu@touricoholidays.com Skype: remus.constantin.langu THANK YOU