Subroutines, Functions, and Modularity

Active learning works for subroutines and functions because students must physically break down problems, see immediate consequences of their design choices, and experience firsthand how modularity reduces errors. When students refactor messy code or debug broken functions together, they move from abstract concepts to concrete outcomes that reveal why organisation matters.

• Year 11
• Computing
• 4 activities
• 25 min–45 min

Learning Objectives

1. Analyze the benefits of using functions for code organization and debugging.
2. Differentiate between parameters and arguments when calling a function.
3. Construct a program that effectively utilizes multiple user-defined functions.
4. Evaluate the impact of modularity on code readability and maintainability.
5. Synthesize code from multiple functions to solve a larger programming problem.

Flipped Classroom

⏱ 30 min·Pairs

Pair Refactoring Challenge: Modularise a Calculator

Provide students with a linear script for a basic calculator. In pairs, identify repeated operations and refactor them into functions with parameters. Test the modular version by adding a new operation and compare debugging time to the original.

Prepare & details

Analyze the benefits of using functions for code organization and debugging.

Facilitation Tip: During the Pair Refactoring Challenge, circulate and ask each pair to verbally explain why they chose specific functions before they write any code, forcing early design thinking.

Setup: Standard classroom, flexible for group activities during class

Materials: Pre-class content (video/reading with guiding questions), Readiness check or entrance ticket, In-class application activity, Reflection journal

• Understand
• Apply
• Analyze
• Self-Management
• Self-Awareness

Flipped Classroom

⏱ 45 min·Small Groups

Small Group Design Sprint: Modular Game Logic

Groups outline a simple text-based game, then decompose it into functions for input handling, scoring, and output. Write and integrate the functions, passing arguments between them. Share one function with the class for peer review.

Prepare & details

Differentiate between parameters and arguments when calling a function.

Facilitation Tip: For the Small Group Design Sprint, provide a timer and enforce strict role rotation so every student contributes to function definition, parameter design, and testing phases.

Setup: Standard classroom, flexible for group activities during class

Materials: Pre-class content (video/reading with guiding questions), Readiness check or entrance ticket, In-class application activity, Reflection journal

• Understand
• Apply
• Analyze
• Self-Management
• Self-Awareness

Flipped Classroom

⏱ 35 min·Whole Class

Whole Class Debug Relay: Function Fault-Finding

Display a buggy modular program on the board. Teams take turns identifying errors in specific functions, passing arguments correctly, and suggesting fixes. The class votes on solutions before running the updated code together.

Prepare & details

Construct a program that effectively utilizes multiple user-defined functions.

Facilitation Tip: In the Whole Class Debug Relay, assign each error to a different group and require them to present the fix using the function’s purpose as the anchor for their explanation.

Setup: Standard classroom, flexible for group activities during class

Materials: Pre-class content (video/reading with guiding questions), Readiness check or entrance ticket, In-class application activity, Reflection journal

• Understand
• Apply
• Analyze
• Self-Management
• Self-Awareness

Flipped Classroom

⏱ 25 min·Individual

Individual Function Portfolio: Reusable Utilities

Students create three utility functions, such as string validation or list sorting, with clear parameters. Document usage examples and test cases. Submit for teacher feedback on modularity and reusability.

Prepare & details

Analyze the benefits of using functions for code organization and debugging.

Setup: Standard classroom, flexible for group activities during class

Materials: Pre-class content (video/reading with guiding questions), Readiness check or entrance ticket, In-class application activity, Reflection journal

• Understand
• Apply
• Analyze
• Self-Management
• Self-Awareness

Teaching This Topic

Teachers approach this topic by having students experience the pain of repetition first, then introducing functions as the relief. Use live coding to model how a small change in one function updates everywhere it’s called. Avoid teaching function syntax in isolation; instead, embed it in meaningful tasks where students feel the benefit of reuse immediately. Research shows that students grasp parameters better when they see mismatched arguments crash the program, so design activities that make these errors visible and fixable in real time.

What to Expect

Successful learning looks like students confidently breaking problems into smaller pieces, passing arguments correctly, and explaining how isolated functions improve debugging and reuse. By the end, they should articulate why modularity matters in their own words and apply it in new contexts without prompting.

Watch Out for These Misconceptions

Common Misconception

During the Pair Refactoring Challenge, watch for students treating functions as mere shortcuts rather than organised logic blocks.

What to Teach Instead

Pause the activity after 10 minutes and ask each pair to point to a function they created and explain what specific problem it solves in isolation; redirect any vague answers by having them trace how changes to that function affect the program’s output.

Common Misconception

During the Whole Class Debug Relay, watch for students confusing parameters and arguments in error messages.

What to Teach Instead

Require each group to write the corrected function call on the board, labeling each argument and mapping it to the corresponding parameter, then explain why mismatched types caused the original error.

Common Misconception

During the Small Group Design Sprint, watch for students defaulting to global variables for shared state.

What to Teach Instead

Introduce a design rule: no global variables allowed in this sprint. If students use them, ask them to refactor by moving shared data into parameters and observe how the function becomes more reusable and predictable.

Assessment Ideas

Exit Ticket

After the Pair Refactoring Challenge, give students a printed code snippet with one function. Ask them to identify the function’s name, parameters, and arguments, then write one sentence explaining its purpose and one benefit of modularising this code.

Quick Check

After the Small Group Design Sprint, collect each group’s final function definitions and test cases. Check that their functions include meaningful parameters, avoid global variables, and come with at least one test that verifies correct argument handling.

Discussion Prompt

During the Whole Class Debug Relay, after each group presents their fix, ask the class: 'How did the presence of separate functions make locating and fixing this error easier than it would have been in a single long block of code? Have students cite specific lines and functions in their answers.'

Extensions & Scaffolding

• Challenge: Ask students to extend their reusable utilities portfolio with a function that processes multiple data types (e.g., list, string, integer) using type hints and exception handling.
• Scaffolding: Provide partially written function headers with parameter names and types for students to complete during the Function Portfolio activity.
• Deeper exploration: Have students research and implement callback functions in their game logic, then document how higher-order functions reduce code duplication in event-driven programs.

Key Vocabulary

Subroutine	A block of code that performs a specific task and can be called from other parts of the program. It may or may not return a value.
Function	A type of subroutine that performs a specific task and always returns a value to the part of the program that called it.
Modularity	The practice of breaking down a large program into smaller, independent, and interchangeable modules or functions.
Parameter	A variable listed inside the parentheses in the function definition. It acts as a placeholder for a value that will be passed into the function.
Argument	The actual value that is sent to a function when it is called. This value is assigned to the corresponding parameter.
Reusability	The ability of code, such as a function, to be used multiple times in the same program or in different programs without being rewritten.