Critical path method in Software Engineering - Mini Project: Build & Apply

Understanding the Critical Path Method

📖 Scenario: You are managing a small project with several tasks. You want to find the longest path of dependent tasks to know the minimum time needed to complete the project.

🎯 Goal: Build a simple representation of tasks with durations and dependencies, then identify the critical path using the Critical Path Method (CPM).

📋 What You'll Learn

Create a dictionary of tasks with durations

Create a dictionary of task dependencies

Calculate earliest start and finish times for each task

Determine the critical path based on the longest duration path

💡 Why This Matters

🌍 Real World

Project managers use the Critical Path Method to find the minimum time needed to complete a project and identify tasks that cannot be delayed.

💼 Career

Understanding CPM helps in planning, scheduling, and managing projects efficiently in fields like construction, software development, and event planning.

1

Create the tasks dictionary with durations

Create a dictionary called tasks with these exact entries: 'A': 3, 'B': 2, 'C': 4, 'D': 2, 'E': 3 representing task names and their durations in days.

Software Engineering

# Create the tasks dictionary with durations
# Your code here

Hint

Use a Python dictionary with task names as keys and durations as values.

2

Create the dependencies dictionary

Create a dictionary called dependencies with these exact entries: 'B': ['A'], 'C': ['A'], 'D': ['B', 'C'], 'E': ['D']. Tasks without dependencies should not appear as keys.

Software Engineering

tasks = {'A': 3, 'B': 2, 'C': 4, 'D': 2, 'E': 3}
# Create the dependencies dictionary
# Your code here

Hint

Use a dictionary where keys are tasks and values are lists of tasks they depend on.

3

Calculate earliest start and finish times

Create two dictionaries called earliest_start and earliest_finish. For each task, calculate earliest start as the maximum earliest finish of its dependencies (or 0 if none), and earliest finish as earliest start plus task duration. Use a for loop over tasks in order ['A', 'B', 'C', 'D', 'E'].

Software Engineering

tasks = {'A': 3, 'B': 2, 'C': 4, 'D': 2, 'E': 3}
dependencies = {'B': ['A'], 'C': ['A'], 'D': ['B', 'C'], 'E': ['D']}
# Calculate earliest start and finish times
# Your code here

Hint

Use a loop over tasks in order, check dependencies, and calculate start and finish times accordingly.

4

Identify the critical path

Create a list called critical_path starting from task 'E'. Use a while loop to move backwards by choosing the dependency with the highest earliest finish time until reaching task 'A'. Append each task to critical_path and then reverse the list to get the path from start to end.

Software Engineering

tasks = {'A': 3, 'B': 2, 'C': 4, 'D': 2, 'E': 3}
dependencies = {'B': ['A'], 'C': ['A'], 'D': ['B', 'C'], 'E': ['D']}
earliest_start = {}
earliest_finish = {}
for task in ['A', 'B', 'C', 'D', 'E']:
    if task not in dependencies:
        earliest_start[task] = 0
    else:
        earliest_start[task] = max(earliest_finish[dep] for dep in dependencies[task])
    earliest_finish[task] = earliest_start[task] + tasks[task]
# Identify the critical path
# Your code here

Hint

Start from the last task and move backwards choosing the dependency with the highest earliest finish time until you reach the first task.

Practice

1. What does the Critical Path Method (CPM) primarily help determine in a project?

easy

A. The total cost of the project

B. The longest sequence of dependent tasks that sets the project duration

C. The number of team members required

D. The quality standards for project deliverables

Solution

1. Step 1: Understand the purpose of CPM

   The Critical Path Method is used to find the longest chain of tasks that must be completed on time to avoid delaying the project.

2. Step 2: Identify what CPM does not measure

   CPM does not calculate cost, team size, or quality standards; it focuses on task sequencing and timing.

3. Final Answer:

   The longest sequence of dependent tasks that sets the project duration -> Option B

4. Quick Check:

   CPM = longest task sequence [OK]

Hint: CPM finds the longest chain of tasks to finish on time [OK]

Common Mistakes:

• Confusing CPM with cost estimation
• Thinking CPM calculates resources needed
• Assuming CPM sets quality standards

2. Which of the following is the correct way to represent a task dependency in a project network diagram?

easy

A. Task A finishes before Task B starts, but they are independent

B. Task A and Task B start at the same time regardless of each other

C. Task B starts only after Task A finishes

D. Task B can start before Task A finishes

Solution

1. Step 1: Understand task dependency in CPM

   In CPM, a task dependency means one task must finish before the next can start.

2. Step 2: Evaluate each option

   Only Task B starts only after Task A finishes correctly states that Task B starts after Task A finishes, showing a dependency.

3. Final Answer:

   Task B starts only after Task A finishes -> Option C

4. Quick Check:

   Dependency = task B after task A [OK]

Hint: Dependencies mean one task waits for another to finish [OK]

Common Mistakes:

• Assuming tasks can start simultaneously without dependency
• Thinking tasks are independent when they have dependencies
• Believing a task can start before its predecessor finishes

3. Given tasks with durations and dependencies:
Task A: 3 days (start)
Task B: 4 days (after A)
Task C: 2 days (after A)
Task D: 5 days (after B and C)
What is the total project duration using CPM?

medium

A. 9 days

B. 7 days

C. 14 days

D. 12 days

Solution

1. Step 1: Calculate paths and durations

   Path 1: A (3) -> B (4) -> D (5) = 3 + 4 + 5 = 12 days
   Path 2: A (3) -> C (2) -> D (5) = 3 + 2 + 5 = 10 days

2. Step 2: Identify the critical path

   The longest path is Path 1 with 12 days, so the project duration is 12 days.

3. Final Answer:

   12 days -> Option D

4. Quick Check:

   Longest path duration = 12 days [OK]

Hint: Add durations along longest dependent path [OK]

Common Mistakes:

• Adding all tasks durations regardless of dependencies
• Choosing the shortest path instead of longest
• Ignoring that D depends on both B and C

4. A project has tasks:
A (2 days), B (3 days after A), C (4 days after B), D (1 day after A)
Which task dependency is incorrect if the critical path is A -> B -> C?

medium

A. Task D depends on Task C

B. Task D depends on Task A

C. Task B depends on Task A

D. Task C depends on Task B

Solution

1. Step 1: Analyze given dependencies

   Tasks A, B, and C form the critical path with dependencies A->B->C.
   Task D depends on A, so it starts after A.

2. Step 2: Check if Task D depends on Task C

   Since D depends on A only, not on C, Task D depends on Task C is incorrect because it states D depends on C.

3. Final Answer:

   Task D depends on Task C -> Option A

4. Quick Check:

   Incorrect dependency = D on C [OK]

Hint: Check if dependencies match critical path order [OK]

Common Mistakes:

• Assuming all tasks depend on the last task
• Mixing up which tasks depend on which
• Ignoring the critical path sequence

5. You have tasks:
W: 2 days (start)
X: 3 days (after W)
Y: 4 days (after W)
Z: 1 day (after X and Y)
If task Y is delayed by 2 days, what is the new project duration?

hard

A. 9 days

B. 10 days

C. 8 days

D. 7 days

Solution

1. Step 1: Calculate original paths durations

   Path 1: W (2) -> X (3) -> Z (1) = 6 days
   Path 2: W (2) -> Y (4) -> Z (1) = 7 days

2. Step 2: Add delay to task Y and recalculate

   Y delayed by 2 days: Y duration = 4 + 2 = 6 days
   New Path 2 duration: 2 + 6 + 1 = 9 days

3. Step 3: Determine new project duration

   Longest path is now Path 2 with 9 days, so project duration is 9 days.

4. Final Answer:

   9 days -> Option A

5. Quick Check:

   Delay added to longest path = 9 days [OK]

Hint: Add delay to longest path tasks only [OK]

Common Mistakes:

• Adding delay to shortest path
• Ignoring delay impact on critical path
• Calculating total duration without dependencies