The Project | About Us | Contribute | Donations | License

HOME

Introduction

The SOLID principles are a set of five design principles intended to make software designs more understandable, flexible, and maintainable. These principles were introduced by Robert C. Martin, also known as Uncle Bob, and are widely regarded as best practices in object-oriented software development.

What are the SOLID Principles?

The SOLID acronym stands for:

Single Responsibility Principle (SRP)
Open/Closed Principle (OCP)
Liskov Substitution Principle (LSP)
Interface Segregation Principle (ISP)
Dependency Inversion Principle (DIP)

Single Responsibility Principle (SRP)

Definition

A class should have only one reason to change, meaning it should have only one job or responsibility.

Explanation

Single Responsibility: Each class should focus on a single task or responsibility.
Reason to Change: If a class has more than one responsibility, it has more than one reason to change. This can lead to a fragile design where changes in one part of the class affect other parts.

Example

class User:
    def __init__(self, username, email):
        self.username = username
        self.email = email

    def save_to_database(self):
        # Code to save user to database
        pass

    def send_email(self, message):
        # Code to send an email
        pass

Refactored Example:

class User:
    def __init__(self, username, email):
        self.username = username
        self.email = email

class UserRepository:
    def save_to_database(self, user):
        # Code to save user to database
        pass

class EmailService:
    def send_email(self, user, message):
        # Code to send an email
        pass

Exercise

Task: Refactor the following class to adhere to the Single Responsibility Principle.

class Report:
    def __init__(self, title, content):
        self.title = title
        self.content = content

    def generate_pdf(self):
        # Code to generate PDF
        pass

    def send_email(self, recipient):
        # Code to send email
        pass

Solution:

class Report:
    def __init__(self, title, content):
        self.title = title
        self.content = content

class PDFGenerator:
    def generate_pdf(self, report):
        # Code to generate PDF
        pass

class EmailService:
    def send_email(self, recipient, report):
        # Code to send email
        pass

Open/Closed Principle (OCP)

Definition

Software entities (classes, modules, functions, etc.) should be open for extension but closed for modification.

Explanation

Open for Extension: You should be able to add new functionality to a class.
Closed for Modification: You should not modify existing code to add new functionality.

Example

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

class AreaCalculator:
    def calculate_area(self, shapes):
        total_area = 0
        for shape in shapes:
            if isinstance(shape, Rectangle):
                total_area += shape.width * shape.height
        return total_area

Refactored Example:

class Shape:
    def area(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

class AreaCalculator:
    def calculate_area(self, shapes):
        total_area = 0
        for shape in shapes:
            total_area += shape.area()
        return total_area

Exercise

Task: Refactor the following code to adhere to the Open/Closed Principle.

class Circle:
    def __init__(self, radius):
        self.radius = radius

class AreaCalculator:
    def calculate_area(self, shapes):
        total_area = 0
        for shape in shapes:
            if isinstance(shape, Circle):
                total_area += 3.14 * shape.radius * shape.radius
        return total_area

Solution:

class Shape:
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

class AreaCalculator:
    def calculate_area(self, shapes):
        total_area = 0
        for shape in shapes:
            total_area += shape.area()
        return total_area

Liskov Substitution Principle (LSP)

Definition

Objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program.

Explanation

Substitutability: Subclasses should be substitutable for their base classes.
Behavioral Consistency: Subclasses should behave in a way that does not break the functionality of the base class.

Example

class Bird:
    def fly(self):
        pass

class Sparrow(Bird):
    def fly(self):
        print("Sparrow flying")

class Ostrich(Bird):
    def fly(self):
        raise Exception("Ostrich can't fly")

Refactored Example:

class Bird:
    pass

class FlyingBird(Bird):
    def fly(self):
        pass

class Sparrow(FlyingBird):
    def fly(self):
        print("Sparrow flying")

class Ostrich(Bird):
    pass

Exercise

Task: Refactor the following code to adhere to the Liskov Substitution Principle.

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def set_width(self, width):
        self.width = width

    def set_height(self, height):
        self.height = height

class Square(Rectangle):
    def set_width(self, width):
        self.width = width
        self.height = width

    def set_height(self, height):
        self.width = height
        self.height = height

Solution:

class Shape:
    pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def set_width(self, width):
        self.width = width

    def set_height(self, height):
        self.height = height

class Square(Shape):
    def __init__(self, side):
        self.side = side

    def set_side(self, side):
        self.side = side

Interface Segregation Principle (ISP)

Definition

A client should not be forced to depend on interfaces it does not use.

Explanation

Specific Interfaces: Create specific interfaces for different clients.
Avoid Fat Interfaces: Avoid creating large interfaces that include methods not used by all clients.

Example

class Worker:
    def work(self):
        pass

    def eat(self):
        pass

class HumanWorker(Worker):
    def work(self):
        print("Human working")

    def eat(self):
        print("Human eating")

class RobotWorker(Worker):
    def work(self):
        print("Robot working")

    def eat(self):
        raise Exception("Robot can't eat")

Refactored Example:

class Workable:
    def work(self):
        pass

class Eatable:
    def eat(self):
        pass

class HumanWorker(Workable, Eatable):
    def work(self):
        print("Human working")

    def eat(self):
        print("Human eating")

class RobotWorker(Workable):
    def work(self):
        print("Robot working")

Exercise

Task: Refactor the following code to adhere to the Interface Segregation Principle.

class Printer:
    def print_document(self, document):
        pass

    def scan_document(self, document):
        pass

class BasicPrinter(Printer):
    def print_document(self, document):
        print("Printing document")

    def scan_document(self, document):
        raise Exception("Basic printer can't scan")

Solution:

class Printable:
    def print_document(self, document):
        pass

class Scannable:
    def scan_document(self, document):
        pass

class BasicPrinter(Printable):
    def print_document(self, document):
        print("Printing document")

Dependency Inversion Principle (DIP)

Definition

High-level modules should not depend on low-level modules. Both should depend on abstractions. Abstractions should not depend on details. Details should depend on abstractions.

Explanation

High-Level Modules: These modules contain the business logic.
Low-Level Modules: These modules contain the implementation details.
Abstractions: Interfaces or abstract classes that define the contract between high-level and low-level modules.

Example

class LightBulb:
    def turn_on(self):
        print("LightBulb: Bulb turned on")

    def turn_off(self):
        print("LightBulb: Bulb turned off")

class Switch:
    def __init__(self, bulb):
        self.bulb = bulb

    def operate(self, command):
        if command == "ON":
            self.bulb.turn_on()
        elif command == "OFF":
            self.bulb.turn_off()

Refactored Example:

class Switchable:
    def turn_on(self):
        pass

    def turn_off(self):
        pass

class LightBulb(Switchable):
    def turn_on(self):
        print("LightBulb: Bulb turned on")

    def turn_off(self):
        print("LightBulb: Bulb turned off")

class Switch:
    def __init__(self, device):
        self.device = device

    def operate(self, command):
        if command == "ON":
            self.device.turn_on()
        elif command == "OFF":
            self.device.turn_off()

Exercise

Task: Refactor the following code to adhere to the Dependency Inversion Principle.

class Keyboard:
    def type(self):
        print("Typing")

class Computer:
    def __init__(self):
        self.keyboard = Keyboard()

    def use_keyboard(self):
        self.keyboard.type()

Solution:

class Typable:
    def type(self):
        pass

class Keyboard(Typable):
    def type(self):
        print("Typing")

class Computer:
    def __init__(self, keyboard):
        self.keyboard = keyboard

    def use_keyboard(self):
        self.keyboard.type()

Conclusion

The SOLID principles are fundamental guidelines for designing robust, maintainable, and scalable software architectures. By adhering to these principles, you can create systems that are easier to understand, extend, and maintain. Each principle addresses a specific aspect of software design, and together they form a comprehensive approach to building high-quality software systems.

System Architectures: Principles and Practices for Designing Robust and Scalable Technological Architectures

SOLID Principles

Introduction

What are the SOLID Principles?

Single Responsibility Principle (SRP)

Definition

Explanation

Example

Exercise

Open/Closed Principle (OCP)

Definition

Explanation

Example

Exercise

Liskov Substitution Principle (LSP)

Definition

Explanation

Example

Exercise

Interface Segregation Principle (ISP)

Definition

Explanation

Example

Exercise

Dependency Inversion Principle (DIP)

Definition

Explanation

Example

Exercise

Conclusion

System Architectures: Principles and Practices for Designing Robust and Scalable Technological Architectures

Module 1: Introduction to System Architectures

Module 2: Design Principles of Architectures

Module 3: Components of a System Architecture

Module 4: Scalability and Performance

Module 5: Security in System Architectures

Module 6: Tools and Technologies

Module 7: Case Studies and Practical Examples

Module 8: Trends and Future of System Architectures