Problem Statement

• Complex assessment lifecycle with multiple states
• Challenges in managing transitions and ensuring consistency
• Need for a structured approach to handle state changes
• Consistency for analytics and reporting
• Difficulty in scaling changes in the assessment

Complex Assessment Lifecycle

• No clear boundary between happy, terminal, and error states
• Numerous events triggering state transitions
• Interdependencies between states and events

Challenges in Managing Transitions

• Inconsistent handling of state changes
• Increased risk of errors and mismanagement
• Difficulty in tracking state history and debugging issues

Need for a Structured Approach

• Clear definition of states and transitions
• Standardized handling of events
• Improved maintainability and scalability

Consistency for Analytics & Reporting

• Standardized logging, monitoring, and reporting
• Reliable data for performance metrics
• Accurate tracking of assessment outcomes
• Enhanced decision-making based on consistent data

Difficulty in Scaling Changes

• Complexity in updating state logic
• Increased effort for testing and validation
• Risk of introducing inconsistencies during changes
• Separation of concerns and modularity challenges

State Machine Overview

• Definition of a finite state machine (FSM)
• States involved in the assessment process
• Transitions between states based on events
• Responsibilities and actions of a state machine

What is a Finite State Machine?

• Set of data structures and design patterns
• Consists of a finite number of discrete states
• Used to model complex behaviors in a structured manner
• Transitions between states are triggered by events
• Provides clarity and predictability in system behavior
• Facilitates easier debugging and maintenance

States in the Assessment Process

• Initial State: Assessment not started
• In Progress: Assessment is being conducted
• Completed: Assessment has been finished
• Terminated: Assessment was terminated before completion
• Error: An error occurred during the assessment process

Screen Transitions Based on Events

• Root event tells the state machine to go to a new screen based on the current screen and some additional context
• Events include user actions (e.g., start, submit, terminate) and system events (e.g., error occurrence)
• Each event triggers a transition from one state to another, updating the assessment status accordingly

State Machine Navigation Observers

State Machine Navigation Handlers

• Reusable components for verifying context between screen navigation
• Validate navigation rules and conditions
  • Handling invalid navigation attempts gracefully
  • Ensuring prerequisites are met before transitioning to a new screen
    • Age check
    • State check
    • Guardian checks
    • Schizophrenia check
    • Suicide-risk check

State Machine Navigation Strategies

• Determine the appropriate navigation path based on current state and events
• Implement fallback strategies for unexpected states or events
• Optimize navigation for user experience and performance
• Modular and extensible design such that reusability is high between intake and referral assessments

Implementation Details

• Four core design patterns working together
• Type-safe navigation context
• Reusable validation handlers
• Pluggable observer architecture

Architecture Overview

Flow: User Action → Context → State → Strategy → Handlers → Observers → Result

Core Design Patterns

Result: Behavior changes without conditionals, isolated testable components

Pattern Example: Chain of Responsibility

              
abstract class BaseNavigationHandler {
  private nextHandler: INavigationHandler | null = null;
  setNext(handler: INavigationHandler) { this.nextHandler = handler; }
  protected next(context) { return this.nextHandler?.handle(context); }
}

class AgeValidationHandler extends BaseNavigationHandler {
  handle(context: NavigationContext) {
    if (isUnder18 && context.isGuardian === false) {
      return this.terminate(Screens.MinorTermination);
    }
    return this.next(context); // Continue chain
  }
}

// Chain handlers together
new AgeValidationHandler()
  .setNext(new StateValidationHandler())
  .setNext(new GuardianRequirementHandler())
  .setNext(new SuicideRiskCheckHandler());
              
            

Extensibility: Adding Features

                  registry.set(Screens.NewScreen, new NewScreenStrategy());
                

                  chain.setNext(new CustomValidationHandler());
                

Extensibility: Adding Features (Cont.)

                  stateMachine.addObserver(new CustomObserver());
                

Testing Strategy

Key Takeaways: Implementation

A maintainable, extensible, testable architecture

Benefits and Outcomes

Real-World Impact: Metrics

Example: Faster Development

Lessons Learned

Future Enhancements

Conclusion + Q&A

• Problem Statement
• State Machine Overview
• Implementation Details
• Benefits and Outcomes
• Q&A

Additional Resources on Finite State Machines

1. MIT OpenCourseWare
2. Design Patterns

Powered By

1. A single, static webpage.
2. reveal.js
3. highlight.js