Clean code FTW

Writing code is easy. Writing human understandable code is difficult. Writing boring, easy to understand code is the aim. This, along with importance of testing and a good architecture, is what the talk was mostly about.

Transcript

1. Why clean code and proper architecture matters Moving to a cleaner world GurpreetSK.com Gurpreet Singh Android @ Kite Learning Functional & Reactive programming and clean code, Knows nerd talks @imGurpreetSK
2. What is ‘dirty’ code?
3. • Rigid What is ‘dirty’ code?
4. • Rigid • Fragile What is ‘dirty’ code?
5. • Rigid • Fragile • Coupled What is ‘dirty’ code?
6. Having said that
7. Having said that most code is written like
9. Object creation
10. Object creation Long IO operation
11. Object creation Long IO operation Error handling (?) Platform UI elements
12. The All-in-One™ principle
14. Logic
15. Logic Platform callback
16. The platform has control over your business logic
17. 1. Untestable / very hard to test code
18. 1. Untestable / very hard to test code 2. Tight coupling - Code is rigid and fragile
19. 1. Untestable / very hard to test code 2. Tight coupling - Code is rigid and fragile 3. Doesn’t follow any of the SOLID principles
20. 1. Untestable / very hard to test code 2. Tight coupling - Code is rigid and fragile 3. Doesn’t follow any of the SOLID principles 4. Unreadable
21. 1. Untestable / very hard to test code 2. Tight coupling - Code is rigid and fragile 3. Doesn’t follow any of the SOLID principles 4. Unreadable -> unmaintainable & non-extensible
22. 1. Untestable / very hard to test code 2. Tight coupling - Code is rigid and fragile 3. Doesn’t follow any of the SOLID principles 4. Unreadable -> unmaintainable & non-extensible 5. Hard to refactor
23. 1. Untestable / very hard to test code 2. Tight coupling - Code is rigid and fragile 3. Doesn’t follow any of the SOLID principles 4. Unreadable -> unmaintainable & non-extensible 5. Hard to refactor 6. You’re not in control of what happens
24. 1. Untestable / very hard to test code 2. Tight coupling - Code is rigid and fragile 3. Doesn’t follow any of the SOLID principles 4. Unreadable -> unmaintainable & non-extensible 5. Hard to refactor 6. You’re not in control of what happens
30. Asynchrony. Asynchrony everywhere.
31. Engineering practices Rx* Immutability Functional paradigm Reactive paradigm Persistence as single source of truth Clean SOLID State Good architecture
33. S - Single Responsibility Principle O - Open/Closed Principle L - Liskov Substitution Principle I - Interface Segregation Principle D - Dependency Inversion Principle
36. Refactoring
51. 1. Untestable / very hard to test code 2. Tight coupling - Code is rigid and fragile 3. Doesn’t follow any of the SOLID principles 4. Unreadable -> unmaintainable & non-extensible 5. Hard to refactor 6. You’re not in control of what happens Checklist
52. 1. Untestable / very hard to test code 2. Tight coupling - Code is rigid and fragile 3. Doesn’t follow any of the SOLID principles 4. Unreadable -> unmaintainable & non-extensible 5. Hard to refactor 6. You’re not in control of what happens Checklist
53. 1. Untestable / very hard to test code 2. Tight coupling - Code is rigid and fragile 3. Doesn’t follow any of the SOLID principles 4. Unreadable -> unmaintainable & non-extensible 5. Hard to refactor 6. You’re not in control of what happens Checklist
54. 1. Untestable / very hard to test code 2. Tight coupling - Code is rigid and fragile 3. Doesn’t follow any of the SOLID principles 4. Unreadable -> unmaintainable & non-extensible 5. Hard to refactor 6. You’re not in control of what happens Checklist
55. 1. Untestable / very hard to test code 2. Tight coupling - Code is rigid and fragile 3. Doesn’t follow any of the SOLID principles 4. Unreadable -> unmaintainable & non-extensible 5. Hard to refactor 6. You’re not in control of what happens Checklist
56. 1. Untestable / very hard to test code 2. Tight coupling - Code is rigid and fragile 3. Doesn’t follow any of the SOLID principles 4. Unreadable -> unmaintainable & non-extensible 5. Hard to refactor 6. You’re not in control of what happens Checklist
57. 1. Untestable / very hard to test code 2. Tight coupling - Code is rigid and fragile 3. Doesn’t follow any of the SOLID principles 4. Unreadable -> unmaintainable & non-extensible 5. Hard to refactor 6. You’re not in control of what happens Checklist
58. Thank you