Keeping Code DRY without Sacrificing Efficiency

Question

Suppose for example that I have two functions that are almost exactly the same, that represent a bottleneck of the system, that look something like this, (much more complicated) :

void f1( int s )
{
    for( size_t i = 0, END = m_v.size(); i < END; ++i )
    {
        int bin_id = binId( m_v[ i ], s );
        m_result[ bin_id ] += m_w[ i ]; //
    }
}

void f2( int s )
{
    for( size_t i = 0, END = m_v.size(); i < END; ++i )
    {
        int bin_id = binId( m_v[ i ], s );
        m_result[ bin_id ] += 1.f; //
    }
}

Everything is the same except that you either use a variable or a constant in one line of the code. As mentioned, suppose the actual code is much more complex. It would be nice not to duplicate it twice with the minor difference, as it requires one to make sure to maintain each identically. I could do something like this to merge them into one:

void f3( bool use_weight, int s )
{
    if( use_weight )
    {
        for( size_t i = 0, END = v.size(); i < END; ++i )
        {
            int bin_id = binId( v[ i ], s );
            result[ bin_id ] += m_w[ i ]; //
        }
    }
    else 
    {
        for( size_t i = 0, END = v.size(); i < END; ++i )
        {
            int bin_id = binId( v[ i ], s );
            result[ bin_id ] += 1.f; //
        }
    }
}

But this is still duplicating the code, just within a single function. We could do this, but it would give worse performance:

void f3( bool use_weight, int s )
{
    for( size_t i = 0, END = v.size(); i < END; ++i )
    {
        int bin_id = binId( v[ i ], s );
        if( use_weight )
        {
            result[ bin_id ] += m_w[ i ]; //
        }
        else 
        {
            result[ bin_id += 1.f; //
        }
    }
}

And the calling code looks like this:

bool use_weight = something.use_weight();
const int N = very_large_number;
for( int s = 0; s < N; ++s )
{
    f3( use_weight, s );
}

Again, assuming the code is much more complicated so that f3, for example is actually duplicating alot of logic.

Answer 1

Honestly, sometimes optimizing code reusability can often go out the door, but in your example it would likely be better to utilize Polymorphism. Classes and function should take in arguments that they are working on and not work member variables. Making an 'uber' function or class that 'does it all' is usually a mistake. These sort of classes and functions just get more and more bloated as time goes on.

So, the code would ideally use an Interface, and the needed parser would be injected. :)

var parser1 = new HotSauceParser();
parser.parse(arrayData);

var parser2 = new WeightParser();
parser2.setWeights(m_w); // in many langages you can chain this.
parser.parse(arrayData);

This follows the Single responsibility principle and it easily testable. Then you could write a class that decides when to use one class or the other. The logic of HOW to parse is encapsulated in the Parsers themselves.

As far as efficiency goes, typically if you are parsing an Array the performance concerns are about how BIG that array is and do you have to walk the entire structure.

Just be careful with 'DRY'ing your code, it easy to over-DRY your code and fall into common pitfalls like over use of Inheritance and/or creating Classes and Functions with 'Feature Envy'.

You might want to check out the Clean Code book and S.O.L.I.D..