Software engineering principles - Mini Project: Build & Apply

Understanding Software Engineering Principles

📖 Scenario: You are part of a small software team building a simple app. To keep your work organized and efficient, you need to understand some basic software engineering principles.

🎯 Goal: Build a simple list of key software engineering principles with their brief descriptions to help your team remember and apply them.

📋 What You'll Learn

Create a dictionary called principles with exact principle names as keys and their descriptions as values.

Add a variable called min_length to set the minimum length of principle descriptions to consider.

Use a dictionary comprehension to create a new dictionary filtered_principles containing only principles with descriptions longer than min_length.

Add a final key-value pair to filtered_principles to include a summary principle.

💡 Why This Matters

🌍 Real World

Software engineers use principles like modularity and encapsulation to build reliable and maintainable software systems.

💼 Career

Understanding and applying software engineering principles is essential for writing clean code, collaborating in teams, and managing complex projects.

1

Create the initial principles dictionary

Create a dictionary called principles with these exact entries: 'Modularity' with description 'Divide the system into separate components.', 'Encapsulation' with description 'Hide internal details and expose only necessary parts.', and 'DRY' with description 'Don\'t Repeat Yourself - avoid code duplication.'.

Software Engineering

# Create the principles dictionary with exact entries
# Your code here

Hint

Use curly braces to create a dictionary with keys and values as strings.

2

Add a minimum description length variable

Add a variable called min_length and set it to 30 to filter principles by description length.

Software Engineering

principles = {
    'Modularity': 'Divide the system into separate components.',
    'Encapsulation': 'Hide internal details and expose only necessary parts.',
    'DRY': 'Don\'t Repeat Yourself - avoid code duplication.'
}
# Add min_length variable below
# Your code here

Hint

Set min_length to 30 using a simple assignment.

3

Filter principles by description length

Use a dictionary comprehension to create a new dictionary called filtered_principles that includes only those entries from principles where the description length is greater than min_length.

Software Engineering

principles = {
    'Modularity': 'Divide the system into separate components.',
    'Encapsulation': 'Hide internal details and expose only necessary parts.',
    'DRY': 'Don\'t Repeat Yourself - avoid code duplication.'
}
min_length = 30
# Create filtered_principles dictionary using comprehension
# Your code here

Hint

Use {key: desc for key, desc in principles.items() if len(desc) > min_length} to filter.

4

Add a summary principle to filtered dictionary

Add a new key-value pair to filtered_principles with key 'Summary' and value 'Apply principles to write clean and maintainable code.'.

Software Engineering

principles = {
    'Modularity': 'Divide the system into separate components.',
    'Encapsulation': 'Hide internal details and expose only necessary parts.',
    'DRY': 'Don\'t Repeat Yourself - avoid code duplication.'
}
min_length = 30
filtered_principles = {key: desc for key, desc in principles.items() if len(desc) > min_length}
# Add the summary principle below
# Your code here

Hint

Use filtered_principles['Summary'] = 'Apply principles to write clean and maintainable code.' to add the new entry.

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