← VCE Software Development U4O1

Assessing project plan effectiveness: number of changes

A plan that needed few changes was likely more effective. Count the changes made during the project and compare that count with the size of the plan, such as its total tasks.

Part of: VCE Software Development - U4O1 - development and evaluation — Module 195

Understanding Assessing project plan effectiveness: number of changes in VCE Software Development U4O1

What it does: A low change rate (few changes relative to total tasks) suggests the plan was effective, which the if statement tests. You start by counting the changes (such as tasks added, removed or rescheduled) recorded in the project log or journal. Compare the count with the size of the plan. 4 of 8 tasks is half the plan changing, while 4 of 40 is only one tenth. Few changes is a good sign, but a strong assessment also considers reasons for the changes and their impact.

Common mistakes: len() is a built-in function, not a list method. To count the changes made during the project, write len(changes). Without the f prefix, Python prints the text {ratio} literally instead of the change ratio. It should be print(f"Ratio: {ratio}").

Class: _____________________ · Name: _____________________ · Date: _________

Free printable worksheet with full answer key — or add this module to a class and your students practise it interactively.

🖨 Print worksheet + answer key Add Assessing project plan effectiveness: number of changes to a class →

This module's key terms are also in a printable crossword (Modules 186–198) and word search (Modules 172–198).

Take this worksheet further — free with Cloodit

Each concept is reinforced from every angle — learned, then applied, then tested.

Learning

Duo

A Gantt chart had 20 tasks and needed only 2 changes during the project. What does this suggest about the plan?

It was likely effective because few changes were neededIt was likely ineffective because it was changed at all

Matches

A plan with 10 changes is always less effective than a plan with 3 changes, whatever its size.

↓

The count of changes must be compared with the size of the plan. 10 changes in a 100-task plan is a lower rate than 3 changes in a 5-task plan.

Applying

Meanings

Term

number of changes

Meaning

A plan that needed few changes was likely more effective. Count the changes made during the project and compare that count with the size of the plan, such as its total tasks.

Practice

total_tasks ← 20

Testing

Gaps

changes = (log)

Check Answer

Spots

1changes = ["add", "drop"]

2n_changes = changes.len()

Cloodit turns curriculum-aligned coding content into journeys students work through one biome at a time.

Students earn collectable badges

Over 100 of them, across seven natural biomes.

Study Buddy

Students build a real study resource

Turns their work into revision material ready for Flash Cards and Exam study.

Diamond Dash — one of Cloodit's live, competitive Sprint games

Students lock in with Sprints

Live, competitive practice for the start of the lesson or a teacher-led lesson finisher.

A Cloodit certificate of achievement, ready to personalise and print

Custom printable certificates

Honour your top performers, or encourage a student who's trying hard — ready to print in seconds.

Add to class →

Quick Questions

1. A Gantt chart had 20 tasks and needed only 2 changes during the project. What does this suggest about the plan?

A. It was likely ineffective because it was changed at all

B. It was likely effective because few changes were needed ✓

A plan that needed few changes was likely more effective. 2 changes out of 20 tasks is a small number.

2. Which is the first step when using the number of changes to assess a plan's effectiveness?

A. Count the changes made during the project ✓

B. Count the number of team members

You start by counting the changes (such as tasks added, removed or rescheduled) recorded in the project log or journal.

3. Plan A: 4 changes in a 40-task plan. Plan B: 4 changes in a 8-task plan. Which plan was likely more effective?

A. Plan A, because 4 changes is a small share of 40 tasks ✓

B. Plan B, because the plans had the same number of changes

Compare the count with the size of the plan. 4 of 8 tasks is half the plan changing, while 4 of 40 is only one tenth.

4. Why compare the number of changes with the total number of tasks in the plan?

A. It shows how fast the programmer types code

B. It shows how big the changes were relative to the plan's size ✓

A raw count means little on its own. Comparing it with the plan size, such as total tasks, gives context.

5. A project had 10 tasks and 8 changes were made. What is the best conclusion?

A. The plan was probably not very effective as it needed many changes ✓

B. The plan was very effective as it was updated often

Many changes compared with the plan size suggest the original plan did not match what the project needed.

Match the Pairs

changes = 3 → Counts how many changes were made to the plan during the project

change_rate = changes / total_tasks → Compares the number of changes with the size of the plan

A plan with only a few changes compared with its size was likely more effective → if change_rate < 0.2: print("Plan was effective")

Count each change made to the plan during the project → changes = changes + 1

A plan with 10 changes is always less effective than a plan with 3 changes, whatever its size. → The count of changes must be compared with the size of the plan. 10 changes in a 100-task plan is a lower rate than 3 changes in a 5-task plan.

A plan with many changes was likely more effective because the team adapted. → Many changes usually suggest the original plan was less effective, because it needed a lot of fixing. Few changes suggests a more effective plan.

Key Term

number of changes

A plan that needed few changes was likely more effective. Count the changes made during the project and compare that count with the size of the plan, such as its total tasks.

Fill in the Blanks

1. log = ["moved task 4", "new task"] changes = len(log)

Hint: Type the built-in function that counts how many items are in a list.

2. total = 20 changes = 5 ratio = changes / total

Hint: Type the arithmetic operator that divides the number of changes by the plan size.

3. log = [] log.append("moved task 4")

Hint: Type the list method that records one more change at the end of the log.

4. total = 20 changes = 5 percent = changes / total * 100

Hint: Type the number that turns a fraction of the plan into a percentage.

5. if changes < 3: print("Likely an effective plan")

Hint: Type the comparison operator that checks the change count is below the limit, meaning few changes.

Spot the Error

Question 1

A changes = ["add", "drop"]

B n_changes = changes.len()

C n_tasks = 20

D ratio = n_changes / n_tasks

E print(ratio)

Line B — len() is a built-in function, not a list method. To count the changes made during the project, write len(changes).

Question 2

A n_changes = 3

B n_tasks = 24

C ratio = n_changes / n_tasks

D print("Ratio: {ratio}")

Line D — Without the f prefix, Python prints the text {ratio} literally instead of the change ratio. It should be print(f"Ratio: {ratio}").

Question 3

A tasks = [True, False, True]

B changes = 0

C for changed in tasks

D if changed:

E changes += 1

Line C — A for loop header must end with a colon. Without it the program has a syntax error and cannot count the changed tasks.

Question 4

A n_changes = "2"

B n_tasks = 40

C if n_changes / n_tasks < 0.1:

D print("Few changes")

Line A — The count is stored as a string, so dividing it by n_tasks causes a TypeError. The number of changes should be the integer 2.

Question 5

A changes_log = ["add", "move"]

B n_changes = len(changes_log)

C if n_changes >= 3:

D print("Effective plan")

Line C — The logic is reversed. A plan with few changes is likely more effective, so the test should be n_changes <= 3, not >= 3.

Student with a class code? Join your class →