Code Smell 124 — Divergent Change

You change something in a class. You change something unrelated in the same class

TL:DR; Classes should have just one responsibility and one reason to change.

Problems

• Coupling
• Code Duplication
• Low Cohesion
• Single Responsibility Principle violation

Solutions

1. Extract class

Context

We create classes to fulfill responsibilities.

If an object does too much, it might change in different directions.

Sample Code

Wrong

class Webpage {
  renderHTML(): {
    renderDocType();
    renderTitle();
    renderRssHeader();
    renderRssTitle();
    renderRssDescription();
   // ...
  }
  //HTML render can change
  renderRssDescription() {
   // ...
  }
  renderRssTitle() {
   // ...
  }
  renderRssPubDate() {
   // ...
  }
  //RSS Format might change
}

Right

class Webpage {
  renderHTML() {
    this.renderDocType();
    this.renderTitle();
    (new RSSFeed()).render();
    this.renderRssTitle();
    this.renderRssDescription();
   // ...
  }
  //HTML render can change
}
class RSSFeed {
  render() {
    this.renderDescription();
    this.renderTitle();
    this.renderPubDate();
    //...
  }  
  //RSS Format might change
  //Might have unitary tests 
  //etc
}

Detection

[X] Semi Automatic

We can automatically detect large classes or track changes.

Tags

• Coupling

Conclusion

Classes must follow the Single Responsibility Principle and have just one reason to change.

If they evolve in different ways, they are doing too much.

Relations

Code Smell 34 — Too Many Attributes

Code Smell 94 — Too Many imports

Code Smell 14 — God Objects

More Info

• Refactoring.guru

A design that doesn’t take change into account risks major redesign in the future.

Erich Gamma

Software Engineering Great Quotes

This article is part of the CodeSmell Series.

How to Find the Stinky parts of your Code