Stretch tasks Subroutines and Structured Programming

Round 1: Quiz Blitz

1. A function returns a value; a procedure does not A function's call appears where a value is expected.
2. Parameters Parameters are the names in the definition.
3. Arguments Arguments are the actual values passed in when the subroutine is called.
4. 28 4 x 7 = 28.
5. True It is created when the subroutine starts and destroyed when it ends.
6. 1 count is local, so it starts again at 0 on every call.
7. The part of the program where it can be accessed Local variables have the scope of their subroutine. Globals can be reached anywhere.
8. Other subroutines cannot change them by accident; Their memory is freed when the subroutine ends They also keep each subroutine self-contained.
9. Building a program from self-contained subroutines Each subroutine has clearly defined inputs and outputs.
10. False They suit genuinely shared values, such as a game's running total. Their danger is that anything can change them.
11. As a statement on its own greet('Amira') stands alone. A function call sits where a value is needed.
12. Each subroutine can be tested on its own; A change is made in one place It is also easier to write, read and reuse.

Round 2: Quick Fire

1. • A parameter is the name in the subroutine's definition
   • An argument is the actual value passed in when it is called
   Model answer

   A parameter is the name listed in the subroutine's definition. An argument is the actual value passed in when the subroutine is called.

2. • count is a local variable
   • It is created and set to 0 again on each call
   Model answer

   count is a local variable, so it is created and set to 0 each time the subroutine runs, and destroyed when it ends. It always goes from 0 to 1.

3. • Other subroutines cannot change them by accident
   • Their memory is reclaimed when the subroutine ends
   • They keep the subroutine self-contained and reusable
   Model answer

   No other subroutine can change them by accident, and their memory is reclaimed as soon as the subroutine ends.

4. • Easier to maintain, test, reuse or read
   • Because each task is in one self-contained subroutine
   Model answer

   It is easier to maintain, because a change only has to be made in the one subroutine responsible for that task, rather than everywhere the code was repeated.

Round 3: Big Think

1. • A SUBROUTINE header with a parameter
   • RETURN the new price
   • Works out price * 0.9
   • Ends with ENDSUBROUTINE
   • Calls it with an argument
   Model answer

   AQA pseudo-codeCopy

   SUBROUTINE discount(price)
       RETURN price * 0.9
   ENDSUBROUTINE
   
   sale ← discount(50)

2. • Easier to write: the problem is decomposed into small tasks
   • A team can work on different subroutines at the same time
   • Easier to test: each subroutine is tested on its own
   • A fault is found inside one small routine
   • Easier to maintain: a change is made in one place
   • Subroutines can be reused in other programs
   • Easier to read: the names explain the program
   Model answer

   Structured programming is easier to write, because decomposing the problem gives small tasks, and two people can work on different subroutines at the same time. It is easier to test, because each subroutine has defined inputs and can be tested on its own, so a fault is found inside one small routine. It is easier to maintain, because a change only has to be made in the one subroutine responsible, not everywhere the code was repeated. Subroutines can be reused in other programs, and a main program made of well-named calls is easier to read.

This or That

1. A function A function returns a value. A procedure just carries out a task.
2. A global variable That is what makes globals useful, and dangerous.
3. They stay completely separate Each local i exists only inside its own subroutine.
4. When many parts share one value A running total in a game is a fair use. Most values should be local.
5. An argument It is the actual value passed in. The parameter is the name in the definition.
6. In size The function returns 28, and the assignment stores it in size.
7. The reason: a change is in one place Examiners want the reason, not just the label.
8. No: parameters make it reusable Taking any two numbers as parameters lets it be called anywhere.

Memory Match

• A 6 Procedure: Does a task, returns nothing
• B 5 Function: Returns a value
• C 4 Parameter: A name in the subroutine definition
• D 2 Argument: The value passed in a call
• E 1 Local variable: Exists only while its subroutine runs
• F 3 Scope: Where a variable can be accessed

Sort It

1. Global Suits a running total shared by the whole game Genuinely shared values are a fair use of a global.
2. Local Declared inside a subroutine That makes it local to the subroutine.
3. Local Its memory is freed when the subroutine ends A local variable stops using memory at the end.
4. Global Keeps its value between subroutine calls It is not destroyed when a subroutine ends.
5. Global Can be accessed anywhere in the program Global scope covers the whole program.
6. Global Declared outside every subroutine That makes it global.
7. Global A bug in it can come from anywhere Any subroutine can change a global.
8. Local Keeps a subroutine self-contained Everything it uses lives inside it.
9. Local Two subroutines can each have one called i Locals in different subroutines never clash.
10. Local Exists only while its subroutine runs It is destroyed when the subroutine ends.