The Wrong Abstraction
I can tell an amateur programmer from a professional by looking at their order of priorities when they grow a code base.<p>Amateur programmers tend to put code de-duplication at the top of their priority list and will burn the whole house down to that often-trivial end.<p>This writer is pointing out that there are other concerns that far, far trump duplicated code -- and she's right. However she's not elaborating enough on what it is a "wrong abstraction." We can be more precise.<p>The real offense when we factor duplicated code is the new dependency that is added to the system. And this is what amateurs don't understand. Every dependency you bring into your code architecture costs you and should be judiciously introduced. De-duplication of code ALONE is <i>rarely</i> a strong enough reason to add a dependency.<p>If you want to be a professional programmer one of the most important things to acquire is a distaste for dependencies. Every dependency you add should be carefully considered (and lamented as a reluctant necessity if you decide to introduce it). As a 20 year veteran in this industry having worked on myriad code bases, I will always prefer a code base with duplicated code and fewer dependencies than the other way around.<p>So back to the "wrong abstraction". When we compose systems, we are looking for fewest dependencies and <i>stable</i> dependencies. What I think the writer means by "the wrong abstraction" is a "volatile dependency".<p>I'm trying to be precise here because a common reaction to terms like "the wrong abstraction" is that wrong/right, its all subjective. The truth of the matter is that it's not subjective at all -- the higher-quality system is the one with optimally few dependencies and stable dependencies, these are measurable qualities.