Pattern selection guidelines in Software Engineering - Mini Project: Build & Apply

Pattern Selection Guidelines

📖 Scenario: You are a software engineer working on a new project. You need to choose the best design pattern to solve common problems in your code. Understanding how to select the right pattern will help you write clean, maintainable software.

🎯 Goal: Build a simple guide that lists common software design problems and matches each with the best design pattern to use. This will help you quickly decide which pattern fits your needs.

📋 What You'll Learn

Create a dictionary called problems with exact problem descriptions as keys and example situations as values

Create a variable called pattern_criteria that holds a list of key factors to consider when selecting a pattern

Use a for loop with variables problem and example to iterate over problems.items() and create a new dictionary pattern_suggestions that assigns a suitable pattern to each problem

Add a final key-value pair to pattern_suggestions for the problem 'Need to create objects without specifying exact classes' with the pattern 'Factory Method'

💡 Why This Matters

🌍 Real World

Software engineers often need to select the right design pattern to solve common coding problems efficiently and maintainably.

💼 Career

Understanding pattern selection helps developers write better code, communicate design decisions clearly, and improve software quality.

1

Create the initial problem dictionary

Create a dictionary called problems with these exact entries: 'Need to separate object construction from representation' with value 'Building complex objects step by step', 'Need to ensure a class has only one instance' with value 'Managing a single database connection', and 'Need to define a family of algorithms' with value 'Sorting data in different ways'.

Software Engineering

# Create the dictionary called problems with exact entries
# Your code here

Hint

Use curly braces to create the dictionary and include the exact keys and values as strings.

2

Add pattern selection criteria list

Create a list called pattern_criteria with these exact strings: 'Problem type', 'Complexity', and 'Reusability'.

Software Engineering

problems = {
    'Need to separate object construction from representation': 'Building complex objects step by step',
    'Need to ensure a class has only one instance': 'Managing a single database connection',
    'Need to define a family of algorithms': 'Sorting data in different ways'
}
# Create the list pattern_criteria with exact strings
# Your code here

Hint

Use square brackets to create the list and include the exact strings in order.

3

Create pattern suggestions dictionary using a loop

Use a for loop with variables problem and example to iterate over problems.items(). Inside the loop, create a dictionary called pattern_suggestions and assign these exact pattern matches: for 'Need to separate object construction from representation' assign 'Builder', for 'Need to ensure a class has only one instance' assign 'Singleton', and for 'Need to define a family of algorithms' assign 'Strategy'.

Software Engineering

problems = {
    'Need to separate object construction from representation': 'Building complex objects step by step',
    'Need to ensure a class has only one instance': 'Managing a single database connection',
    'Need to define a family of algorithms': 'Sorting data in different ways'
}
pattern_criteria = ['Problem type', 'Complexity', 'Reusability']
# Use a for loop to create pattern_suggestions dictionary with exact pattern matches
# Your code here

Hint

Initialize an empty dictionary before the loop. Use if-elif statements inside the loop to assign patterns based on the problem key.

4

Add final pattern suggestion entry

Add a new key-value pair to the pattern_suggestions dictionary with key 'Need to create objects without specifying exact classes' and value 'Factory Method'.

Software Engineering

problems = {
    'Need to separate object construction from representation': 'Building complex objects step by step',
    'Need to ensure a class has only one instance': 'Managing a single database connection',
    'Need to define a family of algorithms': 'Sorting data in different ways'
}
pattern_criteria = ['Problem type', 'Complexity', 'Reusability']
pattern_suggestions = {}
for problem, example in problems.items():
    if problem == 'Need to separate object construction from representation':
        pattern_suggestions[problem] = 'Builder'
    elif problem == 'Need to ensure a class has only one instance':
        pattern_suggestions[problem] = 'Singleton'
    elif problem == 'Need to define a family of algorithms':
        pattern_suggestions[problem] = 'Strategy'
# Add the final key-value pair to pattern_suggestions
# Your code here

Hint

Use the dictionary key assignment syntax to add the new entry after the loop.

Practice

1. Which of the following best describes the main purpose of design patterns in software engineering?

easy

A. Make software run faster

B. Increase the number of lines of code

C. Provide reusable solutions to common design problems

D. Replace the need for testing

Solution

1. Step 1: Understand what design patterns are

   Design patterns are proven ways to solve common problems in software design.

2. Step 2: Identify the main goal of design patterns

   The main goal is to provide reusable, clear, and flexible solutions, not to speed up code or replace testing.

3. Final Answer:

   Provide reusable solutions to common design problems -> Option C

4. Quick Check:

   Design patterns = reusable solutions [OK]

Hint: Design patterns solve common problems clearly [OK]

Common Mistakes:

• Thinking patterns improve performance directly
• Believing patterns replace testing
• Assuming patterns increase code size intentionally

2. Which guideline is important when selecting a design pattern?

easy

A. Select a pattern based on the problem context and goals

B. Pick patterns randomly to explore options

C. Always use the Singleton pattern for all problems

D. Choose the pattern that adds the most code

Solution

1. Step 1: Review pattern selection criteria

   Patterns should be chosen based on the specific problem and what you want to achieve.

2. Step 2: Eliminate incorrect choices

   Adding unnecessary code, always using one pattern, or random selection are poor practices.

3. Final Answer:

   Select a pattern based on the problem context and goals -> Option A

4. Quick Check:

   Pattern choice = problem context [OK]

Hint: Match pattern to problem context and goals [OK]

Common Mistakes:

• Using one pattern for all problems
• Choosing patterns without understanding the problem
• Adding complexity unnecessarily

3. Consider this scenario: You want to ensure only one instance of a class exists and provide a global access point. Which design pattern fits best?

medium

A. Singleton

B. Observer

C. Factory

D. Decorator

Solution

1. Step 1: Understand the problem requirements

   Only one instance and global access means controlling object creation strictly.

2. Step 2: Match the problem to the pattern

   The Singleton pattern ensures a single instance and provides global access.

3. Final Answer:

   Singleton -> Option A

4. Quick Check:

   Single instance + global access = Singleton [OK]

Hint: Single instance + global access = Singleton pattern [OK]

Common Mistakes:

• Confusing Singleton with Factory
• Choosing Observer which is for event handling
• Selecting Decorator which adds behavior

4. You have a design pattern implementation that tightly couples objects, making future changes difficult. What is the likely issue?

medium

A. Applying the Observer pattern correctly

B. Using too many interfaces

C. Following the pattern selection guidelines perfectly

D. Incorrect pattern selection ignoring flexibility

Solution

1. Step 1: Analyze the problem of tight coupling

   Tight coupling reduces flexibility and makes changes hard.

2. Step 2: Identify cause related to pattern choice

   Choosing a pattern that does not promote loose coupling causes this issue.

3. Final Answer:

   Incorrect pattern selection ignoring flexibility -> Option D

4. Quick Check:

   Tight coupling = wrong pattern choice [OK]

Hint: Tight coupling means wrong pattern choice [OK]

Common Mistakes:

• Assuming interfaces cause tight coupling
• Thinking Observer always reduces coupling
• Believing perfect guideline following causes issues

5. You need to design a system that can dynamically add responsibilities to objects without affecting others. Which pattern should you select and why?

hard

A. Singleton, because it restricts object creation

B. Decorator, because it adds behavior dynamically without changing original objects

C. Factory, because it creates objects based on input

D. Adapter, because it changes interface of objects

Solution

1. Step 1: Understand the requirement for dynamic behavior addition

   The system needs to add responsibilities at runtime without altering others.

2. Step 2: Match requirement to pattern characteristics

   The Decorator pattern allows adding behavior dynamically to individual objects.

3. Step 3: Eliminate other options

   Singleton restricts instances, Factory creates objects, Adapter changes interfaces, none add behavior dynamically.

4. Final Answer:

   Decorator, because it adds behavior dynamically without changing original objects -> Option B

5. Quick Check:

   Dynamic behavior addition = Decorator [OK]

Hint: Add behavior dynamically? Use Decorator pattern [OK]

Common Mistakes:

• Confusing Decorator with Adapter
• Choosing Singleton for behavior addition
• Thinking Factory adds responsibilities