Timeless Wisdom for Modern Code: SOLID Principles Through the Lens of the Bhagavad Gita

Introduction

In modern software development, AI tools have become highly proficient at generating code, automating repetitive tasks, and streamlining workflows. However, as AI takes on more of the coding burden, the responsibility shifts toward defining the right problems and ensuring that the design principles guiding these tools are robust and effective. This is where timeless wisdom and sound design principles converge.

This article explores how the ancient wisdom of the Bhagavad Gita can provide deeper insights into applying SOLID design principles. The Gita’s teachings on duty, adaptability, and higher principles resonate with the challenges of creating software that remains maintainable, flexible, and scalable as technology advances.

Understanding the Bhagavad Gita

The Bhagavad Gita is a dialogue between Lord Krishna and the warrior Arjuna on the battlefield of Mahabharata. Faced with a moral and existential crisis, Arjuna receives guidance from Krishna on how to live and act in alignment with higher principles, regardless of outcomes. These teachings emphasize duty, adaptability, balance, and the alignment with larger purposes—principles that can be applied to both life and software design.

Key Teachings of the Bhagavad Gita

• Duty and Purpose: Krishna encourages Arjuna to focus on his responsibilities with full dedication, without being attached to the results. This can be seen as a call to uphold one's role with clarity and purpose.
• Adaptability and Balance: Life requires constant balance, and adaptability is key to responding to changes while remaining grounded in core principles.
• Role Fulfillment: Every role has its importance in a broader context. Effectively fulfilling your role contributes to the harmony of the whole system.
• Higher Principles: Instead of being driven solely by immediate outcomes, one should align actions with higher ethical and moral principles.

These teachings offer valuable parallels to SOLID principles, which aim to create software that can adapt to change and remain maintainable over time.

Applying Bhagavad Gita Teachings to SOLID Design Principles

The SOLID principles—Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion—are critical for writing code that is flexible, robust, and easy to maintain. The Bhagavad Gita’s emphasis on duty, adaptability, and alignment with higher principles provides a philosophical foundation for better understanding these design guidelines. Below, we apply these teachings to the development of a Library Management System.

Library Management System Overview

Our Library Management System manages books and patrons, supporting functionalities like adding books, registering patrons, and handling checkouts and returns.

Base Code: Library System Overview

# Basic implementation of a Library Management System
class Book:
    def __init__(self, title):
        self.title = title
        self.is_checked_out = False

class Patron:
    def __init__(self, name):
        self.name = name

class Library:
    def __init__(self):
        self.books = []
        self.patrons = []

    def add_book(self, book):
        self.books.append(book)

    def register_patron(self, patron):
        self.patrons.append(patron)

    def checkout_book(self, book_title, patron_name):
        for book in self.books:
            if book.title == book_title and not book.is_checked_out:
                book.is_checked_out = True
                return f"Book '{book_title}' checked out by {patron_name}."

        return f"Book '{book_title}' is not available."

    def return_book(self, book_title):
        for book in self.books:
            if book.title == book_title and book.is_checked_out:
                book.is_checked_out = False
                return f"Book '{book_title}' returned."
        return f"Book '{book_title}' was not checked out."        

Single Responsibility Principle (SRP)

The Gita on Duty and Focus: In the Bhagavad Gita, Lord Krishna teaches Arjuna to focus on his specific duty (or dharma) as a warrior. Krishna emphasizes that Arjuna should not be distracted by others' responsibilities or the outcomes of his actions but should concentrate on fulfilling his own role with precision and dedication. This focused approach leads to clarity of purpose and effectiveness in action.

Single Responsibility Principle (SRP): The Single Responsibility Principle (SRP) in software design states that a class should have only one responsibility or reason to change. By giving each class a clear, singular focus, the design becomes easier to maintain, test, and modify, leading to cleaner, more manageable code.

The Connection: Just as Krishna advises Arjuna to focus solely on his duty as a warrior, the SRP emphasizes that each class should concentrate on doing one thing well. Both teach the importance of having a clear, specific role to ensure clarity and effectiveness, whether in life (Arjuna’s duty) or in software (class responsibility).

This parallel illustrates how staying true to a focused duty or responsibility—be it a person in their role or a class in its function—creates clarity, reduces complexity, and promotes efficiency in both the philosophical and technical domains.

Refactor: By separating responsibilities for managing books, patrons, and library operations, we create a clearer and more maintainable design.

class Book:
    def __init__(self, title):
        self.title = title
        self.is_checked_out = False

class Patron:
    def __init__(self, name):
        self.name = name

class BookRepository:
    def __init__(self):
        self.books = []

    def add_book(self, book):
        self.books.append(book)

    def get_book(self, title):
        for book in self.books:
            if book.title == title:
                return book
        return None

class PatronRepository:
    def __init__(self):
        self.patrons = []

    def register_patron(self, patron):
        self.patrons.append(patron)

    def get_patron(self, name):
        for patron in self.patrons:
            if patron.name == name:
                return patron
        return None

class Library:
    def __init__(self, book_repo, patron_repo):
        self.book_repo = book_repo
        self.patron_repo = patron_repo

    def checkout_book(self, book_title, patron_name):
        book = self.book_repo.get_book(book_title)
        patron = self.patron_repo.get_patron(patron_name)
        if book and not book.is_checked_out:
            book.is_checked_out = True
            return f"Book '{book_title}' checked out by {patron_name}."
        return f"Book '{book_title}' is not available."
    
    def return_book(self, book_title):
        book = self.book_repo.get_book(book_title)
        if book and book.is_checked_out:
            book.is_checked_out = False
            return f"Book '{book_title}' returned."
        return f"Book '{book_title}' was not checked out."        

Open/Closed Principle (OCP)

The Gita on Adaptability and Core Values: The Bhagavad Gita emphasizes the importance of adapting to changing circumstances while remaining firmly rooted in one's core values and principles. Lord Krishna advises Arjuna to act according to his dharma (duty) but to be flexible in how he approaches challenges, always guided by wisdom and righteousness. This balance of adaptability with a strong foundation ensures stability in action.

Open/Closed Principle (OCP): In software design, the Open/Closed Principle (OCP) states that a system should be open for extension but closed for modification. This means the codebase should allow for new features and changes through extensions, without needing to modify existing, stable code. It ensures that the system can evolve over time without introducing bugs or disrupting the core functionality.

The Connection: Just as the Gita advises flexibility in actions while remaining true to fundamental values, the OCP encourages developers to build systems that can adapt to new requirements (flexibility) without altering the original structure or core logic (stability). Both teach the importance of being adaptable while maintaining a solid, unchanging foundation.

This parallel draws on the idea that in both life and software, change is inevitable, but it should be approached in a way that respects and preserves the integrity of the foundational principles.

Refactor: We introduce an interface for notification services, allowing for extensions like email or SMS notifications without modifying existing code.

from abc import ABC, abstractmethod
class NotificationService(ABC):
    @abstractmethod
    def send_notification(self, message: str):
        pass

class EmailNotificationService(NotificationService):
    def send_notification(self, message: str):
        print(f"Sending email with message: {message}")

class Library:
    def __init__(self, book_repo, patron_repo, notification_service):
        self.book_repo = book_repo
        self.patron_repo = patron_repo
        self.notification_service = notification_service

    def checkout_book(self, book_title, patron_name):
        book = self.book_repo.get_book(book_title)
        patron = self.patron_repo.get_patron(patron_name)
        if book and not book.is_checked_out:
            book.is_checked_out = True
            message = f"Book '{book_title}' checked out by {patron_name}."
            self.notification_service.send_notification(message)
            return message
        
return f"Book '{book_title}' is not available."        

Liskov Substitution Principle (LSP)

Bhagavad Gita’s Insight on Roles: The Gita encourages individuals to fulfill their duties without deviation, maintaining consistency in action and purpose. Lord Krishna advises Arjuna to focus on his role as a warrior, without letting external distractions interfere. This teaches the importance of staying true to one’s role in the larger system to ensure harmony and balance.

Liskov Substitution Principle (LSP): In software design, the LSP ensures that subclasses must adhere to the expectations set by their base classes. If a subclass is used in place of a base class, it should not break the application’s logic. This principle maintains consistency across an application, ensuring that all derived classes perform as expected without deviating from their intended role within the system.

The Connection: Just as the Gita stresses the importance of each individual fulfilling their role to maintain harmony in the world, the LSP requires that subclasses fulfill their roles within the system without causing issues or inconsistencies. Both emphasize that deviations from expected behavior can lead to instability—whether in the world (Gita) or in the software system (LSP).

This parallel highlights how the philosophical consistency in the Gita mirrors the technical consistency required in software design to ensure smooth functioning.

Refactor: We ensure all subclasses of NotificationService adhere to the same contract.

class SMSNotificationService(NotificationService):
    def send_notification(self, message: str):
        print(f"Sending SMS with message: {message}")

# Usage
email_service = EmailNotificationService()
sms_service = SMSNotificationService()
library_with_email = Library(book_repo, patron_repo, email_service)
library_with_sms = Library(book_repo, patron_repo, sms_service)        

Interface Segregation Principle (ISP)

The Gita on Focusing on Essential Tasks: In the Bhagavad Gita, Lord Krishna advises Arjuna to concentrate on essential tasks and avoid unnecessary distractions. Krishna emphasizes that focusing on what truly matters—fulfilling one’s duty without being overwhelmed by peripheral concerns—leads to better clarity, purpose, and action. This teaching encourages simplicity and prioritization in life.

Interface Segregation Principle (ISP): The Interface Segregation Principle (ISP) in software design promotes the idea of creating smaller, more specific interfaces that clients need, rather than large, general ones. By focusing on essential methods and avoiding overly broad interfaces, the design becomes simpler, more efficient, and easier to maintain.

The Connection: Just as the Gita advises focusing on essential tasks for clarity and purpose, the ISP encourages developers to create smaller, focused interfaces to reduce complexity. Both emphasize simplicity by focusing on what is necessary and avoiding overcomplication—whether in life (tasks) or software design (interfaces).

This parallel highlights how focusing on essentials, whether in personal actions or software design, leads to better outcomes, making systems (or lives) easier to manage and more efficient.

Refactor: Proper Segregation of Responsibilities

Here’s an example of how an incorrectly designed interface might look:

# Violating ISP: LibraryService interface includes unrelated responsibilities
class LibraryService:
    def send_notification(self, message: str):
        pass

    def generate_report(self):
        pass        

In this case, the LibraryService forces all implementations to handle both notifications and report generation, even if they are not needed. For instance, an implementation that only deals with notifications would still need to define the generate_report method, even though it might not use it.

To follow ISP, we split this into two smaller interfaces, each focused on a specific responsibility. One interface handles notifications, and the other handles report generation. This allows implementations to choose only the interfaces that are relevant to their needs.

# Correctly applying ISP: Smaller, more focused interfaces
class NotificationService:
    def send_notification(self, message: str):
        pass

class ReportService:
    def generate_report(self):
        pass        

Now, we can have separate implementations for notifications and reports, avoiding the clutter and ensuring that each class only depends on what it actually needs.

class EmailNotificationService(NotificationService):
    def send_notification(self, message: str):
        print(f"Sending email with message: {message}")

class SMSNotificationService(NotificationService):
    def send_notification(self, message: str):
        print(f"Sending SMS with message: {message}")

class CSVReportService(ReportService):
    def generate_report(self):
        print("Generating CSV report.")        

This approach ensures that classes interact with interfaces tailored to their specific needs, rather than being burdened by unrelated methods.

Dependency Inversion Principle (DIP)

The Gita on Aligning with Higher Principles: In the Bhagavad Gita, Lord Krishna teaches Arjuna the importance of aligning one's actions with higher principles—such as duty, righteousness, and spiritual wisdom—rather than being driven by immediate outcomes. Krishna encourages Arjuna to elevate his thinking and actions to serve a greater purpose, staying true to core principles.

Dependency Inversion Principle (DIP): The Dependency Inversion Principle (DIP) in software design suggests that high-level modules (core functionalities) should not rely directly on low-level modules (specific implementations). Instead, both high-level and low-level modules should depend on abstractions (interfaces or abstract classes), ensuring that the system remains flexible, scalable, and adaptable to changes.

The Connection: Just as Krishna advises aligning actions with higher principles to maintain integrity and purpose, the DIP emphasizes that high-level modules should depend on abstractions, not on specific low-level details. Both stress the importance of grounding decisions and actions in higher, more stable concepts—whether it’s living in accordance with spiritual principles or building software that is flexible and not tied to specific implementations.

This parallel illustrates that both in life and in software design, depending on higher-level abstractions or principles creates stability, adaptability, and long-term sustainability.

To adhere to DIP, we'll introduce an abstraction (`NotificationService`), which the Library class will depend on. Concrete implementations (e.g., EmailNotificationService, SMSNotificationService) will implement this abstraction.

Before DIP: Tight coupling to a specific notification service

class Library:
    def __init__(self, book_repo, patron_repo):
        self.book_repo = book_repo
        self.patron_repo = patron_repo
        self.email_service = EmailNotificationService()  # Direct dependency on email service

    def checkout_book(self, book_title, patron_name):
        book = self.book_repo.get_book(book_title)
        patron = self.patron_repo.get_patron(patron_name)
        if book and not book.is_checked_out:
            book.is_checked_out = True
            self.email_service.send_email(f"Book '{book_title}' checked out by {patron_name}.")
            return f"Book '{book_title}' checked out by {patron_name}."

        return f"Book '{book_title}' is not available."        

Here, the Library class is tightly coupled to the EmailNotificationService. This makes it difficult to swap out the email notification system with, say, an SMS or a push notification system without modifying the Library class.

Refactor with DIP: Dependency on abstractions, not implementations

from abc import ABC, abstractmethod
# Abstract notification service

class NotificationService(ABC):
    @abstractmethod
    def send_notification(self, message: str):
        pass

# Concrete notification implementations
class EmailNotificationService(NotificationService):
    def send_notification(self, message: str):
        print(f"Sending email: {message}")

class SMSNotificationService(NotificationService):
    def send_notification(self, message: str):
        print(f"Sending SMS: {message}")

# High-level module (Library) depends on abstraction (NotificationService), not concrete implementations

class Library:
    def __init__(self, book_repo, patron_repo, notification_service: NotificationService):
        self.book_repo = book_repo
        self.patron_repo = patron_repo
        self.notification_service = notification_service  # Dependency on abstraction

    def checkout_book(self, book_title, patron_name):
        book = self.book_repo.get_book(book_title)
        patron = self.patron_repo.get_patron(patron_name)
        if book and not book.is_checked_out:
            book.is_checked_out = True
            self.notification_service.send_notification(f"Book '{book_title}' checked out by {patron_name}.")
            return f"Book '{book_title}' checked out by {patron_name}."
        return f"Book '{book_title}' is not available."        

Explanation:

• The Library class now depends on the NotificationService abstraction instead of a specific implementation like EmailNotificationService.
• This allows us to inject any notification service (email, SMS, push notifications, etc.) without modifying the Library class itself, making it more flexible and easy to extend.

Usage Example:

# Initialize repositories
book_repo = BookRepository()
patron_repo = PatronRepository()
# Inject an EmailNotificationService into the Library
email_service = EmailNotificationService()
library = Library(book_repo, patron_repo, email_service)
# Checkout a book and send an email notification
library.checkout_book('The Gita', 'Arjuna')

# Switch to SMSNotificationService without changing the Library class
sms_service = SMSNotificationService()
library_with_sms = Library(book_repo, patron_repo, sms_service)
# Checkout a book and send an SMS notification
library_with_sms.checkout_book('The Gita', 'Arjuna')        

Benefits of DIP in this Scenario:

• Decoupling: The Library class is no longer tied to a specific notification implementation. This makes it easier to extend the system with new types of notifications in the future.
• Flexibility: We can switch out different notification services (email, SMS, push notifications) without modifying the Library class. This makes the code more flexible and open to future changes.
• Testability: The abstraction makes it easier to mock or stub NotificationService in unit tests, improving testability.

Conclusion

By aligning the wisdom of the Bhagavad Gita with modern software design principles, we can not only write better code but also develop a more thoughtful approach to our work. Just as the Gita teaches us to act with purpose and adaptability, SOLID principles guide us in creating software that is open to change, robust in its design, and fulfilling its role efficiently. This philosophical grounding provides not only technical insight but also personal growth in our journey as developers.