GCSE · Computer Science · Edexcel · Spec 1CP2

Benefits of subprograms

Imagine hunting for one mistake in a program thousands of lines long. Programmers make that easier by splitting a program into small, named pieces that each do one job.

Programming · Subprograms

Watch where the program goes

This program works out what you'd pay for some pens and some books. Step through it and follow the highlighted line. It doesn't just go down the page.

Predict first: when line 5 calls total_cost, which line do you think runs next?

 1  def total_cost(price, quantity):
 2      cost = price * quantity
 3      return cost
 4  # main program
 5  pens = total_cost(2, 3)
 6  books = total_cost(5, 2)
 7  print(pens + books)

Variables

Output

Step 1: total_cost is written at the top, but it's out of line. The computer reads that it's there and doesn't run the code inside it yet. It waits to be called.

1 / 12

Press Next and watch the highlight jump out of the main program and back. Then watch it do it again.

Step 1 of 12: total_cost is written at the top, but it's out of line. The computer reads that it's there and doesn't run the code inside it yet. It waits to be called..

Watch out: The main program never gets to use cost itself. It only gets the value total_cost returns, which is why that value is stored in pens, and then in books.

Programming · Program structure

One program, split into single-task subprograms

Showing 1 layer: Program structure

Explore

tap each box, then the line to check_answer

Each subprogram does one specific task. The lines are the joins where data passes in and out.

A quiz program, structured as a main program and three subprograms.

Programming · The five benefits

Which benefit is this?

Pick a moment, then pick the benefit it shows.

Still to sort

Easier to read (0)

Small chunks of code are much easier to read and check through than one very large program.

Easier to test (0)

A subprogram that does a single task is easier to test, and with less code, mistakes are easier to find and fix.

Where the line is: Reading and checking through the code is readability. Testing is about finding and fixing mistakes in one single-task subprogram.

Easier to maintain (0)

A change can be made and tested in one place, and the rest of the program isn't affected.

Where the line is: Maintenance is about changing the program. The change stays in one subprogram, so the rest of the program carries on, even if the new version doesn't work yet.

Faster development (0)

Several programmers can each develop a different subprogram at the same time.

Where the line is: It's the development time that gets shorter, because several people are building the program at once.

Less repeated code (0)

A subprogram can be called as many times as it's needed, so its code only has to be written once.

Where the line is: This is about calling the same subprogram again, instead of writing the same code again.

6 of 6 still to sort.

Every one of these moments happens only because the quiz program is split into small, single-task subprograms. That is the root of all five benefits.

Programming · Check your thinking

Do subprograms mean fewer errors?

A classmate's revision notes say: "Benefit of subprograms: you make fewer errors when you code."

Which of these is closest to what you think?

Fair enough. Splitting a program into subprograms means you make fewer coding errors.Not quite. You can still make errors, but they're easier to find and fix, because each subprogram is small and does one task.Errors are easier to find because the subprograms are written at the top of the program.With subprograms, the computer finds and fixes your mistakes for you.

How sure are you?

I'm sureI think soI'm guessing

Fair enough. Splitting a program into subprograms means you make fewer coding errors.

This is a common misconception

This is the one that catches people out. Splitting a program up doesn't stop you making mistakes, so 'fewer errors' isn't a benefit. What subprograms change is how easy mistakes are to deal with: each subprogram is small and does one task, so a mistake is easier to find and fix.

Not quite. You can still make errors, but they're easier to find and fix, because each subprogram is small and does one task.

This matches the evidence

Exactly right. 'Fewer errors' isn't a benefit; 'errors are easier to find and fix' is. A subprogram that carries out a single task is much easier to test, and with less code to look through, mistakes are easier to track down.

Errors are easier to find because the subprograms are written at the top of the program.

This is a common misconception

Where a subprogram is written isn't the reason. The top is just where it usually sits, out of line, until it's called. Errors are easier to find because each subprogram is small and does one task, so it's easier to test, with far less code to search.

With subprograms, the computer finds and fixes your mistakes for you.

This is a common misconception

No: finding and fixing mistakes is still the programmer's job. Subprograms make that job easier, because you're testing a small subprogram that does a single task, with much less code to search.

Subprograms don't mean fewer errors. They make errors easier to find and fix, because each one is small and does one task.

Programming · Your turn

Explain it in your own words

A team of programmers is writing a large quiz program, and they split it into subprograms. Explain how this helps (a) while the team is building the program and (b) when the scoring rules change after the program is finished. [4 marks]

Your answer

0 words · your answer stays on this page and is not sent anywhere.

The mark scheme

(a) Different programmers can each write a different subprogram. (1 mark)
(a) They can work at the same time (concurrently), so development time is faster. (1 mark)
(b) Only the subprogram that handles scoring needs changing, so the change is made and tested in one place. (1 mark)
(b) The rest of the program isn't affected by the change. (1 mark)

Model answer

(a) The work can be shared out. Each programmer writes a different subprogram, and because they can all work at the same time, the program is developed faster. (b) The new scoring rules only need changing in the subprogram that handles scoring. The change is made and tested in that one place, and the rest of the program isn't affected.

Say what splitting the program lets you do, then say why that helps. A benefit with no reason is only half an answer.

WHAT YOU'VE LEARNED

A quick recap of today's lesson.

Why programmers split a program into small, named parts that each do one job, and what that buys them.

What you need to know

A subprogram is a sequence of instructions that performs a specific task and has an identifiable name.
In structured programming, a program is divided into smaller sections called subprograms, each designed to do one specific task. As programs grow more complex, this makes them easier to understand and manage.
A subprogram is an out-of-line block of code, typically written at the top of the program and called from the main program. So a program doesn't simply run line by line from top to bottom.
The interface decides how data passes in and out of a subprogram. It's made up of the identifier (a meaningful name), the parameters (the information that must be passed in) and the return value (passed back to the main program).
The main program can only use a variable from a subprogram if it is returned.
The benefits: code is easier to read, easier to test and easier to maintain, development is faster because a team can work on different subprograms at the same time, and there's less repeated code because a subprogram can be called many times.
Subprograms don't reduce the number of coding errors. They make errors easier to find and fix.

The big picture

A subprogram is a named sequence of instructions that does one specific task. It's written out of line and only runs when the main program calls it: execution jumps to it, does the job, and can pass a value back. Data moves in and out through its interface: the identifier, the parameters and the return value. Splitting a program up like this makes it easier to read, test and maintain, faster to develop as a team, and cuts repeated code. It doesn't mean fewer errors, but errors are easier to find.

Key points

1Subprogram: a named sequence of instructions that does one specific task.

2Out of line: it only runs when it's called, and then execution returns to the main program.

3Interface = identifier + parameters (in) + return value (out).

4The main program can only use a subprogram's variable if it's returned.

5Five benefits: easier to read, easier to test, easier to maintain, faster development, less repeated code.

6Not fewer errors: errors that are easier to find and fix.

.we-_R_18slubsnpfiv5ubrb_ [data-we-step]{display:flex !important}.we-_R_18slubsnpfiv5ubrb_ [data-we-solution]{display:block !important}.we-_R_18slubsnpfiv5ubrb_ [data-we-reveal]{display:none !important}

Worked example

Problem

A subprogram is written as: def area(length, width): then result = length * width, then return result. The main program runs room = area(4, 3) and then print(room). Identify the subprogram's identifier, parameters and return value, and say what the program prints.

⚠ Watch out

Naming a benefit without saying why subprograms give it. 'Easier to maintain' on its own is only half an answer. Add the reason: a change can be made and tested in one place, and the rest of the program isn't affected.

🧠

Memory hook

One job, one name, call it again. Small named parts are easier to read, test, maintain, share out and reuse.

✓

Check yourself

A program calls the same subprogram three times with different parameters. Where does execution go on each call, what comes back, and which benefit does this show?

Flashcards

(14)

What is a subprogram?

A sequence of instructions that performs a specific task and has an identifiable name.

What does it mean that a subprogram is 'out of line'?

Its code is written separately, typically at the top of the program, and it only runs when the main program calls it.

Does a program with subprograms run line by line from top to bottom?

No. When a subprogram is called, execution jumps to it, runs it, then goes back to the main program.

What three parts make up a subprogram's interface?

The identifier, the parameters and the return value.

In a subprogram's interface, what are the parameters?

The information that must be passed to the subprogram.

Which part of a subprogram's interface carries data OUT?

The return value, which goes back to the main program.

When can the main program use a variable from a subprogram?

Only if the subprogram returns it.

Why does structuring a program into subprograms make it easier to read?

Small chunks of code are much easier to read and check through than one very large program.

Why are subprograms easier to test?

Each one carries out a single task, and with less code it's easier to find and fix mistakes.

True or false: using subprograms means you make fewer coding errors.

False. Fewer errors isn't a benefit. Subprograms make errors easier to find, not less likely.

Why do subprograms make a program easier to maintain?

A change can be made and tested in one place, and the rest of the program isn't affected, even if the change doesn't work.

How do subprograms give a faster development time?

Several programmers can each develop a different subprogram at the same time (concurrently).

How do subprograms reduce repeated code?

A subprogram can be called as many times as it's needed, instead of the same code being written out again.

What is 'spaghetti code'?

The nickname for code made messy and hard to follow by too many go-to statements.

Tap any card to flip it, or use Study as deck to go through them one at a time. In the full lesson these run as a spaced-repetition deck — you rate each card Hard, Good or Easy and the tricky ones keep coming back until they stick.

Learning with Lightbulb is opening soon

You can use this lesson now. Join the waitlist and we'll let you know when the full Lightbulb experience is ready.

Keep me posted

Watch where the program goes

Which benefit is this?

Do subprograms mean fewer errors?

Explain it in your own words

More Edexcel GCSE Computer Science topics