Software Design Principles with Python Example

Software Design Principles Software design is a fundamental process in developing scalable, maintainable, and efficient applications. To achieve this, various principles have been established to help developers create high-quality software. Below, we will explore some of the most important principles along with a practical example in Python. Fundamental Principles 1.Single Responsibility Principle (SRP) Each class or module should have a single reason to change. This means a class should focus on one functionality. 2. Open/Closed Principle (OCP) Software should be open for extension but closed for modification. New functionalities should be added without changing existing code. 3. Liskov Substitution Principle (LSP) Subclass objects should be replaceable with superclass objects without altering program functionality. 4. Interface Segregation Principle (ISP) No client should be forced to depend on interfaces it does not use. Large interfaces should be divided into smaller, more specific ones. 5. Dependency Inversion Principle (DIP) High-level modules should not depend on low-level modules but on abstractions. This enhances software maintainability and scalability. Example in Python Let's imagine a notification system that follows the Dependency Inversion Principle (DIP). Instead of having a service depend directly on a specific implementation (such as email or SMS notifications), we use an abstraction to make the system flexible and easy to extend. from abc import ABC, abstractmethod # Interface for different types of notifications class Notifier(ABC): @abstractmethod def send(self, message: str): pass # Notifier implementation for email class EmailNotifier(Notifier): def send(self, message: str): print(f"Sending email: {message}") # Notifier implementation for SMS class SMSNotifier(Notifier): def send(self, message: str): print(f"Sending SMS: {message}") # Class using abstraction, avoiding direct dependency on a specific implementation class NotificationService: def init(self, notifier: Notifier): self.notifier = notifier def notify_user(self, message: str): self.notifier.send(message) # Using the system email_notifier = EmailNotifier() service = NotificationService(email_notifier) service.notify_user("Your order has been shipped.") sms_notifier = SMSNotifier() service_sms = NotificationService(sms_notifier) service_sms.notify_user("Your verification code is 1234.") Explanation of the Example We define an interface (Notifier) with an abstract send() method, allowing new notification methods to be added without modifying existing code. EmailNotifier and SMSNotifier implement the interface and define the send() method. NotificationService depends on the Notifier abstraction rather than a specific implementation, adhering to the Dependency Inversion Principle (DIP). Conclusion Applying software design principles improves code structure and quality, making it more flexible and maintainable. In this example, we demonstrated how DIP helps decouple components and facilitate system extension without modifying existing code. Link de github del ejemplo https://github.com/juanjosee15/principios-diseno-software.git

Mar 28, 2025 - 07:03

Software Design Principles

Software design is a fundamental process in developing scalable, maintainable, and efficient applications. To achieve this, various principles have been established to help developers create high-quality software. Below, we will explore some of the most important principles along with a practical example in Python.

Fundamental Principles

1.Single Responsibility Principle (SRP)

Each class or module should have a single reason to change. This means a class should focus on one functionality.

2. Open/Closed Principle (OCP)

Software should be open for extension but closed for modification. New functionalities should be added without changing existing code.

3. Liskov Substitution Principle (LSP)

Subclass objects should be replaceable with superclass objects without altering program functionality.

4. Interface Segregation Principle (ISP)

No client should be forced to depend on interfaces it does not use. Large interfaces should be divided into smaller, more specific ones.

5. Dependency Inversion Principle (DIP)

High-level modules should not depend on low-level modules but on abstractions. This enhances software maintainability and scalability.

Example in Python

Let's imagine a notification system that follows the Dependency Inversion Principle (DIP). Instead of having a service depend directly on a specific implementation (such as email or SMS notifications), we use an abstraction to make the system flexible and easy to extend.

from abc import ABC, abstractmethod

# Interface for different types of notifications
class Notifier(ABC):
    @abstractmethod
    def send(self, message: str):
        pass

# Notifier implementation for email
class EmailNotifier(Notifier):
    def send(self, message: str):
        print(f"Sending email: {message}")

# Notifier implementation for SMS
class SMSNotifier(Notifier):
    def send(self, message: str):
        print(f"Sending SMS: {message}")

# Class using abstraction, avoiding direct dependency on a specific implementation
class NotificationService:
    def __init__(self, notifier: Notifier):
        self.notifier = notifier

    def notify_user(self, message: str):
        self.notifier.send(message)

# Using the system
email_notifier = EmailNotifier()
service = NotificationService(email_notifier)
service.notify_user("Your order has been shipped.")

sms_notifier = SMSNotifier()
service_sms = NotificationService(sms_notifier)
service_sms.notify_user("Your verification code is 1234.")

Explanation of the Example

We define an interface (Notifier) with an abstract send() method, allowing new notification methods to be added without modifying existing code.
EmailNotifier and SMSNotifier implement the interface and define the send() method.
NotificationService depends on the Notifier abstraction rather than a specific implementation, adhering to the Dependency Inversion Principle (DIP).

Conclusion

Applying software design principles improves code structure and quality, making it more flexible and maintainable. In this example, we demonstrated how DIP helps decouple components and facilitate system extension without modifying existing code.

Link de github del ejemplo

https://github.com/juanjosee15/principios-diseno-software.git