The flip side of this occurs when trying to evolve systems with too much copying — particularly when there is not a good way to find where “these things should behave the same” has spread ... I get really nervous when coding up a pattern based on copying when the main reason for the copying is that there _isnt_ a good way to share the logic without a lot of hoops ... copying when I see how I could easily have shared the logic feels like such a safer decision, much easier to justify because I can always see how to refactor later if it proves that the copied pattern really does represent a use that evolves with shared requirements. When I’m put into a situation where I know that I’m only copying because I can’t see a good way for the logic to be shared I feel like I’m setting up an infinite game of bug wack-a-mole as errors due to untraceable synchronization requirements are doomed to reoccur forever as the system changes ... I find these scenarios frequently popping up when using tools with poor composition capacity (lots of build and deployment systems) — “I don’t know how to compose this stuff so I’m just going to copy and will hate this later” is the worst feeling.
