Simplicity. Grigas
•
0 likes•185 views
The document discusses simplicity and complexity in software design. It argues that complexity is the "silent killer" of agility. Simplicity is a prerequisite for agility. The document outlines four rules of simple design: 1) code passes all tests, 2) clear and expressive naming, 3) no duplication, 4) minimal or doing the least amount of work. It advocates reducing accidental complexity through principles like separation of concerns, low coupling, and following solid architectures.
Recommended
More Related Content
Viewers also liked
Viewers also liked (17)
Similar to Simplicity. Grigas
Similar to Simplicity. Grigas (20)
More from Dev.by
More from Dev.by (20)
Recently uploaded
Recently uploaded (20)
Simplicity. Grigas
- 4. Edsger Dijkstra (1980) Computing's central challenge, "How not to make a mess of it", has not been met.
- 5. agile
- 6. agile continuous improvement based on frequent feedback
- 20. DONE
- 21. embrace the transient nature of your code
- 22. Russ Miles Complexity is the silent killer of delivering change at the right time.
- 23. simplicity is prerequisite for agility
- 24. what is simplicity ?
- 25. Nothing is more simple than a single giant button MacBook Wheel
- 26. what "simple" isn’t ...
- 27. what "simple" isn’t ... familiar / convenient
- 28. what "simple" isn’t ... familiar / convenient small / concise
- 29. what "simple" isn’t ... familiar / convenient small / concise beautiful / elegant
- 31. “Simplicity -- the art of maximizing the amount of work not done -- is essential.” from the agile principles
- 32. YAGNI from the agile principles “Simplicity -- the art of maximizing the amount of work not done -- is essential.”
- 33. “Technical excellence and good design enhances agility.” from the agile principles
- 34. Martin Fowler Design is there to enable you to keep changing the software easily.
- 35. when it comes to design ...
- 38. COMPLEXITY SUCKS ... … your brain power
- 39. COMPLEXITY SUCKS ... … your brain power
- 40. Rich Hickey Once your software is of a certain size, complexity is gonna dominate what you can do.
- 49. SIMPLICITY RULES ... … are …
- 50. SIMPLICITY RULES ... … are … The 4 Rules of Simple Design
- 51. SIMPLICITY RULES ... … are … The 4 Rules of Simple Design 1) passes all tests
- 52. SIMPLICITY RULES ... … are … The 4 Rules of Simple Design 1) passes all tests 2) clear, expressive names
- 53. SIMPLICITY RULES ... … are … The 4 Rules of Simple Design 1) passes all tests 2) clear, expressive names 3) no duplication
- 54. SIMPLICITY RULES ... … are … The 4 Rules of Simple Design 1) passes all tests 2) clear, expressive names 3) no duplication 4) minimal
- 55. rule #4: minimal
- 56. the less code, the better
- 57. code folding
- 58. code generators
- 62. rule #3: no duplication
- 63. primitive obsession duplication in behavior
- 64. data clump duplication in structure
- 65. refactoring
- 66. rule #2: clear, expressive names
- 67. small, focused methods reduce cyclomatic complexity
- 68. small, focused classes single responsibility
- 70. refactoring
- 71. rule #1: passes all tests
- 72. unit testing
- 73. testability & good design
- 74. testability & good design (but not integration tests)
- 76. wget -qO- http://c2.com/ | tr -cs '[:alpha:]' 'n' | sort | uniq composition
- 77. dependencies
- 78. auto-import
- 82. A B E G F D C follow the law of Demeter introduce indirection
- 83. modularity
- 84. coupling
- 91. tell, don’t ask high cohesion
- 97. use cases & business rules framework persistence framework web DB infrastructure messaging QUEUE task scheduler WS
- 100. @Entity @Table(name = "orders", schema = "com"}) public class Order implements Serializable { @Id @GeneratedValue(strategy = SEQUENCE, generator = "order_seq") @Column(name = "ID", unique = true, nullable = false) private Integer id; @Column(name = "NUMBER", nullable = false, length = 8) private String number; @ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL) @JoinTable(name = "order_items", catalog = "com", joinColumns = {@JoinColumn(name = "ORDER_ID", updatable = false, nullable = false)}, inverseJoinColumns = {@JoinColumn(name = "ITEM_ID", updatable = false, nullable = false)}) private Set<Item> items = new HashSet<Item>(); }
- 101. the law of leaky abstractions
- 103. libraries
- 104. state & side effects
- 106. functional style imperative style
- 108. functional style expressions immutable values imperative style statements mutable state
- 109. functional style expressions immutable values data transformations imperative style statements mutable state side effects
- 110. functional style expressions immutable values data transformations recursion & polymorphism imperative style statements mutable state side effects looping & branching
- 111. stepping out of comfort zone
- 112. Edsger Dijkstra (1980) Computing's central challenge, "How not to make a mess of it", has not been met.
- 113. I‘m done