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

Need a 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

Need a 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

Need a 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

Need a hint?

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