A()
B()
C()
So someone thinks, hey, lets extract that bit, and create a function that does all three things def ABC():
A()
B()
C()
Now the calls site is much simpler and there is no more repetition: ABC()
Except you realise that in some call sites the B() call was missing, so to fix that you add an argument: def ABC(doB):
A()
if(doB):
B()
C()
The call site now looks a bit less clean, but still no repetition! ABC(True)
or ABC(False)
Then you realise in some cases the C() call is not necessary, so just add another argument: def ABC(doB, doC):
A()
if (doB):
B()
if (doC):
C()
And your call sites look like this: ABC(True, False)
etc.At that point the repetition in the original is definitely preferrable...
def handleNewEmail(isInboxDisplayed, areNotificationsEnabled):
AddToInbox();
if (isInboxDisplayed):
RefreshInboxView();
if (areNotificationsEnabled):
SendSystemNotification();
Not defending needless refactoring in all cases, it's definitely a judgement call.(Edit: formatting)
I'm talking about the case where the conditionals are only needed because of the refactoring.
To be honest, I find it hard to discuss readibility without a real-world example. The algebraic placeholders feel too terse.
def func1():
...
A()
B()
C()
...
def func2():
...
A()
B()
C()
...
Which is then refactored to def func1():
...
ABC()
...
def func2():
...
ABC()
...
def ABC():
A()
B()
C()
Which is sensible, but then other functions show up: def func3()
...
A()
C()
...
And you refactor to: def func1():
...
ABC(True)
...
def func2():
...
ABC(True)
...
def func3()
...
ABC(False)
...
def ABC(doB):
A()
if (doB):
B()
C()
I'll leave the final example to your imagination, since I've already used so much screen space.I'm currently in the process of undoing a lot of such refactorings in my codebase because it has become unmanageable.
I really think repetitive code is much easier to work with than overabstracted code.
My personal approach to combat this is better data structures that model the problem (and are checked by the compiler). Once this is in place I try to "flatten" the calls, so that things are mostly at the top level, or few levels deep, which usually comes up naturally once the data structure is consciously defined.
I try to have as much code as possible be "structure in - structure out" (pure functions) and to concentrate stateful code to work on the structure's fields/values. This is surprisingly easy once the data structures match the problem, instead of only growing organically.
Both options can be valid. DRY is a tangential topic, the main goal should be to keep your code as close to your mental model as possible (also keeping mental models in sync between team members, which is quite hard).
ABC being a sequence could be a pattern, or it could be a coincidence. You can't know which one it is just by looking at the code. The knowledge whether it's a sequence or not is in the business domain and in your mental model of that domain.
You might think you're disagreeing on DRY with another team member, but in reality you two have different mental models, and one of you is using DRY to justify a his.
"You seem to be using ifs and fors very much. These should be abstracted into a function."
Of course, the downside is that now you have way more tokens you need to know to understand some code, similarly to how Haskell code tends to have tons of mega-abstract function combinators or whatever whereas Go code is very simple. Which one is more readable depends on the reader, because a language like Go requires the reader to sift through more details, whereas Haskell is much terser but also requires much more pre-existing knowledge to understand.
I'm wondering if we can use these code-generation models to find "low entropy code" that is a prime target for turning into libraries.