Tight Coupling in Python

Tight coupling in software development refers to a scenario where classes or components are highly dependent on each other. This dependency can make it challenging to modify or update one class without impacting others, leading to difficulties in maintaining and scaling the software. In Python, tight coupling can manifest in various ways, often resulting in a codebase that is less flexible and harder to manage.

Understanding Tight Coupling

Tight coupling occurs when two pieces of code are highly interconnected, meaning changes in one part often require changes in the other. This can be problematic when it exists between separate concerns, but it can also indicate high cohesion when the interconnected elements are closely related in functionality. The main issue with tight coupling is that it makes it difficult to change one component without affecting the other, which can lead to maintenance challenges and reduced flexibility in the codebase.

Examples of Tight Coupling

Example 1: Function Tightly Coupled to an Object

In this example, the display_book_info function is tightly coupled to the Book class. The function needs to know all the different pieces of information that a Book instance contains, which makes it dependent on the internal structure of the Book class.

Listing 10.1. A function tightly coupled to an object

class Book:
    def __init__(self, title, subtitle, author):              #1
        self.title = title
        self.subtitle = subtitle
        self.author = author

def display_book_info(book):
    print(f'{book.title}: {book.subtitle} by {book.author}')  #2
#1 A book stores several pieces of info as attributes.
#2 This function has knowledge of all the book’s attributes.

Example 2: Procedure Tightly Coupled to the Details of a Class

Consider a scenario where you have a search index, and users can submit queries. The search module provides functionality for cleaning up those queries. The main procedure is tightly coupled to the search module because it relies on specific functions for query cleaning.

Listing 10.3. A procedure tightly coupled to the details of a class

import re

def remove_spaces(query):                                #1
    query = query.strip()
    query = re.sub(r'\\s+', ' ', query)
    return query

def normalize(query):                                    #2
    query = query.casefold()
    return query

if __name__ == '__main__':
    search_query = input('Enter your search query: ')    #3
    search_query = remove_spaces(search_query)           #4
    search_query = normalize(search_query)
    print(f'Running a search for \"{search_query}\"')      #5
#1 Turns ' George Washington ' into 'George Washington'
#2 Turns 'Universitätsstraße' (“University Street”) into 'universitätsstrasse'
#3 Gets a query from the user
#4 Removes spaces and normalizes casing
#5 Prints the cleaned-up query

Example 3: Tight Coupling Causing Changes to Ripple Outward

In this example, the addition of a new function to the search module requires updates in all places where queries are cleaned. This demonstrates how tight coupling can cause changes to ripple outward, affecting multiple parts of the codebase.

Listing 10.4. Tight coupling causing changes to ripple outward

def remove_quotes(query):                       #1
    query = re.sub(r'\"', '', query)
    return query

if __name__ == '__main__':
    ...
    search_query = remove_quotes(search_query)  #2
    ...
#1 A new function for removing quotes
#2 Calls the new function anywhere you normalize queries

Avoiding Tight Coupling

To avoid tight coupling, it is recommended to design systems where related classes are loosely connected. This approach facilitates easier maintenance and updates. The key strategies to achieve this include:

  • Separation of Concerns: This involves dividing a program into distinct sections, where each section addresses a separate concern or functionality. By doing so, each class or component can focus on a specific task, reducing the interdependencies between them.

  • Minimizing Dependencies: By minimizing the dependencies between classes, changes in one class are less likely to affect others. This can be achieved through techniques such as dependency injection, using interfaces, and adhering to design principles like SOLID.

By implementing these strategies, developers can create more flexible and maintainable software systems, where components can be modified or replaced with minimal impact on the overall system.

For more detailed examples and strategies, refer to the Python How-To and Practices of the Python Pro.

| Book Title | Usage of Tight Coupling | Technical Depth | Connections to Other Concepts | Examples Used | Practical Application |
|------------|-------------------------|-----------------|-------------------------------|---------------|-----------------------|
| [Python How-To](https://www.manning.com/books/python-how-to) | Discusses tight coupling as a design paradigm where classes are highly dependent, making maintenance and scaling difficult. [more](https://livebook.manning.com/book/python-how-to/chapter-9/241) | Explains strategies to avoid tight coupling, such as separation of concerns and minimizing dependencies. [more](https://livebook.manning.com/book/python-how-to/chapter-9/241) | Connects to design principles like SOLID and techniques like dependency injection. [more](https://livebook.manning.com/book/python-how-to/chapter-9/241) | No specific examples provided. [more](https://livebook.manning.com/book/python-how-to/chapter-9/241) | Focuses on creating flexible and maintainable software systems. [more](https://livebook.manning.com/book/python-how-to/chapter-9/241) |
| [Practices of the Python Pro](https://www.manning.com/books/practices-of-the-python-pro) | Describes tight coupling as high interdependency between code pieces, leading to maintenance challenges. [more](https://livebook.manning.com/book/practices-of-the-python-pro/chapter-10/14) | Provides detailed examples of tight coupling and suggests re-encapsulation and shared abstractions to address it. [more](https://livebook.manning.com/book/practices-of-the-python-pro/chapter-10/1) | Discusses cohesion and the impact of tight coupling on code flexibility. [more](https://livebook.manning.com/book/practices-of-the-python-pro/chapter-10/14) | Includes examples like a function tightly coupled to an object and procedures tightly coupled to class details. [more](https://livebook.manning.com/book/practices-of-the-python-pro/chapter-10/20) | Highlights the ripple effect of changes due to tight coupling, affecting multiple codebase parts. [more](https://livebook.manning.com/book/practices-of-the-python-pro/chapter-10/14) |

FAQ (Frequently asked questions)