When you start building reusable assets there is considerable awkwardness with trying to align your reuse strategy with iteration goals. The real challenge is when you are not sure about refactoring existing assets. You will discover hidden couplings to implementation technology or platform, undocumented assumptions about how something will work, and all kinds of duplications sprinkled across your codebase. Soon, you will find yourself asking the questions such as – What can we reuse? Didn’t we just solve the same problem? Is this reusable as-is or needs to be refactored? It will get easier to align your assets to a product line with time and practice. Product lines tend to grow and your understanding of the business domain expands. Your ability to spot common needs and variations in these common needs also improves over time. You will deliver on your immediate goals and still be building towards the systematic reuse strategy.
You are doing right if
- You whiteboard a design as a team and in a few hours identify new and existing reusable assets
- You design identifies gaps in an existing asset that needs refactoring so the asset can be reused
- Add items to your refactoring list as and when you identify a gap in an existing asset.
- The team collaborates on aligning your systematic reuse strategy with your iteration goals.
- You are able to recognize variations in your domain and apply that to your reusable asset design
- You are decoupling connectivity components from business logic components
- A family of message types are defined and used for integration with external systems
- Design patterns are being leveraged to support essential variations in your domain
- You are spending week after week in design and architecture. There are no signs of working code.
- New design patterns and technologies are being introduced without reason (showcasing architectural complexity or technical brilliance don’t count!)
- You don’t organize existing assets in any consistent manner forcing your team to recall capabilities every time they want to evaluate existing code for reuse.
- Nothing in the business domain tends to vary and you have a tough time finding common patterns across user stories
- The codebase is sprinkled with several design patterns that increase complexity without any domain alignment
- You create only CRUD type interfaces assuming that will address all product line variations
- Every asset in your codebase raises an ad-hoc set of error codes
- You are modeling all the complexity in your domain and trying to cram choices instead of meeting iteration goals