Notification on state change in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a method that triggers notification on state change.

LLD

def notify_on_state_change(self, new_state):
    if new_state != self.current_state:
        self.current_state = new_state
        self.[1]()

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

Alog_change

Bupdate_state

Csend_notification

Dreset_state

Attempts:

3 left

💡 Hint

Common Mistakes

Calling a method that only updates state without notifying.

Using a logging method instead of notification.

The method send_notification is called to notify when the state changes.

2fill in blank

medium

Complete the code to register an observer for state changes.

LLD

def register_observer(self, observer):
    self.[1].append(observer)

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

Aobservers

Bnotifications

Clisteners

Dsubscribers

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable that does not store observers.

Using a singular form instead of plural.

The list observers holds all registered observers to notify on state changes.

3fill in blank

hard

Fix the error in notifying all observers about the state change.

LLD

def notify_all(self):
    for observer in self.[1]:
        observer.update(self.current_state)

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

Asubscribers

Bobservers

Cnotifications

Dlisteners

Attempts:

3 left

💡 Hint

Common Mistakes

Using a wrong variable name causing runtime errors.

Using a variable that does not hold observer objects.

The method iterates over observers to call their update method with the new state.

4fill in blank

hard

Fill both blanks to create a dictionary mapping states to notification messages.

LLD

state_messages = {
    'active': '[1]',
    'inactive': '[2]'
}

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

A'User is now active'

B'User is now inactive'

C'State changed to active'

D'State changed to inactive'

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping messages between states.

Using generic messages that do not specify state.

The dictionary maps each state to a clear notification message.

5fill in blank

hard

Fill all three blanks to implement a method that sends notifications with proper message and logs the event.

LLD

def send_notification(self, message):
    self.notification_service.[1](message)
    self.logger.[2](f"Notification sent: [3]")

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

Asend

Binfo

Cmessage

Dalert

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect method names causing errors.

Logging wrong variable or missing message content.

The notification service send method sends the message, and the logger info method logs the message content.

Practice

1. What is the main purpose of a notification system on state change in software design?

easy

A. To inform interested components immediately when data changes

B. To store data permanently in a database

C. To increase the size of the application

D. To delay updates until the user refreshes manually

Solution

1. Step 1: Understand the role of notifications

   Notifications alert parts of a system or users when something important changes.

2. Step 2: Identify the purpose of state change notifications

   They ensure components get updates immediately without waiting or manual refresh.

3. Final Answer:

   To inform interested components immediately when data changes -> Option A

4. Quick Check:

   Notification = Immediate update [OK]

Hint: Notifications alert on change, not store or delay [OK]

Common Mistakes:

• Confusing notification with data storage
• Thinking notifications delay updates
• Assuming notifications increase app size

2. Which of the following is the correct method name to notify observers in a typical observer pattern implementation?

easy

A. unsubscribe()

B. updateState()

C. subscribe()

D. notifyObservers()

Solution

1. Step 1: Recall observer pattern methods

   Common methods include subscribe, unsubscribe, and notifyObservers.

2. Step 2: Identify the method that sends updates

   notifyObservers() is used to alert all subscribed observers about changes.

3. Final Answer:

   notifyObservers() -> Option D

4. Quick Check:

   Notify method = notifyObservers() [OK]

Hint: Notify method usually named notifyObservers() [OK]

Common Mistakes:

• Confusing subscribe with notify
• Using updateState() which changes state, not notify
• Mixing unsubscribe with notification

3. Consider this simplified code snippet for a notification system:

class Subject:
    def __init__(self):
        self.observers = []
    def subscribe(self, observer):
        self.observers.append(observer)
    def notify(self, message):
        for obs in self.observers:
            obs.update(message)

class Observer:
    def update(self, message):
        print(f"Received: {message}")

subject = Subject()
obs1 = Observer()
subject.subscribe(obs1)
subject.notify("State changed")

What will be the output when subject.notify("State changed") is called?

medium

A. Error: update method missing

B. No output

C. Received: State changed

D. Received: None

Solution

1. Step 1: Trace subscription and notification

   Observer obs1 is subscribed to subject, so it is in the observers list.

2. Step 2: Check notify method behavior

   notify calls update on each observer with the message "State changed".

3. Final Answer:

   Received: State changed -> Option C

4. Quick Check:

   Observer prints message on notify [OK]

Hint: Subscribed observers receive and print messages [OK]

Common Mistakes:

• Assuming notify does nothing without explicit call
• Thinking update method is missing
• Expecting no output if observers list is empty

4. In the following code, what is the main issue that prevents observers from receiving notifications?

class Subject:
    def __init__(self):
        self.observers = set()
    def subscribe(self, observer):
        self.observers.add(observer)
    def notify(self, message):
        for obs in self.observers:
            obs.receive(message)

class Observer:
    def update(self, message):
        print(f"Got: {message}")

subject = Subject()
obs1 = Observer()
subject.subscribe(obs1)
subject.notify("Update")

medium

A. Observers are stored in a set instead of a list

B. Method notify calls obs.receive but Observer has update method

C. subscribe method uses add instead of append

D. Observer class is missing

Solution

1. Step 1: Check method called in notify

   notify() calls obs.receive(message).

2. Step 2: Check Observer class methods

   Observer defines update(message), but no receive() method.

3. Final Answer:

   Method notify calls obs.receive but Observer has update method -> Option B

4. Quick Check:

   Method name mismatch causes AttributeError [OK]

Hint: Check method names called vs defined in observers [OK]

Common Mistakes:

• Confusing set vs list for storing observers
• Ignoring method name mismatches
• Assuming missing class when it exists

5. You are designing a scalable notification system for state changes in a distributed application. Which design choice best supports efficient notifications to thousands of subscribers without blocking the main process?

hard

A. Use asynchronous message queues to dispatch notifications

B. Notify all subscribers synchronously in a loop

C. Store notifications in a database and poll subscribers

D. Send notifications only when the system restarts

Solution

1. Step 1: Understand scalability needs

   Thousands of subscribers require non-blocking, efficient notification delivery.

2. Step 2: Evaluate design options

   Synchronous loops block main process; polling adds delay; restart notifications are impractical.

3. Step 3: Identify best practice

   Asynchronous message queues decouple notification sending, allowing scalable, fast delivery.

4. Final Answer:

   Use asynchronous message queues to dispatch notifications -> Option A

5. Quick Check:

   Async queues = scalable notifications [OK]

Hint: Async queues handle many subscribers efficiently [OK]

Common Mistakes:

• Using synchronous loops causing delays
• Relying on polling which is slow
• Sending notifications only on restart