Cohesion and coupling in modular programming

In modular programming, cohesion and coupling are two fundamental concepts that play an important part in how you will organize your code. Understanding these concepts, and being able to balance them, forms the basis of any maintainable, efficient, and scalable software system. Let’s dive deeper into these concepts below.

Cohesion

Cohesion is about how well related different parts of a module are to each other. A module with high cohesion focuses on a single task or a single responsibility. This makes the code a lot easier to understand, test and maintain.

• High cohesion: The module have a clear purpose and all parts are working together to perform a single task. As an example, one module could handle database operations, while another module manages the user interface.
• Low cohesion: The module is trying to do multiple tasks at once that are not related to each other, which might lead to confusion and more difficulty maintaining the module.

An example of cohesion

import socket

class NetworkChecker:
    def is_host_reachable(self, hostname, port=80, timeout=3):
        try:
            socket.create_connection((hostname, port), timeout=timeout)
            return True
        except socket.error:
            return False


checker = NetworkChecker()
print(checker.is_host_reachable('google.com'))

The sample code above is an example of how high cohesion could look like. The reason why the class NetworkChecker is cohesive is due to it having single responsibility; the class focuses on checking network reachability only, and also being concise; it includes only the necessary logic for the specific purpose.

Before moving on to coupling, I would like to give you an idea of what low cohesion could look like. Below I have added some new rows to the previous snippet.

import socket
import time

class NetworkChecker:
    def is_host_reachable(self, hostname, port=80, timeout=3):
        try:
            socket.create_connection((hostname, port), timeout=timeout)
            return True
        except socket.error:
            return False

    def log_host_status(self, hostname, file='host_status.log'):
        status = "reachable" if self.is_host_reachable(hostname) else "unreachable"
        with open(file, 'a') as log:
            log.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} - {hostname}: {status}\n")

    def count_words(self, file_path):
        try:
            with open(file_path, 'r') as file:
                return len(file.read().split())
        except FileNotFoundError:
            return 0


checker = NetworkChecker()
print(checker.is_host_reachable('google.com'))
checker.log_host_status('google.com')
print(checker.count_words('host_status.log'))

In the sample above, you can see that there are now two new functions in the NetworkChecker class; log_host_status and count_words. This brings a lot of confusion and difficulty in maintaining code, since there is no real relation in neither functionality, clarity or requirements for testing (i.e. testing is_host_reachable requires mocking sockets, while testing count_words involves file I/O).

Coupling

Coupling is all about the dependency between different modules. The goal is to have as loose coupling as possible to make a system or application more flexible and easier to modify.

• Loose coupling: The modules are quite independent from each other and communicate from module to module by utilizing well defined interfaces. This makes it easier to maintain or exchange a module without affecting the rest of the system.
• Tight coupling: The modules are strongly dependent on each others internal implementations. This makes it hard to maintain a system, since a change to one module often requires change in other modules.

An example of coupling

Let’s use the same sample code that we had for cohesion but rewrite it to being loosely coupled. I will do this by implementing some abstraction.

import socket
from abc import ABC, abstractmethod

class HostReachabilityChecker(ABC):
    """
    an abstract base class defining the interface for reachability checkers
    """
    @abstractmethod
    def is_host_reachable(self, hostname, port=80, timeout=3):
        pass

class NetworkChecker(HostReachabilityChecker):
    """
    concrete implementation of HostReachabilityChecker using sockets
    """
    def is_host_reachable(self, hostname, port=80, timeout=3):
        try:
            socket.create_connection((hostname, port), timeout=timeout)
            return True
        except socket.error:
            return False

def display_host_status(checker, hostname, port=80):
    """
    function to display the reachability of a host
    """
    status = "reachable" if checker.is_host_reachable(hostname, port) else "unreachable"
    print(f"host '{hostname}' is {status} on port {port}.")


checker = NetworkChecker()
display_host_status(checker, 'google.com')

In the code above, we now have an abstract base class called HostReachabilityChecker. This is to define a common interface for checking host reachability. The abstraction allows us to decouple the display_host_status function from NetworkChecker. By relying on the interface rather than the implementation, display_host_status becomes more flexible and reusable (fulfilling the modular purpose).

If we want to change the way host reachability is checked, for example, the way host reachability is checked using some other protocol or method, then we can do this by creating a new class implementing HostReachabilityChecker without touching the existing code. In general, such separation is also good regarding testability since it is easy to mock an interface.

Connection between cohesion and coupling

A well-designed system seeks high cohesion and loose coupling. High cohesion ensures each module focuses on a single, well-defined task, whereas loose coupling will enable a module to work with others without tight coupling. Together, these principles create a codebase that is easier to maintain, extend, and adapt, fostering flexibility, scalability, and long-term reliability.