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.
At that point the repetition in the original is definitely preferrable...