Design for change and extensibility in Software Engineering - Mini Project: Build & Apply

Design for Change and Extensibility

📖 Scenario: You are working on a simple software system that manages notifications for users. The system currently supports only email notifications, but you want to prepare it so that it can easily add other notification types like SMS or push notifications in the future.

🎯 Goal: Build a basic design structure that supports easy addition of new notification types without changing existing code. You will create a simple setup, add a configuration variable, implement the core logic to send notifications, and complete the design to allow future extensibility.

📋 What You'll Learn

Create a dictionary called notifications with one entry: 'email': 'Send email notification'

Add a variable called default_notification set to 'email'

Write a function called send_notification that takes a method parameter and returns the message from notifications for that method

Add a new notification type 'sms' with the message 'Send SMS notification' to the notifications dictionary

💡 Why This Matters

🌍 Real World

Designing software that can easily adapt to new requirements, like adding new notification channels without rewriting existing code.

💼 Career

Software engineers often need to write code that is easy to maintain and extend. This project teaches a basic approach to achieve that.

1

DATA SETUP: Create the initial notifications dictionary

Create a dictionary called notifications with one entry: 'email': 'Send email notification'

Software Engineering

# Create the notifications dictionary with email notification
# Your code here

Hint

Use curly braces {} to create a dictionary with the key 'email' and its message.

2

CONFIGURATION: Add the default notification method

Add a variable called default_notification and set it to the string 'email'

Software Engineering

notifications = {'email': 'Send email notification'}
# Add the default_notification variable
# Your code here

Hint

Just assign the string 'email' to the variable default_notification.

3

CORE LOGIC: Write the send_notification function

Write a function called send_notification that takes a parameter method and returns the message from the notifications dictionary for that method

Software Engineering

notifications = {'email': 'Send email notification'}
default_notification = 'email'

# Define send_notification function
# Your code here

Hint

Use the dictionary get method to safely get the message for the given method.

4

COMPLETION: Add SMS notification to the dictionary

Add a new entry to the notifications dictionary with key 'sms' and value 'Send SMS notification'

Software Engineering

notifications = {'email': 'Send email notification'}
default_notification = 'email'

def send_notification(method):
    return notifications.get(method, 'Notification method not supported')

# Add SMS notification to notifications dictionary
# Your code here

Hint

Add the new key-value pair inside the notifications dictionary.

Practice

1. What does design for change primarily aim to achieve in software development?

easy

A. Make it easy to update and modify software without major rewrites

B. Create software that never needs updates

C. Focus only on the initial release speed

D. Avoid adding new features after launch

Solution

1. Step 1: Understand the meaning of design for change

   Design for change means planning software so it can be updated or modified easily later.

2. Step 2: Identify the goal of this approach

   The goal is to avoid major rewrites and reduce effort when changes are needed.

3. Final Answer:

   Make it easy to update and modify software without major rewrites -> Option A

4. Quick Check:

   Design for change = easy updates [OK]

Hint: Think about software that adapts easily to updates [OK]

Common Mistakes:

• Assuming software never needs updates
• Confusing speed of initial release with flexibility
• Believing no new features should be added

2. Which of the following is a correct principle to support extensibility in software design?

easy

A. Always rewrite existing code when adding features

B. Hardcode all feature options to prevent changes

C. Avoid modular design to keep code simple

D. Use the Open/Closed Principle to allow adding features without changing existing code

Solution

1. Step 1: Recall the Open/Closed Principle

   This principle states software entities should be open for extension but closed for modification.

2. Step 2: Match principle to extensibility

   It allows adding new features without changing existing code, supporting extensibility.

3. Final Answer:

   Use the Open/Closed Principle to allow adding features without changing existing code -> Option D

4. Quick Check:

   Open/Closed Principle = extensibility [OK]

Hint: Remember Open/Closed means extend without changing [OK]

Common Mistakes:

• Thinking rewriting existing code is needed
• Avoiding modular design reduces flexibility
• Hardcoding features limits extensibility

3. Consider a software module designed with interfaces to add new payment methods without changing existing code. What is the main benefit of this design?

medium

A. It forces rewriting the entire payment system for each new method

B. It allows adding new payment methods easily without breaking existing ones

C. It prevents adding any new payment methods

D. It makes the code harder to maintain due to complexity

Solution

1. Step 1: Understand interface-based design

   Interfaces let you add new features by implementing new classes without changing existing code.

2. Step 2: Identify the benefit for payment methods

   This means new payment methods can be added easily without affecting current ones.

3. Final Answer:

   It allows adding new payment methods easily without breaking existing ones -> Option B

4. Quick Check:

   Interfaces enable easy feature addition [OK]

Hint: Interfaces help add features without breaking old code [OK]

Common Mistakes:

• Assuming entire system must be rewritten
• Thinking new methods are blocked
• Believing complexity always increases maintenance difficulty

4. A developer wrote code that tightly couples modules, making it hard to add new features. What is the main design flaw here?

medium

A. Using interfaces to separate concerns

B. Good modular design with loose coupling

C. Tight coupling reduces extensibility and increases change difficulty

D. Following the Open/Closed Principle correctly

Solution

1. Step 1: Define tight coupling

   Tight coupling means modules depend heavily on each other, making changes risky.

2. Step 2: Understand impact on extensibility

   This reduces extensibility because adding features requires changing many parts.

3. Final Answer:

   Tight coupling reduces extensibility and increases change difficulty -> Option C

4. Quick Check:

   Tight coupling = hard to extend [OK]

Hint: Loose coupling improves extensibility, tight coupling blocks it [OK]

Common Mistakes:

• Confusing tight coupling with good design
• Thinking interfaces cause tight coupling
• Assuming Open/Closed Principle means tight coupling

5. You have a system that uses a dictionary to map feature names to functions. To design for extensibility, which approach is best when adding new features?

hard

A. Use a plugin system where new features register themselves without changing core code

B. Modify the existing dictionary directly each time a new feature is added

C. Hardcode all features in one large function to avoid dictionary changes

D. Remove old features before adding new ones to keep dictionary small

Solution

1. Step 1: Understand the problem with modifying dictionary directly

   Changing the dictionary each time can cause errors and requires core code changes.

2. Step 2: Explain plugin system advantage

   A plugin system lets new features register themselves independently, keeping core code stable and extensible.

3. Final Answer:

   Use a plugin system where new features register themselves without changing core code -> Option A

4. Quick Check:

   Plugin system = extensibility without core changes [OK]

Hint: Plugins add features without touching core code [OK]

Common Mistakes:

• Directly modifying core dictionaries often
• Hardcoding all features reduces flexibility
• Removing old features unnecessarily