Coding Posture Improvement - Complete Guide

# Coding Posture Improvement System

class PostureAnalysis {
  constructor() {
    this.postureElements = {
      head: {
        position: 'Neutral, not tilted forward',
        angle: '0-15 degrees downward',
        distance: '20-26 inches from screen',
        alignment: 'Centered over shoulders'
      },
      
      neck: {
        position: 'Straight, not extended forward',
        angle: 'Neutral alignment',
        support: 'Supported by strong neck muscles',
        movement: 'Minimal forward head posture'
      },
      
      shoulders: {
        position: 'Relaxed and level',
        angle: '90-degree angle with arms',
        height: 'Not hunched or elevated',
        alignment: 'Square with hips'
      },
      
      back: {
        position: 'Straight with natural curves',
        support: 'Lumbar support in chair',
        angle: '100-110 degree backrest angle',
        alignment: 'Spine in neutral position'
      },
      
      arms: {
        position: 'Elbows at 90-degree angle',
        height: 'Level with desk surface',
        support: 'Forearms supported',
        movement: 'Minimal reaching required'
      },
      
      wrists: {
        position: 'Straight, not bent',
        angle: 'Neutral alignment',
        support: 'Wrist rest for support',
        movement: 'Minimal extension or flexion'
      },
      
      legs: {
        position: 'Feet flat on floor',
        angle: '90-degree angle at knees',
        support: 'Thighs parallel to floor',
        circulation: 'No pressure on legs'
      }
    };
  }
  
  analyzeCurrentPosture(userPosture) {
    const analysis = {
      score: this.calculatePostureScore(userPosture),
      issues: this.identifyPostureIssues(userPosture),
      recommendations: this.generateRecommendations(userPosture),
      riskAssessment: this.assessRiskLevel(userPosture)
    };
    
    return analysis;
  }
  
  calculatePostureScore(userPosture) {
    let score = 0;
    const maxScore = 100;
    
    // Head position (20 points)
    if (userPosture.head.forwardTilt <= 15) score += 20;
    else if (userPosture.head.forwardTilt <= 30) score += 15;
    else if (userPosture.head.forwardTilt <= 45) score += 10;
    else score += 5;
    
    // Shoulder position (20 points)
    if (userPosture.shoulders.hunched === false) score += 20;
    else if (userPosture.shoulders.hunched === 'slight') score += 15;
    else if (userPosture.shoulders.hunched === 'moderate') score += 10;
    else score += 5;
    
    // Back support (20 points)
    if (userPosture.back.lumbarSupport === 'excellent') score += 20;
    else if (userPosture.back.lumbarSupport === 'good') score += 15;
    else if (userPosture.back.lumbarSupport === 'fair') score += 10;
    else score += 5;
    
    // Arm position (20 points)
    if (userPosture.arms.elbowAngle >= 85 && userPosture.arms.elbowAngle <= 95) score += 20;
    else if (userPosture.arms.elbowAngle >= 80 && userPosture.arms.elbowAngle <= 100) score += 15;
    else if (userPosture.arms.elbowAngle >= 75 && userPosture.arms.elbowAngle <= 105) score += 10;
    else score += 5;
    
    // Wrist position (20 points)
    if (userPosture.wrists.neutral === true) score += 20;
    else if (userPosture.wrists.neutral === 'mostly') score += 15;
    else if (userPosture.wrists.neutral === 'sometimes') score += 10;
    else score += 5;
    
    return {
      score: score,
      percentage: (score / maxScore) * 100,
      rating: score >= 80 ? 'Excellent' : 
              score >= 60 ? 'Good' : 
              score >= 40 ? 'Fair' : 'Poor'
    };
  }
  
  identifyPostureIssues(userPosture) {
    const issues = [];
    
    // Forward head posture
    if (userPosture.head.forwardTilt > 30) {
      issues.push({
        type: 'Forward Head Posture',
        severity: userPosture.head.forwardTilt > 45 ? 'High' : 'Medium',
        description: 'Head is tilted too far forward',
        impact: 'Neck strain, headaches, shoulder tension'
      });
    }
    
    // Rounded shoulders
    if (userPosture.shoulders.hunched === true || userPosture.shoulders.hunched === 'moderate') {
      issues.push({
        type: 'Rounded Shoulders',
        severity: userPosture.shoulders.hunched === true ? 'High' : 'Medium',
        description: 'Shoulders are hunched forward',
        impact: 'Upper back pain, reduced breathing capacity'
      });
    }
    
    // Poor back support
    if (userPosture.back.lumbarSupport === 'poor' || userPosture.back.lumbarSupport === 'none') {
      issues.push({
        type: 'Poor Back Support',
        severity: 'High',
        description: 'Insufficient lumbar support',
        impact: 'Lower back pain, spinal misalignment'
      });
    }
    
    // Wrist extension
    if (userPosture.wrists.neutral === false) {
      issues.push({
        type: 'Wrist Extension',
        severity: 'Medium',
        description: 'Wrists are bent or extended',
        impact: 'Carpal tunnel syndrome, wrist pain'
      });
    }
    
    return issues;
  }
  
  generateRecommendations(userPosture) {
    const recommendations = [];
    
    // Head and neck recommendations
    if (userPosture.head.forwardTilt > 15) {
      recommendations.push({
        category: 'Head and Neck',
        action: 'Adjust monitor height',
        description: 'Position monitor so top of screen is at eye level',
        priority: 'High'
      });
      
      recommendations.push({
        category: 'Head and Neck',
        action: 'Strengthen neck muscles',
        description: 'Perform neck strengthening exercises',
        priority: 'Medium'
      });
    }
    
    // Shoulder recommendations
    if (userPosture.shoulders.hunched === true || userPosture.shoulders.hunched === 'moderate') {
      recommendations.push({
        category: 'Shoulders',
        action: 'Improve shoulder posture',
        description: 'Keep shoulders back and down',
        priority: 'High'
      });
      
      recommendations.push({
        category: 'Shoulders',
        action: 'Stretch chest muscles',
        description: 'Perform chest stretches to counteract hunching',
        priority: 'Medium'
      });
    }
    
    // Back recommendations
    if (userPosture.back.lumbarSupport === 'poor' || userPosture.back.lumbarSupport === 'none') {
      recommendations.push({
        category: 'Back',
        action: 'Improve lumbar support',
        description: 'Use lumbar support cushion or adjust chair',
        priority: 'High'
      });
      
      recommendations.push({
        category: 'Back',
        action: 'Strengthen core muscles',
        description: 'Perform core strengthening exercises',
        priority: 'Medium'
      });
    }
    
    // Wrist recommendations
    if (userPosture.wrists.neutral === false) {
      recommendations.push({
        category: 'Wrists',
        action: 'Improve wrist position',
        description: 'Keep wrists straight and use wrist rest',
        priority: 'High'
      });
      
      recommendations.push({
        category: 'Wrists',
        action: 'Adjust keyboard height',
        description: 'Position keyboard at elbow height',
        priority: 'Medium'
      });
    }
    
    return recommendations;
  }
  
  assessRiskLevel(userPosture) {
    let riskScore = 0;
    
    // Forward head posture risk
    if (userPosture.head.forwardTilt > 45) riskScore += 30;
    else if (userPosture.head.forwardTilt > 30) riskScore += 20;
    else if (userPosture.head.forwardTilt > 15) riskScore += 10;
    
    // Shoulder hunching risk
    if (userPosture.shoulders.hunched === true) riskScore += 25;
    else if (userPosture.shoulders.hunched === 'moderate') riskScore += 15;
    else if (userPosture.shoulders.hunched === 'slight') riskScore += 8;
    
    // Back support risk
    if (userPosture.back.lumbarSupport === 'none') riskScore += 25;
    else if (userPosture.back.lumbarSupport === 'poor') riskScore += 15;
    else if (userPosture.back.lumbarSupport === 'fair') riskScore += 8;
    
    // Wrist position risk
    if (userPosture.wrists.neutral === false) riskScore += 20;
    else if (userPosture.wrists.neutral === 'sometimes') riskScore += 10;
    
    return {
      score: riskScore,
      level: riskScore >= 70 ? 'High Risk' : 
             riskScore >= 50 ? 'Medium Risk' : 
             riskScore >= 30 ? 'Low Risk' : 'Minimal Risk',
      factors: {
        forwardHead: userPosture.head.forwardTilt > 30,
        roundedShoulders: userPosture.shoulders.hunched === true,
        poorBackSupport: userPosture.back.lumbarSupport === 'poor' || userPosture.back.lumbarSupport === 'none',
        wristExtension: userPosture.wrists.neutral === false
      }
    };
  }
}

class PostureImprovementExercises {
  constructor() {
    this.exercises = {
      neck: {
        name: 'Neck Strengthening',
        exercises: [
          {
            name: 'Chin Tucks',
            description: 'Pull chin back to create double chin',
            reps: '10-15 repetitions',
            frequency: '3 times daily',
            benefits: 'Strengthens deep neck flexors'
          },
          {
            name: 'Neck Extensions',
            description: 'Gently extend neck backward',
            reps: '8-12 repetitions',
            frequency: '2 times daily',
            benefits: 'Strengthens neck extensors'
          },
          {
            name: 'Neck Side Bends',
            description: 'Gently bend neck to each side',
            reps: '8-12 repetitions each side',
            frequency: '2 times daily',
            benefits: 'Improves neck flexibility'
          }
        ]
      },
      
      shoulders: {
        name: 'Shoulder Posture',
        exercises: [
          {
            name: 'Wall Slides',
            description: 'Slide arms up and down wall',
            reps: '10-15 repetitions',
            frequency: '3 times daily',
            benefits: 'Improves shoulder blade position'
          },
          {
            name: 'Chest Stretches',
            description: 'Stretch chest muscles',
            reps: 'Hold 30 seconds',
            frequency: '3 times daily',
            benefits: 'Reduces chest tightness'
          },
          {
            name: 'Shoulder Blade Squeezes',
            description: 'Squeeze shoulder blades together',
            reps: '10-15 repetitions',
            frequency: '3 times daily',
            benefits: 'Strengthens upper back'
          }
        ]
      },
      
      back: {
        name: 'Back Strengthening',
        exercises: [
          {
            name: 'Core Strengthening',
            description: 'Planks and core exercises',
            reps: '30-60 seconds hold',
            frequency: 'Daily',
            benefits: 'Supports spine and improves posture'
          },
          {
            name: 'Back Extensions',
            description: 'Gentle back extension exercises',
            reps: '10-15 repetitions',
            frequency: '2 times daily',
            benefits: 'Strengthens back muscles'
          },
          {
            name: 'Hip Flexor Stretches',
            description: 'Stretch hip flexor muscles',
            reps: 'Hold 30 seconds each side',
            frequency: '2 times daily',
            benefits: 'Reduces lower back tension'
          }
        ]
      },
      
      wrists: {
        name: 'Wrist Health',
        exercises: [
          {
            name: 'Wrist Stretches',
            description: 'Gentle wrist flexion and extension',
            reps: '10-15 repetitions each direction',
            frequency: '3 times daily',
            benefits: 'Improves wrist flexibility'
          },
          {
            name: 'Forearm Stretches',
            description: 'Stretch forearm muscles',
            reps: 'Hold 30 seconds each arm',
            frequency: '3 times daily',
            benefits: 'Reduces forearm tension'
          },
          {
            name: 'Grip Strengthening',
            description: 'Squeeze stress ball or grip trainer',
            reps: '10-15 repetitions',
            frequency: '2 times daily',
            benefits: 'Strengthens grip and forearm muscles'
          }
        ]
      }
    };
  }
  
  createExerciseProgram(userPosture) {
    const program = {
      daily: this.getDailyExercises(userPosture),
      weekly: this.getWeeklyExercises(userPosture),
      progress: this.createProgressTracking(userPosture)
    };
    
    return program;
  }
  
  getDailyExercises(userPosture) {
    const dailyExercises = [];
    
    // Always include basic exercises
    dailyExercises.push({
      name: 'Posture Check',
      description: 'Check and correct posture every 30 minutes',
      duration: '1 minute',
      frequency: 'Every 30 minutes'
    });
    
    // Add specific exercises based on posture issues
    if (userPosture.head.forwardTilt > 15) {
      dailyExercises.push(...this.exercises.neck.exercises);
    }
    
    if (userPosture.shoulders.hunched === true || userPosture.shoulders.hunched === 'moderate') {
      dailyExercises.push(...this.exercises.shoulders.exercises);
    }
    
    if (userPosture.back.lumbarSupport === 'poor' || userPosture.back.lumbarSupport === 'none') {
      dailyExercises.push(...this.exercises.back.exercises);
    }
    
    if (userPosture.wrists.neutral === false) {
      dailyExercises.push(...this.exercises.wrists.exercises);
    }
    
    return dailyExercises;
  }
  
  getWeeklyExercises(userPosture) {
    return [
      {
        name: 'Posture Assessment',
        description: 'Weekly posture evaluation',
        duration: '10 minutes',
        frequency: 'Once per week'
      },
      {
        name: 'Ergonomic Setup Review',
        description: 'Review and adjust workstation setup',
        duration: '15 minutes',
        frequency: 'Once per week'
      },
      {
        name: 'Exercise Program Adjustment',
        description: 'Adjust exercise program based on progress',
        duration: '5 minutes',
        frequency: 'Once per week'
      }
    ];
  }
  
  createProgressTracking(userPosture) {
    return {
      baseline: userPosture,
      weeklyAssessments: [],
      improvements: [],
      goals: this.setPostureGoals(userPosture)
    };
  }
  
  setPostureGoals(userPosture) {
    const goals = [];
    
    if (userPosture.head.forwardTilt > 15) {
      goals.push({
        area: 'Head Position',
        current: userPosture.head.forwardTilt,
        target: 15,
        timeline: '4-6 weeks'
      });
    }
    
    if (userPosture.shoulders.hunched === true) {
      goals.push({
        area: 'Shoulder Position',
        current: 'Hunched',
        target: 'Neutral',
        timeline: '6-8 weeks'
      });
    }
    
    if (userPosture.back.lumbarSupport === 'poor' || userPosture.back.lumbarSupport === 'none') {
      goals.push({
        area: 'Back Support',
        current: userPosture.back.lumbarSupport,
        target: 'Good',
        timeline: '2-4 weeks'
      });
    }
    
    return goals;
  }
}