Skip to end of metadata
Go to start of metadata

You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 6 Next »

Code duplication

Code duplication is very hard to define. It generally falls within one of these definitions.

  1. Identical code fragments except for variations in whitespace (may be also variations in layout) and comments.
  2. Structurally / syntactically identical fragments except for variations in identifiers, literals, types, layout and comments. The reserved words and the sentence structures are essentially the same.
  3. As previous, but with further modifications – statements can be changed, added and / or deleted in addition to variations in identifiers, literals, types, layout and comments.
  4. Code fragments that perform the same computation but implemented through different syntactic variants.

Why care?

  • Propagation of bugs: if a code fragment contains a bug and this fragment is copied, then the bug will exist in all pasted fragments. More generally, duplicating code will also duplicate the associated technical debt.
  • Increased maintenance cost: any maintenance required on a copied code fragments will certainly need to be applied on the pasted ones, i.e. duplication multiplies the work to be done.
  • Increased time to understand and thus to improve/modify existing system if it contains a lot of duplications, because differences must be studied by developers before modifications.
  • As an indicator of a bad design, lack of good inheritance structure or abstraction.
  • As an indicator about copyright infringement.

How to see it?

Sonar has the tools for you to see these duplicated blocks.

Code complexity

It is the cyclomatic complexity, also known as McCabe metric. Whenever the control flow of a function splits, the complexity counter gets incremented by one. Each function has a minimum complexity of 1.

Or. A measurement of the intricacy of a program module based on the number of repetitive cycles or loops that are made in the program logic. It is used as a general measure of complexity for software quality control as well as to determine the number of testing procedures

Why care?

  • How many outcomes for a given piece of code?
  • Outcomes create behaviors. Each is a possible regression.

How is it calculated?

public void process(Car myCar){          // +1
    if(myCar.isNotMine()){               // +1
         return;                         // +1
    }
    car.paint("red");
    car.changeWheel();
    while(car.hasGazol() && car.getDriver().isNotStressed()){   // +2
         car.drive();
    }
    return;
}

How to track this on Sonar?

Each project has a complexity analysis tool. ie: kettle-core.

  • No labels