Bird
Raised Fist0
LLDsystem_design~12 mins

Why elevator design tests state machines in LLD - Architecture Impact

Choose your learning style10 modes available
LearnWhyDeepArchPracticeChallengeDesignRecallScale

Start learning this pattern below

Jump into concepts and practice - no test required

or
Recommended
Test this pattern10 questions across easy, medium, and hard to know if this pattern is strong
System Overview - Why elevator design tests state machines

An elevator system moves people between floors safely and efficiently. It must handle requests, move up or down, open and close doors, and respond to emergencies. Testing it as a state machine helps ensure it behaves correctly in all situations.

Architecture Diagram
  +---------+       +-------------+       +------------+       +---------+
  |  User   | --->  | Elevator    | --->  | Controller | --->  | Sensors |
  +---------+       | State       |       +------------+       +---------+
                    | Machine    |            |                  |
                    +-------------+            |                  |
                          |                    |                  |
                          v                    v                  v
                    +-------------+      +------------+     +------------+
                    | Motor       |      | Door       |     | Emergency  |
                    | Controller  |      | Controller |     | System     |
                    +-------------+      +------------+     +------------+
Components
User
actor
Person who requests elevator service by pressing buttons
Elevator State Machine
service
Manages elevator states like moving, stopped, doors open/closed
Controller
service
Processes inputs and commands motor and doors accordingly
Sensors
hardware
Detect elevator position, door status, and safety conditions
Motor Controller
hardware
Controls elevator movement up or down
Door Controller
hardware
Controls opening and closing of elevator doors
Emergency System
hardware
Handles emergency stops and alarms
Request Flow - 6 Hops
User → Elevator State Machine
Elevator State Machine → Controller
Controller → Motor Controller
Sensors → Elevator State Machine
Controller → Door Controller
Emergency System → Elevator State Machine
Failure Scenario
Component Fails:Elevator State Machine
Impact:Elevator may enter incorrect states causing unsafe or stuck behavior
Mitigation:Use thorough state machine testing and fallback safe states to stop elevator safely
Architecture Quiz - 3 Questions
Test your understanding
Why is the elevator system modeled as a state machine?
ATo reduce the number of sensors needed
BTo speed up the elevator motor
CTo clearly define and control all possible elevator states and transitions
DTo allow users to control the elevator remotely
Design Principle
Modeling the elevator as a state machine ensures all possible states and transitions are explicitly handled. This approach helps prevent unsafe or unexpected behavior by making the system predictable and testable.

Practice

(1/5)
1. Why is elevator design often used to test state machines in system design?
easy
A. Because elevators have clear states and transitions that model real-world behavior
B. Because elevators require complex database management
C. Because elevators use machine learning algorithms
D. Because elevators operate without any state changes

Solution

  1. Step 1: Understand elevator operation basics

    Elevators move between floors and have states like moving up, moving down, idle, door open, and door closed.

  2. Step 2: Connect elevator states to state machine concept

    State machines model systems with defined states and transitions, matching elevator behavior perfectly.

  3. Final Answer:

    Because elevators have clear states and transitions that model real-world behavior -> Option A

  4. Quick Check:

    Elevator states = clear states and transitions [OK]
Hint: Elevators have clear states and transitions [OK]
Common Mistakes:
  • Thinking elevators don't have states
  • Confusing state machines with databases
  • Assuming elevators use AI for basic movement
2. Which of the following correctly represents a state transition in an elevator state machine?
easy
A. Idle -> Door Open -> Moving Up
B. Idle -> Moving Up -> Door Open
C. Door Open -> Moving Down -> Door Closed
D. Moving Up -> Door Closed -> Idle

Solution

  1. Step 1: Identify valid elevator state order

    An elevator usually goes from Idle to Moving Up, then Door Open when it reaches the floor.

  2. Step 2: Check each option's sequence

    Idle -> Moving Up -> Door Open correctly shows Idle -> Moving Up -> Door Open, a valid transition sequence.

  3. Final Answer:

    <code>Idle -> Moving Up -> Door Open</code> -> Option B

  4. Quick Check:

    Idle to Moving Up to Door Open = valid transition [OK]
Hint: Elevator moves before doors open [OK]
Common Mistakes:
  • Opening doors before moving
  • Closing doors while idle
  • Skipping moving state
3. Given this simplified elevator state machine code snippet, what is the final state after these events: callElevator(), arriveFloor(), openDoor()? 
states = ['Idle', 'Moving', 'DoorOpen']
current_state = 'Idle'

def callElevator():
    global current_state
    if current_state == 'Idle':
        current_state = 'Moving'

def arriveFloor():
    global current_state
    if current_state == 'Moving':
        current_state = 'DoorOpen'

def openDoor():
    global current_state
    if current_state == 'DoorOpen':
        current_state = 'Idle'
medium
A. Idle
B. Moving
C. DoorOpen
D. Error

Solution

  1. Step 1: Trace callElevator()

    Starting at 'Idle', callElevator() changes state to 'Moving'.

  2. Step 2: Trace arriveFloor() and openDoor()

    arriveFloor() changes 'Moving' to 'DoorOpen', then openDoor() changes 'DoorOpen' back to 'Idle'.

  3. Final Answer:

    Idle -> Option A

  4. Quick Check:

    Idle after all events = Idle [OK]
Hint: Follow state changes step-by-step [OK]
Common Mistakes:
  • Skipping openDoor() effect
  • Assuming state stays at DoorOpen
  • Confusing event order
4. In this elevator state machine code, what is the bug causing the elevator to never open doors? 
current_state = 'Idle'

def callElevator():
    global current_state
    if current_state == 'Idle':
        current_state = 'Moving'

def arriveFloor():
    global current_state
    if current_state == 'Moving':
        current_state = 'Idle'  # Bug here

def openDoor():
    global current_state
    if current_state == 'DoorOpen':
        current_state = 'Idle'
medium
A. current_state is not initialized
B. callElevator() does not change state
C. openDoor() changes state incorrectly
D. arriveFloor() sets state to 'Idle' instead of 'DoorOpen'

Solution

  1. Step 1: Analyze arriveFloor() function

    arriveFloor() changes 'Moving' state directly to 'Idle', skipping 'DoorOpen'.

  2. Step 2: Understand effect on door opening

    Since state never becomes 'DoorOpen', openDoor() condition never triggers, so doors never open.

  3. Final Answer:

    arriveFloor() sets state to 'Idle' instead of 'DoorOpen' -> Option D

  4. Quick Check:

    arriveFloor() wrong state change = no door open [OK]
Hint: Check if all states are reachable in transitions [OK]
Common Mistakes:
  • Ignoring wrong state assignment
  • Assuming callElevator() is faulty
  • Overlooking openDoor() condition
5. You are designing an elevator system with multiple elevators and floors. Why is modeling the system as a state machine important for safety and scalability?
hard
A. It eliminates the need for sensors and hardware checks
B. It allows elevators to learn user preferences automatically
C. It ensures predictable behavior and clear transitions, preventing unsafe states
D. It reduces the number of elevators needed by half

Solution

  1. Step 1: Understand state machine benefits in complex systems

    State machines define clear states and transitions, making system behavior predictable and easier to manage.

  2. Step 2: Connect predictability to safety and scalability

    Predictable transitions prevent unsafe states like doors opening while moving, and help scale by managing multiple elevators consistently.

  3. Final Answer:

    It ensures predictable behavior and clear transitions, preventing unsafe states -> Option C

  4. Quick Check:

    Predictable states = safety and scalability [OK]
Hint: Predictable states prevent unsafe elevator behavior [OK]
Common Mistakes:
  • Confusing state machines with AI
  • Ignoring safety in design
  • Assuming hardware replaces software logic