Waterfall (sequential) development

Name:

Date:

Class:

Quick Questions

Shade in the A or B circle for each question.

1. In waterfall development, which statement is correct?

A Each stage is finished before the next stage starts

B All stages run at the same time in short cycles

2. Which order shows the stages of waterfall development?

A Build, release, design, test, requirements

B Requirements, design, build, test, release

3. A client wants a school canteen app and signs off every requirement before design starts. Which method fits?

A Waterfall, because the requirements will change every week

B Waterfall, because the requirements are fixed up front

4. The team has finished the build stage and now wants to change a core requirement. What is likely to happen in waterfall?

A The change is costly because earlier stages must be redone

B The change is cheap because waterfall expects constant changes

5. Which is a feature of waterfall development?

A Little change is allowed once a stage is complete

B Users test a new version at the end of every week

Match the Pairs

Draw a line connecting each item on the left to its match on the right.

Left column		Right column
1Requirements → Design → Build → Test → Release		AThe stages are in the wrong order. Waterfall must run Requirements, then Design, then Build, then Test, then Release.
2requirements_signed_off = True		BThe fixed order of waterfall stages, where each stage is finished before the next one starts
3In waterfall, a stage must be finished before the next stage can start		Cif design_complete: start_build()
4A change found late in a waterfall project costs more because earlier finished stages must be redone		DThe requirements are fixed and locked in, so later changes need extra approval and effort
5Build → Design → Requirements → Test → Release		Echange_cost = redo_design + redo_build + retest
6Waterfall: change the requirements freely after the Build stage with no extra cost		FWaterfall has fixed requirements, so late changes are costly because finished stages must be reworked.

Definitions

waterfall development

Fill in the Blanks

Complete each line of code by filling in the missing parts.

stageDone ← TRUE IF _________ THEN startNextStage()

requirementsLocked ← ____ IF requirementsLocked THEN rejectChange()

costEarly ← 100 costLate ← costEarly _ 10

___ stage IN stages complete(stage) signOff(stage)

IF changeCost _ budget THEN rejectChange() ENDIF

Spot the Error

Shade in the letter of the line that contains an error.

Question 1

A stage = "requirements"

B while stage == "release":

C print("Finish", stage)

D stage = next_stage(stage)

Question 2

A current = "design"

B approved = True

C if approved:

D current = "test"

Question 3

A change_cost = 1

B for stage in done_stages:

C change_cost /= 2

D print(change_cost)

Question 4

A requirements_fixed = False

B if requirements_fixed:

C print("Start design")

D lock_requirements()

Question 5

A def finish(stage)

B print(stage, "complete")

C return True

Answer Key

Waterfall (sequential) development

Section A: Quick Questions

A — Each stage is finished before the next stage starts

B — Requirements, design, build, test, release

B — Waterfall, because the requirements are fixed up front

A — The change is costly because earlier stages must be redone

A — Little change is allowed once a stage is complete

Section B: Match the Pairs

Requirements → Design → Build → Test → Release → The fixed order of waterfall stages, where each stage is finished before the next one starts

requirements_signed_off = True → The requirements are fixed and locked in, so later changes need extra approval and effort

In waterfall, a stage must be finished before the next stage can start → if design_complete: start_build()

A change found late in a waterfall project costs more because earlier finished stages must be redone → change_cost = redo_design + redo_build + retest

Build → Design → Requirements → Test → Release → The stages are in the wrong order. Waterfall must run Requirements, then Design, then Build, then Test, then Release.

Waterfall: change the requirements freely after the Build stage with no extra cost → Waterfall has fixed requirements, so late changes are costly because finished stages must be reworked.

Section C: Definitions

waterfall development — A method where each stage (requirements, design, build, test, release) is finished in fixed order before the next starts, with little change once done, so late changes cost more.

Section D: Fill in the Blanks

stageDone ← TRUE
IF stageDone THEN
  startNextStage()

requirementsLocked ← TRUE
IF requirementsLocked THEN
  rejectChange()

costEarly ← 100
costLate ← costEarly * 10

FOR stage IN stages
  complete(stage)
  signOff(stage)

IF changeCost > budget THEN
  rejectChange()
ENDIF

Section E: Spot the Error

B — The loop must keep finishing stages until release is reached, so the condition should be stage != "release". With == the loop would never run at the start.

D — Waterfall follows a fixed order. After design is approved the next stage is build, not test. Skipping build breaks the sequence.

C — In waterfall, each finished stage makes a change more expensive. The cost should grow with *= 2, not shrink with /= 2.

A — Waterfall needs the requirements finished and fixed before design starts. The flag should be True, otherwise the design stage would never begin.

A — A Python function definition must end with a colon. It should be def finish(stage):.