Software engineering principles - Full Explanation

Introduction

Building software can be complex and prone to errors. Without clear guidelines, projects may become hard to manage, maintain, or improve. Software engineering principles help solve these problems by providing simple rules to write better code and organize work effectively.

Explanation

Single Responsibility Principle

Each part of a software program should have one clear job or responsibility. This makes it easier to understand, test, and fix problems because changes in one part do not affect others. It helps keep the code clean and focused.

Every module or class should have only one reason to change.

Open/Closed Principle

Software components should be open to adding new features but closed to changing existing code. This means you can extend the program without breaking what already works. It encourages building flexible and stable systems.

You can add new behavior without modifying existing code.

Liskov Substitution Principle

Objects of a parent type should be replaceable with objects of a child type without causing errors. This ensures that new parts fit smoothly into the existing system and behave as expected. It supports reliable and predictable code reuse.

Subtypes must be usable in place of their base types without issues.

Interface Segregation Principle

Clients should not be forced to depend on interfaces they do not use. Instead of one large interface, many small and specific interfaces are better. This reduces unnecessary complexity and makes the system easier to understand and maintain.

Use many specific interfaces rather than one general-purpose interface.

Dependency Inversion Principle

High-level modules should not depend on low-level modules directly; both should depend on abstractions. This means the details depend on ideas, not the other way around. It helps create flexible and decoupled systems that are easier to change.

Depend on abstractions, not on concrete implementations.

Real World Analogy

Imagine building a house where each worker has a clear job: the plumber handles pipes, the electrician handles wiring, and the carpenter builds furniture. The design allows adding new rooms without tearing down walls, and new workers can replace old ones without disrupting the house.

Single Responsibility Principle → Each worker has one clear job, like the plumber only fixing pipes.

Open/Closed Principle → Adding a new room without changing the existing structure.

Liskov Substitution Principle → Replacing one carpenter with another who does the same job well.

Interface Segregation Principle → Workers only needing tools and instructions relevant to their job.

Dependency Inversion Principle → Workers following a blueprint (abstraction) rather than depending on each other directly.

Diagram

Diagram

┌─────────────────────────────┐
│     Software Engineering     │
│         Principles           │
├─────────────┬───────────────┤
│ Single Resp │ Open/Closed   │
│ Principle   │ Principle     │
├─────────────┼───────────────┤
│ Liskov Sub  │ Interface     │
│ Principle   │ Segregation   │
├─────────────┼───────────────┤
│ Dependency  │               │
│ Inversion   │               │
│ Principle   │               │
└─────────────┴───────────────┘

A simple box diagram showing the five main software engineering principles grouped together.

Key Facts

Single Responsibility Principle → A class or module should have only one reason to change.

Open/Closed Principle → Software entities should be open for extension but closed for modification.

Liskov Substitution Principle → Subtypes must be substitutable for their base types without altering correctness.

Interface Segregation Principle → Clients should not be forced to depend on interfaces they do not use.

Dependency Inversion Principle → Depend on abstractions, not on concrete implementations.

Common Confusions

Believing Single Responsibility means one function or method per class.

Believing Single Responsibility means one function or method per class. Single Responsibility means one reason to change, which can include multiple related functions working together.

Thinking Open/Closed Principle means never changing code.

Thinking Open/Closed Principle means never changing code. It means avoid changing existing code for new features; instead, extend code safely.

Assuming Dependency Inversion means no dependencies at all.

Assuming Dependency Inversion means no dependencies at all. It means depend on abstract ideas (interfaces), not on specific details.

Summary

Software engineering principles guide how to write clear, flexible, and maintainable code.

Each principle focuses on reducing complexity and making software easier to change safely.

Following these principles helps teams build better software that lasts longer and adapts well.

Practice

1. Which software engineering principle encourages writing code that does one thing and does it well?

easy

A. Open/Closed Principle

B. Don't Repeat Yourself (DRY)

C. Single Responsibility Principle (SRP)

D. Keep It Simple, Stupid (KISS)

Solution

1. Step 1: Understand the principle names

   SRP means each module or class should have one responsibility or reason to change.

2. Step 2: Match the description to the principle

   Writing code that does one thing well matches SRP.

3. Final Answer:

   Single Responsibility Principle (SRP) -> Option C

4. Quick Check:

   One responsibility = SRP [OK]

Hint: One job per module means SRP [OK]

Common Mistakes:

• Confusing SRP with DRY which avoids repetition
• Thinking KISS means single responsibility
• Mixing Open/Closed with SRP

2. Which of the following is the correct description of the DRY principle?

easy

A. Avoid duplicating code or logic in multiple places

B. Keep code as simple as possible

C. Design software to be open for extension but closed for modification

D. Each class should have only one reason to change

Solution

1. Step 1: Recall DRY meaning

   DRY stands for "Don't Repeat Yourself", meaning avoid code duplication.

2. Step 2: Match option to DRY

   Avoid duplicating code or logic in multiple places says avoid duplicating code or logic, which matches DRY.

3. Final Answer:

   Avoid duplicating code or logic in multiple places -> Option A

4. Quick Check:

   DRY = no repetition [OK]

Hint: DRY means no repeated code [OK]

Common Mistakes:

• Confusing DRY with Open/Closed principle
• Mixing DRY with KISS which is about simplicity
• Thinking DRY means single responsibility

3. Consider this code snippet applying the KISS principle:

def calculate_area(radius):
    return 3.14 * radius * radius

area = calculate_area(5)
print(area)

What will be the output?

medium

A. 31.4

B. 78.5

C. Error due to missing import

D. None

Solution

1. Step 1: Calculate area using formula

   Area = π * radius² = 3.14 * 5 * 5 = 3.14 * 25 = 78.5

2. Step 2: Check code output

   The function returns 78.5 and print outputs it.

3. Final Answer:

   78.5 -> Option B

4. Quick Check:

   3.14 * 25 = 78.5 [OK]

Hint: Multiply π by radius squared for area [OK]

Common Mistakes:

• Using 2 * π * r (circumference) instead of area formula
• Expecting error due to missing math module (not needed here)
• Confusing output with None from missing return

4. Identify the error in this code violating the Open/Closed Principle:

class Shape:
    def area(self, shape_type, size):
        if shape_type == 'circle':
            return 3.14 * size * size
        elif shape_type == 'square':
            return size * size
        else:
            return 0

medium

A. The class is closed for modification

B. The method is open for extension without changes

C. The code uses inheritance properly

D. The area method uses conditional logic to handle multiple shapes

Solution

1. Step 1: Understand Open/Closed Principle

   It says software entities should be open for extension but closed for modification.

2. Step 2: Analyze the area method

   The method uses if-else to handle different shapes, so adding a new shape requires modifying this method.

3. Final Answer:

   The area method uses conditional logic to handle multiple shapes -> Option D

4. Quick Check:

   Conditional logic breaks Open/Closed [OK]

Hint: If-else for types breaks Open/Closed [OK]

Common Mistakes:

• Thinking inheritance is used properly here
• Believing the class is closed for modification
• Confusing open for extension with modifying code

5. You want to refactor this code to follow the Single Responsibility Principle (SRP):

class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email
    def save_to_database(self):
        # code to save user data
        pass
    def send_welcome_email(self):
        # code to send email
        pass

What is the best way to apply SRP here?

hard

A. Move save_to_database to a separate DatabaseHandler class

B. Keep all methods in User class since they relate to user

C. Combine both methods into one method for simplicity

D. Remove send_welcome_email method entirely

Solution

1. Step 1: Understand SRP

   SRP says a class should have only one reason to change, so User should only hold user data.

2. Step 2: Identify responsibilities

   Saving to database and sending emails are separate concerns from user data storage.

3. Step 3: Refactor accordingly

   Move save_to_database to a DatabaseHandler class to separate concerns.

4. Final Answer:

   Move save_to_database to a separate DatabaseHandler class -> Option A

5. Quick Check:

   Separate responsibilities = SRP applied [OK]

Hint: One class, one reason to change means separate concerns [OK]

Common Mistakes:

• Keeping all methods in one class breaks SRP
• Combining methods increases complexity
• Removing functionality instead of refactoring