Code Cohesion

In software engineering, good design is foundational to building reliable, maintainable, and scalable systems. One essential characteristic of excellent software design is code cohesion.

Code cohesion describes how closely related and focused the functionalities within a single module (such as a class or function) are. Code cohesion in software engineering ensures that each module serves a distinct, singular purpose. A high standard of code cohesion means that each module has only one specific task to complete, while low code cohesion means modules have dissimilar non-related functions.

The methods of the HighCohesionClass group relate solely to authentication tasks, making them easy to maintain and reuse. However, the LowCohesionClass group combines multiple unrelated tasks, such as authentication, data handling, email operations, and payment processing. This results in complexity, decreased maintainability, and poor readability.

Types of Code Cohesion with Code Examples

1. Functional Cohesion (Ideal)

Functional cohesion is achieved when every part of a module is necessary for the execution of a single well-defined task. It represents the highest form of cohesion, where all module activities are focused on performing a specific and essential operation.

2. Sequential Cohesion

Sequential cohesion occurs when a module’s components are grouped because the output from one part serves as input for another. This type is common in processing pipelines where data flows between operations.

3. Communicational Cohesion

Communicational cohesion occurs when parts of a module are grouped because they operate on the same data or resources. It is stronger than logical cohesion but weaker than functional cohesion.

4. Procedural Cohesion

Procedural cohesion refers to when the components of a module are grouped together to perform a series of steps in a specific order. The parallel execution between modules depends on their programmed sequence to continue the next step in their process.

5. Temporal Cohesion

Modules with temporal cohesion are grouped according to their processing order. However, these parts do not necessarily share a common functional relationship.

6. Logical Cohesion

Logical cohesion is when parts of a module are grouped logically (they are similar) but function differently. It’s often considered a weaker form of cohesion because the only relation is the general category or nature of tasks.

7. Coincidental Cohesion (Poor)

Coincidental cohesion is the weakest type of cohesion, where parts of a module are grouped arbitrarily with no meaningful relationship at all. This often leads to confusing, hard-to-maintain code.

How to Measure Code Cohesion

Measuring code cohesion is crucial in assessing software quality. While cohesion is a conceptual property, several practical ways exist to evaluate it in real-world projects.

1. Code Reviews and Inspections

One of the simplest and most effective ways to measure cohesion is through manual code reviews. During a review, software engineers can ask:

• Does the module or class have a single responsibility?
• Are all the methods and attributes within a class highly related?
• If we remove a method, will the class still make sense?

2. Automated Metrics and Tools

Several software analysis tools measure cohesion using software metrics, such as:

• Lack of cohesion in methods (LCOM) – Measures how related the methods in a class are.
• A high LCOM value suggests the class has multiple unrelated responsibilities (low cohesion).
• A low LCOM value means the methods work together toward a single goal (high cohesion).
• Cohesion metrics in SonarQube and Visual Studio Code Metrics – These tools analyze source code and provide insights into cohesion levels.

3. Refactoring Evaluations

Cohesion can also be measured indirectly by evaluating how often a module requires refactoring. Signs that indicate low cohesion include:

• Frequent modifications to unrelated parts of a class.
• Adding new, unrelated methods in a class regularly.
• Difficulty in understanding what a class does.

This class handles authentication, email notifications, and reporting, which are unrelated responsibilities. Below are the refactored high cohesion classes.

Now, each class focuses on one responsibility, ensuring high cohesion. Future changes to authentication won’t require modifications to email or reporting.

Code Cohesion and Coupling

Code cohesion and coupling are interrelated concepts in software design. While cohesion refers to closely related tasks within a module, coupling measures the interdependencies between different modules. A software system should have high cohesion within modules and low coupling between them. This combination ensures that individual modules perform precise, distinct tasks and interact minimally with each other.

Conclusion

Good software design depends heavily on high cohesion. When developers group related tasks together and clearly define each part’s responsibility, the system becomes easier to understand, maintain, test, and improve. Focusing on cohesion not only boosts software quality but also makes development more efficient.