Terminology – Is There a Term for Reusing Code by Retyping It?

code-reuserefactoringterminology

I built a prototype ("one to throw away") a while ago, and I'm rebuilding it now as an alpha. My goodness, it's been worth it.

I reused some of the prototype code by copy-pasting then modifying it, but I've fallen into a pattern of looking at the prototype for guidance, but writing the new code from scratch. This doesn't take too long for me because I'm a pretty fast touch-typist.

Right now I'm rebuilding a complex function, and I'm actually reading it line-by-line and typing equivalent code into my alpha version. I find it's better than copy-paste-refactor because I get reacquainted with the logic, and I don't miss parts of the code when I'm reading it. Is there a name for this kind of reuse? Any authoritative commentary on its benefits/drawbacks?

Best Answer

IMHO the term that matches your activity best is just a rewrite.

This may sound trivial, but some commenters have already used that term, and if you search for the term here on PSE, you will find lots of postings dealing with the question when a rewrite is good or bad, or when you go better with refactoring (which is most times used in opposition to "rewriting" things). See, for example, here:

When is a BIG Rewrite the answer?

Related Solutions

Terminology – Term for Nested Function Calls: func1(func2(), func3())

I don't think it's function composition. Function composition means taking two or more functions and turning them into a new function, like f . g . h in Haskell. Note that no function is called at this point.

Personally, I would refer to constructs like func1(func2(), func3()) as "nested function calls".

Refactoring Terminology – What is This Type of Refactoring Called?

This is loop-invariant code motion. A good compiler should do it on its own.

...loop-invariant code consists of statements or expressions (in an imperative programming language) which can be moved outside the body of a loop without affecting the semantics of the program. Loop-invariant code motion (also called hoisting or scalar promotion) is a compiler optimization which performs this movement automatically...

If we consider the following code sample, two optimizations can be easily applied.
for (int i = 0; i < n; i++) {
    x = y + z;
    a[i] = 6 * i + x * x;
}
The calculation x = y + z and x * x can be moved outside the loop since within they are loop invariant — they do not change over the iterations of the loop— so the optimized code will be something like this:
x = y + z;
t1 = x * x;
for (int i = 0; i < n; i++) {
    a[i] = 6 * i + t1;
}
This code can be optimized further...

Best Answer

Related Solutions

Terminology – Term for Nested Function Calls: func1(func2(), func3())

Refactoring Terminology – What is This Type of Refactoring Called?

Related Topic