project-management

name	Project Management
description	Planning, executing, and delivering projects successfully through structured methodologies and stakeholder communication
license	MIT
compatibility	universal
audience	developers, team leads, project managers
category	interdisciplinary

Project Management

What I Do

I organize and coordinate project activities to deliver outcomes on time, within budget, and to quality standards. I establish processes, manage risks, facilitate communication, and keep projects moving toward their goals.

When to Use Me

• Planning project scope, timeline, and resources
• Managing team coordination and communication
• Tracking progress and identifying blockers
• Mitigating risks and handling changes
• Running effective meetings and ceremonies
• Balancing constraints (scope, time, cost, quality)

Core Concepts

1. Project Lifecycle: Initiation, Planning, Execution, Monitoring, Closure
2. Scope Management: Defining and controlling what is in/out of scope
3. Work Breakdown Structure: Decomposing work into manageable units
4. Critical Path Analysis: Identifying longest task sequence
5. Risk Management: Identifying, assessing, and mitigating risks
6. Stakeholder Management: Identifying and engaging stakeholders
7. Agile vs Waterfall: Choosing appropriate methodologies
8. Resource Allocation: Assigning people and tools effectively
9. Earned Value Management: Integrated scope, schedule, cost tracking
10. Retrospectives: Continuous improvement through reflection

Code Examples

Project Scheduler

class ProjectScheduler {
  constructor(project) {
    this.project = project;
    this.tasks = project.tasks || [];
    this.resources = project.resources || [];
    this.dependencies = project.dependencies || [];
    this.constraints = project.constraints || {};
  }
  
  buildWBS() {
    const wbs = {
      id: this.project.id,
      name: this.project.name,
      deliverables: []
    };
    
    let workPackageId = 0;
    
    this.project.phases?.forEach(phase => {
      const phaseNode = {
        id: `WP-${phase.id}`,
        name: phase.name,
        deliverables: [],
        estimatedHours: 0,
        actualHours: 0
      };
      
      phase.workPackages?.( {
         wpNode = {
          : ,
          : wp.,
          : wp..( ({
            : t.,
            : t.,
            : t.,
            : t.,
            : t. || [],
            : 
          })),
          : wp..( sum + t., )
        };
        
        phaseNode..(wpNode);
        phaseNode. += wpNode.;
      });
      
      wbs..(phaseNode);
    });
    
     wbs;
  }
  
  () {
     taskMap =  ();
    ..( {
      task. = ;
      task. = ;
      task. = ;
      task. = ;
      taskMap.(task., task);
    });
    
      = () => {
       sorted = [....].( 
        (a.?. || ) - (b.?. || )
      );
      
      sorted.( {
         deps = (task. || [])
          .( taskMap.(id))
          .();
        
        task. = deps. > 
          ? .(...deps.( d.))
          : ;
        task. = task. + task.;
      });
    };
    
      = () => {
       sorted = [....].( 
        (b.?. || ) - (a.?. || )
      );
      
       projectDuration = .(.....( t.));
      
      sorted.( {
         dependents = .(task.);
        
        task. = dependents. > 
          ? .(...dependents.( d.))
          : projectDuration;
        task. = task. - task.;
        task. = task. - task.;
      });
    };
    
    ();
    ();
    
     ..( t. === );
  }
  
  () {
     ..( 
      t.?.(taskId)
    );
  }
  
  () {
     criticalPath = .();
     schedule = {
      : ..,
      : options. ||  (),
      : ,
      : ,
      : ..( ({
        : t.,
        : t.,
        : t.,
        : t.,
        : t.,
        : t. === ,
        : t.
      })),
      : ..?.( ({
        : m.,
        : m.,
        : m.,
        : m.
      }))
    };
    
    schedule. = .(
      schedule.,
      .(...schedule..( t.))
    );
    schedule. = .(...schedule..( t.));
    
     schedule;
  }
  
  () {
     result =  (startDate);
     added = ;
    
     (added < days) {
      result.(result.() + );
       (result.() !==  && result.() !== ) {
        added++;
      }
    }
    
     result;
  }
}

Risk Register Manager

class RiskManager {
  constructor(project) {
    this.project = project;
    this.risks = [];
    this.mitigationStrategies = {
      avoid: 'Change project plan to eliminate threat',
      mitigate: 'Reduce probability or impact',
      transfer: 'Shift responsibility to third party',
      accept: 'Acknowledge and monitor'
    };
  }
  
  addRisk(identification) {
    const risk = {
      id: this.generateId(),
      description: identification.description,
      category: identification.category,
      probability: identification.probability || 'medium',
      impact: identification.impact || 'medium',
      detected: new Date(),
      detectedBy: identification.reporter,
      status: 'identified',
      mitigation: null,
      contingency: null,
      owner: null,
      history: [{
        date:  (),
        : ,
        : identification.
      }]
    };
    
    risk. = .(risk);
    risk. = .(risk.);
    
    ..(risk);
     risk;
  }
  
  () {
     scores = { : , : , : , :  };
     scores[risk.] * scores[risk.];
  }
  
  () {
     (score >= )  ;
     (score >= )  ;
     (score >= )  ;
     ;
  }
  
  () {
     risk = .(riskId);
     (!risk)   ();
    
    risk. = {
      strategy,
      plan,
      : plan.,
      : plan.,
      : 
    };
    
    risk. = plan.;
    .(risk, , plan.);
    
     (strategy === ) {
      risk. = ;
      risk. = ;
    }
    
     risk;
  }
  
  () {
     risk = .(riskId);
     (!risk)   ();
    
     oldStatus = risk.;
    risk. = status;
    risk. =  ();
    
    .(risk, , actor);
    
     (status === ) {
      risk. = .(risk);
      .(risk);
    }
    
     risk;
  }
  
  () {
     {
      : risk. || ,
      : risk. || ,
      : risk. || ,
      : risk. || ,
      : risk. || 
    };
  }
  
  () {
     (!risk.) {
       { : , :  };
    }
    
    risk.. = ;
    risk.. =  ();
    
     {
      : ,
      : risk.,
      : risk..
    };
  }
  
  () {
     byCategory = .();
    byLevel = .();
    
     {
      : {
        : ..,
        : ..( r. !== ).,
        : ..( r. === ).,
        : ..( r. === ).
      },
      byCategory,
      byLevel,
      : .
        .( r. !== )
        .( b. - a.)
        .(, ),
      : .()
    };
  }
  
  () {
     active = ..( 
      r. && r. !== 
    );
    
     completed = active.( 
      r.. === 
    );
    
     {
      : active.,
      : completed.,
      : active. - completed.,
      : active. >  
        ? .((completed. / active.) * )
        : 
    };
  }
}

Sprint Metrics Dashboard

class SprintMetrics {
  constructor(sprint) {
    this.sprint = sprint;
    this.stories = sprint.stories || [];
    this.completedPoints = 0;
    this.totalPoints = 0;
  }
  
  calculateVelocity() {
    const completed = this.stories.filter(s => s.status === 'completed');
    this.completedPoints = completed.reduce((sum, s) => sum + s.points, 0);
    this.totalPoints = this.stories.reduce((sum, s) => sum + s.points, 0);
    
    return {
      committed: this.totalPoints,
      completed: this.completedPoints,
      completionRate: this.totalPoints >  
        ? . / . 
        : ,
      : .. > 
        ? . / completed.
        : 
    };
  }
  
  () {
     dailyData = .. || [];
    
     burndown = dailyData.( ({
      : day.,
      : day.,
      : day.,
      : .(day.)
    }));
    
     {
      : burndown,
      : .(burndown),
      : .(burndown),
      : .(burndown)
    };
  }
  
  () {
     sprintStart =  (..);
     sprintEnd =  (..);
     totalDays = .(sprintStart, sprintEnd);
     daysElapsed = .(sprintStart, currentDate);
    
     .(, . - 
      (. / totalDays) * daysElapsed
    );
  }
  
  () {
     count = ;
     current =  (start);
    
     (current <= end) {
       (current.() !==  && current.() !== ) {
        count++;
      }
      current.(current.() + );
    }
    
     count;
  }
  
  () {
     recent = burndown.(-);
    
     (recent. < )  ;
    
     velocities = recent.( 
      d. - (burndown[recent.(d) - ]?. || )
    );
    
     avgVelocity = velocities.( a + b, ) / velocities.;
    
     (avgVelocity > )  ;
     (avgVelocity < )  ;
     ;
  }
  
  () {
    .();
     burndown = .();
    
     {
      : ..,
      : {
        : .,
        : .,
        : . / .
      },
      : .(),
      : .(),
      : .(),
      : .()
    };
  }
  
  () {
     completed = ..( s. === );
    
     withBugs = completed.( s. > );
     withRework = completed.( s. > );
    
     {
      : completed. >  
        ? withBugs. / completed. 
        : ,
      : completed. >  
        ? withRework. / completed. 
        : ,
      : withBugs. > 
        ? withBugs.( sum + s., ) / withBugs.
        : 
    };
  }
}

Best Practices

1. Define clear, measurable objectives before starting
2. Break work into small, manageable increments
3. Communicate proactively about blockers and risks
4. Track progress against baselines regularly
5. Manage stakeholder expectations continuously
6. Adapt plans based on feedback and changes
7. Hold effective, action-oriented meetings
8. Document decisions and their rationale
9. Retrospect and improve processes continuously
10. Focus on outcomes, not just outputs