Redundant code

In computer programming, redundant code is source code or compiled code in a computer program that is unnecessary, such as:

• recomputing a value that has previously been calculated^[1] and is still available,
• code that is never executed (known as unreachable code),
• code which is executed but has no external effect (e.g., does not change the output produced by a program; known as dead code).

A NOP instruction might be considered to be redundant code that has been explicitly inserted to pad out the instruction stream or introduce a time delay, for example to create a timing loop by "wasting time". Identifiers that are declared, but never referenced, are termed redundant declarations.

The following examples are in C.

intfoo(intiX)
{
intiY=iX*2;
returniX*2;
}

The second iX*2 expression is redundant code and can be replaced by a reference to the variable iY. Alternatively, the definition int iY = iX*2 can instead be removed.

Consider:

#define min(A,B) ((A)<(B)?(A):(B))
intshorter_magnitude(intu1,intv1,intu2,intv2)
{
/* Returns the shorter magnitude of (u1,v1) and (u2,v2) */
returnsqrt(min(u1*u1+v1*v1,u2*u2+v2*v2));
}

As a consequence of using the C preprocessor, the compiler will only see the expanded form:

intshorter_magnitude(intu1,intv1,intu2,intv2)
{
inttemp;
if(u1*u1+v1*v1<u2*u2+v2*v2)
temp=u1*u1+v1*v1;/* Redundant already calculated for comparison */
else
temp=u2*u2+v2*v2;/* Redundant already calculated for comparison */
returnsqrt(temp);
}

Because the use of min/max macros is very common, modern compilers are programmed to recognize and eliminate redundancy caused by their use.

There is no redundancy, however, in the following code:

#define max(A,B) ((A)>(B)?(A):(B))
intrandom(intcutoff,intrange)
{
returnmax(cutoff,rand()%range);
}

If the initial call to rand(), modulo range, is greater than or equal to cutoff, rand() will be called a second time for a second computation of rand()%range, which may result in a value that is actually lower than the cutoff. The max macro thus may not produce the intended behavior for this function.

• Code bloat
• Code reuse
• Common subexpression elimination
• Don't repeat yourself
• Duplicate code
• Redundancy

• Compiler optimizations
• Software anomalies
• Source code