202410221429 Status: #idea Tags: #complexity #software_engineering #design_patterns #object_oriented_programming # Tactical programmers vs. strategic programmers Tactical programers are focused on completing the current feature or bug fix as quickly as possible. As a result, they do not consider design choices that will impact the future extensibility and understandability of the codebase, and instead take any shortcut that will allow them to implement the feature quickest. Tactical programmers frequently introduce additional complexity into a codebase with the justification that "a little extra complexity is worth getting this feature implemented". Over time, these "little extra" bits of complexity grow to make the codebase so difficult to understand & modify that development velocity slows to a crawl. By contrast, strategic programmers spend time considering how their design choices impact the complexity of the codebase as a whole. A good strategic programmer will spend 10-20% of his time on design tasks. For example, when introducing a new class structure to a program, a strategic programmer may go through several iterations of the class design before identifying the one that is simplest to understand, easiest to extend, and introduces the fewest dependencies. While a team of strategic programmers will initially work more slowly than a team of tactical programmers, eventually the strategic programmers will begin to outpace the tactical group due to keeping the complexity of the codebase to a minimum. The expected payoff period for strategic programming vs tactical programming is estimated to be 6-18 months. For definition of complexity in software design: [[Complexity in software development and design]] --- # References [[A philosophy of software design]]