Our main topic for this series is how to write good software with this quote

Good software is highly cohesive and loosely coupled (Separation Of Concern).

What is the benefit from writing a good software?

Writing maintainable, testable and readable code helps increase productivity for us as developers. Having highly maintainable code makes it easier to design new features and write code. Modular, component-based, and layered code increase productivity and reduce risk and cost when making changes.

What is Cohesion?

In software design, it is the degree to which the elements of a certain class belong together.

What is Cohesion types?

1. Functional cohesion (best): This is high cohesion and that means the class should be self-contained and with a single purpose. In other words the class should do one thing and one thing very well. High cohesion is closely related to Single responsibility principle.

• The elements within the object are directly related to the functionality the object is meant to provide. By keeping high cohesion within our code, we end up trying DRY code and reduce duplication of knowledge in our object. We can easily design, write, and test our code since all the code for our object is located together and works together.

• High cohesion gives us better designed code that is easier to maintain.

• We cannot always make it perfect, but we can at least strive for it.

• The point is, while building classes the lesser the elements are, the greater the possibility for reusing them in all the methods.

Examples:

• Swiss watch: Each gear/piece is SOLID and designed to do one thing.
• Your smart phone: You can use one app while installing, updating, and/or uninstalling another! That each app is self-contained is highly cohesive.

The benefits of high cohesion are:

• Readability : (closely) related functions are contained in a single object.
• Maintainability : debugging tends to be contained in a single object.
• Reusability : classes that have less elements and concentrated functionalities are not polluted with useless functions.

2. Sequential cohesion: is when parts of a class are grouped because the output from one part is the input to another part like an assembly line (e.g., a function which reads data from a file and processes the data).

• Is this case, would there be value in “cutting” along the dotted line ? not necessarily… Can you imagine calling “predict target” without having a call to “calculate trajectory” immediately prior to that; to acquire the information needed by the “predict” task? the second task needs the first.

3- Communicational/informational cohesion: is when parts of a module are grouped because they operate on the same data.

Examples:

• Update record in database and send it to the printer

$db->Update(record)
record->Print()

Why is communicational cohesion bad?

• Still lacks reusability

4- Procedural cohesion: is when parts of a module are grouped because they always follow a certain sequence of execution (e.g., a function which checks file permissions and then opens the file).

Examples:

• Update record in database and send it to the printer

$userInput->All()
$validator->Validate($userInput)
$db->Store()

Why is procedural cohesion bad?

• Functions are still weakly connected.
• The class is unlikely to be reusable.

5- Temporal cohesion: is when parts of a module are grouped to perform a series of actions related in time (e.g., a function which is called after catching an exception which closes open files, creates an error log, and notifies the user).

Why is procedural cohesion bad?

• Functions of this class are weakly related to each other but strongly related in time.
• Not reusable.

6- Logical cohesion: is when parts of a module are grouped because they are logically categorized to do the same thing even though they are different by nature (e.g., grouping all mouse and keyboard input handling routines).

Why is logical cohesion bad?

• The interface is difficult to understand.
• Difficult to reuse.

7- Coincidental cohesion (worst): is when parts of a module are grouped arbitrarily; the only relationship between each part is that they have been grouped together (e.g., a “Utilities” class).

How to fix the coincidental cohesion?

• Break arbitrarily grouped parts into separated classes; each of which perform one task.

Recap

Low cohesion insight detector:

• Case 1: Your object has more than one responsibility.
• Case 2: Your object has methods that are not related to the class at all.
• Case 3: Utility Class.
• Case 4: Hidden objects and subclasses.

Footnotes

• Cohesion in computer science

• Thanks @hedayasamy for your review.