Creational patterns (Singleton, Factory, Builder) in Software Engineering - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to ensure only one instance of the class is created (Singleton pattern).

Software Engineering

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is [1]:
            cls._instance = super().__new__(cls)
        return cls._instance

Drag options to blanks, or click blank then click option'

AFalse

BNone

CTrue

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using False or 0 instead of None causes the check to fail.

The Singleton pattern ensures only one instance exists. Checking if _instance is None means no instance has been created yet.

2fill in blank

medium

Complete the Factory method to create a product based on the type.

Software Engineering

class Factory:
    def create_product(self, product_type):
        if product_type == 'A':
            return ProductA()
        elif product_type == 'B':
            return [1]()
        else:
            return None

Drag options to blanks, or click blank then click option'

AProductB

BProductC

CProductA

DProduct

Attempts:

3 left

💡 Hint

Common Mistakes

Returning ProductA or ProductC for product type 'B' is incorrect.

The Factory method returns an instance of the requested product type. For 'B', it should return ProductB().

3fill in blank

hard

Fix the error in the Builder pattern's build method to return the constructed object.

Software Engineering

class Builder:
    def __init__(self):
        self.product = Product()

    def build(self):
        self.product.add_part('Part1')
        self.product.add_part('Part2')
        return [1]

Drag options to blanks, or click blank then click option'

Aself

Bproduct

Cself.product

DProduct

Attempts:

3 left

💡 Hint

Common Mistakes

Returning self or Product class instead of the product instance.

The build method should return the constructed product object, which is stored in self.product.

4fill in blank

hard

Fill both blanks to complete the Singleton pattern's thread-safe instance retrieval.

Software Engineering

import threading

class Singleton:
    _instance = None
    _lock = threading.Lock()

    @classmethod
    def get_instance(cls):
        with cls.[1]:
            if cls._instance is [2]:
                cls._instance = cls()
        return cls._instance

Drag options to blanks, or click blank then click option'

Alock

Bmutex

CNone

DFalse

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'mutex' instead of 'lock' or checking against False instead of None.

To make Singleton thread-safe, a lock is used. The lock attribute is named lock. The instance is checked against None to see if it needs creation.

5fill in blank

hard

Fill all three blanks to complete a dictionary comprehension that builds a product catalog with prices above zero.

Software Engineering

products = {'apple': 1.2, 'banana': 0, 'cherry': 2.5}
catalog = [1]: [2] for [3] in products.items() if [2] > 0

Drag options to blanks, or click blank then click option'

Aname

Bprice

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up keys and values or using inconsistent variable names.

The dictionary comprehension creates a new dictionary with product names as keys and prices as values, but only includes products with price greater than zero.

Practice

1. Which creational pattern ensures that only one instance of a class is created throughout the application?

easy

A. Singleton

B. Factory

C. Builder

D. Prototype

Solution

1. Step 1: Understand the Singleton pattern purpose

   The Singleton pattern restricts the instantiation of a class to one object only.

2. Step 2: Compare with other patterns

   Factory creates objects but does not limit the number; Builder constructs complex objects step-by-step; Prototype clones objects.

3. Final Answer:

   Singleton -> Option A

4. Quick Check:

   Only one instance = Singleton [OK]

Hint: Singleton = single instance only [OK]

Common Mistakes:

• Confusing Factory with Singleton
• Thinking Builder limits instances
• Mixing Prototype with Singleton

2. Which of the following is the correct way to define a Singleton class in most object-oriented languages?

easy

A. Allow multiple instances but share data between them

B. Build the object step-by-step using a builder

C. Make the constructor private and provide a static method to get the instance

D. Use a factory method to create new instances every time

Solution

1. Step 1: Recall Singleton implementation details

   Singleton classes hide their constructor (make it private) to prevent direct instantiation.

2. Step 2: Provide controlled access

   A static method returns the single instance, creating it if it doesn't exist yet.

3. Final Answer:

   Make the constructor private and provide a static method to get the instance -> Option C

4. Quick Check:

   Private constructor + static getter = Singleton [OK]

Hint: Singleton hides constructor, uses static getter [OK]

Common Mistakes:

• Allowing public constructors in Singleton
• Using factory method to create multiple instances
• Confusing Builder with Singleton syntax

3. Consider the following code snippet using a Factory pattern:

class AnimalFactory {
  createAnimal(type) {
    switch(type) {
      case 'dog': return new Dog();
      case 'cat': return new Cat();
      default: return null;
    }
  }
}

const factory = new AnimalFactory();
const pet = factory.createAnimal('dog');
console.log(pet.sound());

What will be the output if Dog.sound() returns "Woof" and Cat.sound() returns "Meow"?

medium

A. Error: createAnimal is not a function

B. "Meow"

C. null

D. "Woof"

Solution

1. Step 1: Understand the Factory method call

   The factory creates an object based on the string 'dog', so it returns a new Dog instance.

2. Step 2: Call the sound method on the Dog instance

   Since Dog.sound() returns "Woof", the console.log outputs "Woof".

3. Final Answer:

   "Woof" -> Option D

4. Quick Check:

   Factory creates Dog, Dog.sound() = "Woof" [OK]

Hint: Factory returns object by type, call its method [OK]

Common Mistakes:

• Assuming factory returns null for known types
• Confusing Dog and Cat outputs
• Thinking createAnimal is undefined

4. A developer tries to implement a Singleton but writes this code:

class Logger {
  constructor() {
    if (!Logger.instance) {
      Logger.instance = this;
    }
    return Logger.instance;
  }
}

const log1 = new Logger();
const log2 = new Logger();
console.log(log1 === log2);

What is the output and what is the issue with this Singleton implementation?

medium

A. false; constructor allows multiple instances

B. true; but constructor is public which is not ideal

C. true; works perfectly as Singleton

D. Error; cannot assign to Logger.instance

Solution

1. Step 1: Analyze the constructor logic

   The constructor checks if Logger.instance exists; if not, assigns this to it, then returns Logger.instance.

2. Step 2: Check the instance equality

   Both log1 and log2 refer to the same Logger.instance, so log1 === log2 is true.

3. Step 3: Identify the issue

   The constructor is still public, so new Logger() can be called multiple times, which is not ideal for Singleton pattern.

4. Final Answer:

   true; but constructor is public which is not ideal -> Option B

5. Quick Check:

   Same instance but public constructor = A [OK]

Hint: Singleton needs private constructor to prevent multiple calls [OK]

Common Mistakes:

• Assuming public constructor is fine for Singleton
• Thinking output is false due to new calls
• Expecting runtime error on instance assignment

5. You need to create a complex computer object with many optional parts (CPU, RAM, GPU, Storage). Which creational pattern is best suited to build this object step-by-step without confusing the client code?

hard

A. Builder

B. Factory

C. Singleton

D. Prototype

Solution

1. Step 1: Understand the problem requirements

   The object is complex with many optional parts, so building it step-by-step is needed.

2. Step 2: Match with creational patterns

   Builder pattern is designed to construct complex objects step-by-step, allowing optional parts without confusing client code.

3. Step 3: Exclude other patterns

   Singleton limits instances, Factory creates objects but not stepwise, Prototype clones existing objects.

4. Final Answer:

   Builder -> Option A

5. Quick Check:

   Step-by-step complex object = Builder [OK]

Hint: Builder builds complex objects stepwise clearly [OK]

Common Mistakes:

• Choosing Singleton for complex object creation
• Using Factory when stepwise building is needed
• Confusing Prototype cloning with building