Software Project Management: Models, Risk, Agile, Metrics & Tools

TAKEAWAYS:

• Project models (Waterfall, Agile, Spiral) differ in flexibility, documentation needs, and risk handling—choose based on project uncertainty and stakeholder demands.
• COCOMO (COnstructive COst MOdel) estimates effort/cost using lines of code (LOC) and project attributes (e.g., team experience), with three variants: Basic, Intermediate, and Advanced.
• Risk management follows identify → analyze → plan → monitor (visualized in a block diagram), where risks like "scope creep" or "vendor delays" must be quantified (probability × impact) and mitigated proactively.
• Agile principles (e.g., "working software over documentation") are implemented via Scrum (sprints, daily standups) or Extreme Programming (pair programming, test-driven development), prioritizing adaptability over rigid plans.
• CASE tools (e.g., Rational Rose for UML, JIRA for tracking) automate design, testing, and documentation, reducing errors but requiring upfront training—critical for large-scale projects like NEPSE’s trading platform.
• Exam focus: Compare models (table), calculate COCOMO effort (worked example), draw risk management flowcharts, and link Agile practices to real tools (e.g., Slack for XP’s communication norms).

1. Software Project Management: Core Concepts

Software project management (SPM) applies planning, organizing, and controlling resources (time, cost, scope, quality) to deliver software successfully. Unlike general project management, SPM emphasizes uncertainty handling (e.g., evolving requirements) and team collaboration (e.g., developers, testers, stakeholders).

Key Challenges in SPM (Nepali Context)

Why it matters:

• 70% of IT projects fail due to poor planning (Standish Group). SPM reduces this by defining clear milestones and adapting to changes.
• Example: When Pathao launched in Nepal, its project managers used Agile to iterate on ride-matching algorithms based on user feedback, avoiding a Waterfall-style "big bang" launch that might have missed local needs (e.g., motorbike taxis).

2. Software Development Models

Models define how work is structured over a project’s lifecycle. Choose based on:

• Project size (small: Waterfall; large/complex: Spiral).
• Requirement volatility (stable: Waterfall; evolving: Agile).
• Stakeholder involvement (low: Waterfall; high: Agile).

Comparison Table

Visual: Waterfall vs. Agile Flow

Worked Example: Daraz’s Order Fulfillment

• Waterfall: If Daraz used this for its 2016 launch, it might have:
  1. Locked requirements (e.g., "only 10 product categories").
  2. Released a rigid system unable to handle Nepal’s diverse inventory (e.g., local brands).
• Agile: Instead, Daraz used 2-week sprints to:
  • Add "local seller" features after initial feedback.
  • Fix payment gateways (e.g., Khalti integration) iteratively.

3. Cost Estimation: The COCOMO Model

COCOMO (Boehm 1981) estimates effort (person-months) and cost based on lines of code (LOC) and project attributes. Used by NASA, Google, and Nepali banks for large systems.

COCOMO Variants

1. Basic COCOMO:

   • Formula: Effort = a × (KLOC)^b
     • KLOC = Thousands of lines of code.
     • a, b = Constants (e.g., for "organic" projects: a=2.4, b=1.05).
   • Limitation: Ignores team experience or tool maturity.

2. Intermediate COCOMO:

   • Adds 15 cost drivers (e.g., team experience, use of modern tools).
   • Formula: $$\text{Effort}=2.8\times (\text{KLOC}{)}^{1.20}\times \prod _{i=1}^{15}{\text{EAF}}_i$$
     • EAF = Effort Adjustment Factor (e.g., EAF=1.12 if team has low experience).

3. Advanced COCOMO:

   • Phase-wise estimation (requirements, design, coding, testing).
   • Used for mission-critical systems (e.g., NEPSE’s trading platform).

Worked Example: Estimating a Bank Loan System

Assumptions:

• Project: Loan processing system for Global IME Bank.
• KLOC = 50 (50,000 lines of code).
• Team: 5 developers with medium experience (EAF=1.05).
• Tools: Moderate (e.g., Java + MySQL; EAF=1.04).

Calculation (Intermediate COCOMO):

1. Base effort: $$\text{Effort}=2.8\times (50{)}^{1.20}=2.8\times 118.5=331.8\text{ person-months}$$
2. Adjust for cost drivers:
   • Team experience: EAF=1.05
   • Tool use: EAF=1.04
   • Total EAF = 1.05 × 1.04 = 1.092
3. Adjusted effort: $$331.8\times 1.092=362.5\text{ person-months}$$
4. Cost: Assume salary = Rs. 50,000/month. $$\text{Total Cost}=362.5\times 50,000=\text{Rs. 18,125,000}$$

Real-World Tie-In:

• Nabil Bank used COCOMO to estimate its core banking system upgrade (2020), adjusting for Nepal’s regulatory requirements (e.g., KYC compliance).

4. Risk Management in Software Projects

Risk = Event with negative impact (e.g., delays, budget overruns). Managed via 4 phases:

flowchart TD
    A["1. Risk Identification"] --> B["2. Risk Analysis"]
    B --> C["3. Risk Planning"]
    C --> D["4. Risk Monitoring"]
    D -->|"New Risks"| A

Risk Identification Techniques

• Checklists: Use standard lists (e.g., "vendor delays," "requirement changes").
• Brainstorming: Team sessions (e.g., Daraz’s "what-if" for monsoon disruptions).
• SWOT Analysis: Internal (Strengths/Weaknesses) vs. external (Opportunities/Threats).

Risk Analysis: Probability vs. Impact Matrix

Example Risks for eSewa:

Worked Example: NTC’s Fiber Optic Rollout

• Risk: Delayed due to land acquisition (probability: high; impact: high).
• Mitigation:
  1. Plan B: Use existing telecom towers temporarily.
  2. Contingency Budget: Allocated 20% extra for legal fees.

5. Agile Software Development

Agile is an iterative, incremental approach prioritizing:

• Individuals and interactions over processes.
• Working software over documentation.
• Customer collaboration over contract negotiation.

Agile Principles (Manifestos)

1. Customer satisfaction via early/continuous delivery.
2. Welcome changing requirements (even late in development).
3. Deliver working software frequently (weeks, not months).
4. Business and developers must work together daily.

Agile Methodologies

How XP Implements Agile Principles:

• Pair Programming: Two developers work together (e.g., Daraz’s frontend/backend pairs).
• Test-Driven Development (TDD): Write tests before code (reduces bugs in Khalti’s transactions).
• Continuous Integration: Merge code changes frequently (e.g., Pathao’s real-time ride updates).

6. Computer-Aided Software Engineering (CASE) Tools

CASE tools automate software development tasks (e.g., design, testing, documentation). Types:

Popular CASE Tools

Benefits:

• Reduces errors: Automated code reviews (e.g., SonarQube).
• Saves time: Generates documentation (e.g., Swagger for APIs).
• Improves collaboration: Shared repositories (e.g., GitHub for open-source Nepali projects).

Limitation:

• Steep learning curve (e.g., UML tools require training).
• Overhead for small projects (e.g., a 5-person team may not need JIRA).

7. Human Factors in Project Management

People are the biggest project risk. Key considerations:

• Team dynamics: Conflict resolution (e.g., remote vs. in-office teams in Nepal).
• Communication: Daily standups (Agile) vs. weekly reports (Waterfall).
• Motivation: Recognition (e.g., Daraz’s "Employee of the Month").

In the Real World

1. eSewa’s Payment System

   • Agile + COCOMO: Used 2-week sprints to add features like "QR payments" while estimating costs via COCOMO for scalability (handling 1M+ transactions/day).
   • Risk Management: Mitigated "fraud risks" by integrating biometric verification (fingerprint + OTP).

2. Daraz’s Logistics Network

   • Spiral Model: Tested delivery routes in Pokhara (low risk) before scaling to Kathmandu, using risk analysis to identify traffic bottlenecks.
   • CASE Tools: Used Tableau to visualize delivery delays (e.g., monsoon season).

3. NEPSE’s Trading Platform

   • Waterfall for Compliance: Used for audit trails (critical for regulatory bodies like SEBON).
   • Agile for UI: Iterated on the mobile app based on trader feedback (e.g., adding "real-time price alerts").

4. Pathao’s Ride-Matching Algorithm

   • COCOMO Estimation: Initially estimated 80 person-months for the core algorithm (KLOC=30, team experience=high).
   • Risk: "Driver shortages" → Solution: Dynamic surge pricing (Agile adaptation).

5. NTC’s Fiber Optic Expansion

   • Project Management Tools: Used MS Project to track land acquisition vs. construction timelines.
   • Challenge: Scope creep (adding Wi-Fi zones mid-project) → Mitigated by change control boards.

Exam Tip

What Examiners Love to See

1. COCOMO Calculations:

   • Always show formulas and step-by-step adjustments (e.g., EAF).
   • Example: For a 100-KLOC project with EAF=1.15, write: $$\text{Effort}=3.0\times (100{)}^{1.12}\times 1.15=1150\text{ person-months}$$

2. Risk Management Diagrams:

   • Draw a block diagram (like the one above) and label all 4 phases.
   • Example Answer:

     "Risk identification for Pathao’s app included brainstorming sessions where developers listed risks like ‘server downtime during Diwali’ (high probability, high impact). The team mitigated this by deploying cloud-based redundancy (AWS)."

3. Agile vs. Waterfall Comparisons:

   • Use a table (like above) and link to Nepali examples.
   • Example:

     "Unlike Waterfall, Agile allowed eSewa to add ‘UPI integration’ after the initial launch, adapting to RBI’s 2021 regulations without rewriting the entire system."

4. CASE Tools:

   • Name 2 tools and describe one feature each.
   • Example:

     "Rational Rose automates UML diagram generation, reducing errors in TU student projects by 30%. JIRA’s burndown charts help Daraz track sprint progress visually."

5. Worked Examples:

   • Always tie to Nepal: Use banks, e-commerce, or telecom (e.g., "Ncell’s 5G rollout used Spiral model to test in Bhaktapur before nationwide launch").
   • Avoid generic answers: Instead of "Agile is flexible," write:

     "Agile’s iterative nature helped Khalti recover from the 2021 cyberattack by patching vulnerabilities in 3-week sprints, unlike traditional models that would require a full redesign."

Common Mistakes to Avoid

• Ignoring EAF in COCOMO: Forgetting to multiply by effort adjustment factors.
• Vague risk descriptions: Write "risks may occur" → Instead: "Vendor delay risk (probability=0.7, impact=high) mitigated by having backup suppliers like Transcom and Smart Telecom."
• Drawing incorrect diagrams: For Agile, show sprints with feedback loops; for risk management, use 4-box flowcharts.
• Overlooking Nepali context: Examiners reward local examples (e.g., NTC, banks, Daraz). Always connect theory to Nepal.

Quick Revision Checklist

Before the exam, verify you can: ✅ Calculate COCOMO effort for a given KLOC and EAF. ✅ Differentiate Scrum, XP, and Kanban with Nepali examples. ✅ Draw a risk management flowchart and label all phases. ✅ Explain how Agile principles are implemented in tools like JIRA or Slack. ✅ List 3 CASE tools and their uses in Nepali projects. ✅ Compare Waterfall vs. Agile in a table with local case studies.