Modular Programming with Functions

Active learning works for modular programming because students must repeatedly decide how to split tasks, name units, and connect them. These decisions cement the value of functions beyond syntax, turning abstract ideas into concrete, reusable tools.

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

Learning Objectives

1. Design a Python program that effectively utilizes functions to solve a multi-step problem.
2. Analyze a given Python script to identify opportunities for code modularization using functions.
3. Evaluate the impact of well-defined functions on code readability and maintainability.
4. Create a set of reusable functions for common programming tasks, such as input validation or data formatting.
5. Compare the efficiency and structure of a monolithic program versus a modular program with functions.

Collaborative Problem-Solving

⏱ 45 min·Pairs

Pair Programming: Modular Calculator Build

Pairs outline calculator operations, write separate functions for add, subtract, multiply, and divide, then create a main loop for user input. Test with edge cases like division by zero. Pairs demo their calculators to the class.

Prepare & details

Justify why modular programming is crucial for developing complex software applications.

Facilitation Tip: During Pair Programming: Modular Calculator Build, circulate and ask each pair to explain why they placed a specific operation in a function rather than in the main loop.

Setup: Groups at tables with problem materials

Materials: Problem packet, Role cards (facilitator, recorder, timekeeper, reporter), Problem-solving protocol sheet, Solution evaluation rubric

• Apply
• Analyze
• Evaluate
• Create
• Relationship Skills
• Decision-Making
• Self-Management

Collaborative Problem-Solving

⏱ 35 min·Small Groups

Small Groups: Refactoring Relay

Provide a single-script program with repeated code. Groups take turns extracting functions for common tasks, passing the updated code along. End with group presentations on time saved in testing.

Prepare & details

Design a program for a simple calculator, separating operations into distinct functions.

Facilitation Tip: During Small Groups: Refactoring Relay, assign each group a different monolithic script so they experience varied decomposition paths and can compare approaches afterward.

Setup: Groups at tables with problem materials

Materials: Problem packet, Role cards (facilitator, recorder, timekeeper, reporter), Problem-solving protocol sheet, Solution evaluation rubric

• Apply
• Analyze
• Evaluate
• Create
• Relationship Skills
• Decision-Making
• Self-Management

Collaborative Problem-Solving

⏱ 25 min·Whole Class

Whole Class: Modular vs Monolithic Debug

Display two program versions, one modular and one not, each with bugs. Class discusses and votes on fix ease, then codes fixes collaboratively on shared screens.

Prepare & details

Evaluate how well-defined functions improve the debugging process.

Facilitation Tip: During Whole Class: Modular vs Monolithic Debug, deliberately introduce a bug in the monolithic version first so students feel the pain before seeing the fix in the modular version.

Setup: Groups at tables with problem materials

Materials: Problem packet, Role cards (facilitator, recorder, timekeeper, reporter), Problem-solving protocol sheet, Solution evaluation rubric

• Apply
• Analyze
• Evaluate
• Create
• Relationship Skills
• Decision-Making
• Self-Management

Collaborative Problem-Solving

⏱ 30 min·Individual

Individual: Function Design Portfolio

Students independently design three functions for a text adventure game, like movement or inventory checks. Peer review follows, with revisions based on feedback.

Prepare & details

Justify why modular programming is crucial for developing complex software applications.

Facilitation Tip: During Individual: Function Design Portfolio, require students to submit both code and a short rationale paragraph for each function they create.

Setup: Groups at tables with problem materials

Materials: Problem packet, Role cards (facilitator, recorder, timekeeper, reporter), Problem-solving protocol sheet, Solution evaluation rubric

• Apply
• Analyze
• Evaluate
• Create
• Relationship Skills
• Decision-Making
• Self-Management

Teaching This Topic

Teachers approach this topic by making decomposition visible: use color coding to mark function boundaries in shared code, and insist on naming conventions that reveal purpose. Avoid rushing to solutions; instead, pause after each function is written and ask, 'How could another part of the program use this without rewriting?' Research supports frequent, low-stakes refactoring to build mental models of modularity.

What to Expect

Successful learning looks like students designing clear function boundaries, reusing code without duplication, and confidently tracing data flow between functions and the main program. You will see fewer global variables and more comments explaining function purposes.

Watch Out for These Misconceptions

Common Misconception

During Pair Programming: Modular Calculator Build, students may argue that functions just make code longer without benefits.

What to Teach Instead

During this activity, have each pair time how long it takes to find and fix a deliberate bug in their first monolithic version versus in their refactored version with separate functions.

Common Misconception

During Small Groups: Refactoring Relay, students might believe everything belongs in the main program body.

What to Teach Instead

During this relay, ask groups to count how many lines of repeated code they remove by creating functions and compare that to the total lines in their original scripts.

Common Misconception

During Function Design Portfolio, students often think functions cannot share or modify data effectively.

What to Teach Instead

In this portfolio, require students to use parameters and return values for all data sharing, then review their submissions to highlight cases where globals were replaced.

Assessment Ideas

Exit Ticket

After Pair Programming: Modular Calculator Build, give students a short, non-modular Python script and ask them to identify at least two sections that could become functions, writing proposed names and purposes.

Quick Check

During Small Groups: Refactoring Relay, present the scenario of writing a program that takes user input for name, age, and email, validates each input, and prints a welcome message. Ask each group to list the distinct functions they would create and describe what each would do.

Peer Assessment

After Whole Class: Modular vs Monolithic Debug, have students swap calculator programs created in the Pair Programming activity and complete a review checklist: Does each operation have its own function? Is the main program clear and easy to follow? Are there repeated lines that could be functions?

Extensions & Scaffolding

• Challenge: Ask early finishers to extend their calculator with a new operation (e.g., exponentiation) using a function that calls two existing functions.
• Scaffolding: Provide partially written functions with missing parameters or return statements for students who struggle to design signatures.
• Deeper exploration: Introduce scope by having students pass the same list to multiple functions and observe how changes in one function affect the list in another.

Key Vocabulary

Function	A named block of reusable code that performs a specific task. Functions help organize programs and reduce repetition.
Modularity	The design principle of breaking down a large software system into smaller, independent, and interchangeable modules or functions.
Decomposition	The process of breaking down a complex problem or system into smaller, more manageable parts, often corresponding to functions.
Code Reuse	The practice of using existing code, typically in the form of functions or modules, in new programs to save time and effort.
Abstraction	Hiding complex implementation details and exposing only the essential features of a function or module.