2024 Public Training Schedule
November 18 – 21, 2024 – Agile Analysis and Design Patterns
Half-Day Sessions
December 9 – 12, 2024 – Agile Analysis and Design Patterns
Half-Day Sessions
Follow me on Twitter:
Blog Post Categories
- Announcements {19}
- Articles {2}
- Bits and Pieces {74}
- Blogosphere {1}
- Bonuses {2}
- Build in Small Batches {27}
- Collaborate {38}
- Create CLEAN Code {34}
- Implement the Design Last {11}
- Integrate Continuously {30}
- Off-Topic but Interesting {3}
- Rants {82}
- Refactor Legacy Code {24}
- Say What, Why, and for Whom Before How {22}
- Seven Strategies {38}
- Specify Behaviors with Tests {17}
- Write the Test First {27}
Archives
Privacy Policy
(c) 2024 To Be Agile
- October 16, 2012
- Bits and Pieces
Emergent design is an advanced technique, drawing on several agile practices. When done correctly, it can be a highly efficient way of building quality software but it is not a beginner technique, it requires a deep understanding in many areas. Here are seven strategies to help you master emergent design:
1. Understand object-oriented design
Just using an object-oriented language doesn’t make software object-oriented. Most of the software written between the curly braces of a class statement is procedural. Good object-oriented code is composed of well-encapsulated entities that accurately model the problem it is solving.
2. Understand design patterns
Design patterns are valuable for managing complexity and isolating varying behavior so that new variations can be added without impacting the rest of the system. Patterns are more relevant when practicing emergent design than when designing upfront as we can find many more opportunities to apply patterns as we are building software.
3. Understand test driven development
Test driven development informs the way we do design at many levels. Beyond the safety net of having a suite of regression tests to support any changes to a system, when done correctly test driven development supports us in following good design principles and practices.
4. Understand refactoring
Refactoring is the process of changing one design to another without changing external behavior. It gives us the perfect opportunity to redesign in the small or in the large with working code. Ironically, I do most of my design during refactoring once I’ve already worked out what needs to be done. This allows me to focus on doing it well and so I can emerge the right design for the problem I am solving.
5. Focus on code quality
Code quality underlies all good software. Without making software cohesive, non-redundant, well-encapsulated, assertive, testable, and correctly coupled, code quickly degrades into legacy software that people are afraid to touch. Paying attention to code quality will show us better ways of building more maintainable software that gives designs resilience and makes it easier to change.
6. Be merciless
It is easy to get attached to a design we come up with when we don’t have all the facts. Knowing the limits of a design and being willing to change it as needed is one of the most important skills for doing emergent design.
7. Turn practices into a practice
The Agile practices of Scrum and eXtreme Programming are valuable tools for doing design but tools do not create designs. To create good designs we must understand the principles behind the practices and make good development practices our habits. That way, we’ll be able to derive benefit from using them all the time.
Emergent design is about knowing our options as we build software and how to avoid painting ourselves into a corner. When we understand and are able to use good development practices it gives us the ability to easily change designs and this gives a lot more confidence that we can handle any changes in the future. It also helps make developing software less stressful and more fun.
Previous Post: « Seven Strategies for Agile Infrastructure
Next Post: Seven Strategies for Pair Programming »