Computing · Secondary 4

Active learning ideas

Scope of Variables: Local and Global

Active learning works for this topic because students need to see scope in action to trust it. Watching variables behave differently across boundaries sticks better than lecture, especially when students debug or refactor broken code themselves. The hands-on activities let students confront their assumptions directly, turning abstract rules into visible consequences.

• MOE Syllabus Outcomes
• MOE: Programming - S4

• 30–50 min
• Pairs → Whole Class
• 4 activities

Activity 01

• Problem-Based Learning
• 30 min · Pairs

Debugging Challenge: Global Variable Hunt

Provide pairs with a buggy program using excessive globals causing errors. Students trace execution, identify issues, and rewrite with locals. Discuss fixes as a class.

Explain how local and global variables affect the integrity and predictability of a program.

Facilitation Tip

During Global Variable Hunt, ask students to trace globals step-by-step aloud, forcing them to verbalize their assumptions before testing.

What to look for

Provide students with a short Python code snippet containing both local and global variables. Ask them to identify which variables are global and which are local, and predict the output of the program, explaining their reasoning for each variable's value.

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

Activity 02

• Problem-Based Learning
• 45 min · Small Groups

Code Refactor Relay: Scope Optimization

In small groups, pass code segments; each member converts globals to locals where possible, tests, and explains changes. Groups present optimized versions.

Analyze the potential risks of overusing global variables in complex programs.

Facilitation Tip

For Scope Optimization, set a strict time limit to push students toward efficient solutions rather than exhaustive refactoring.

What to look for

Present students with a scenario describing a program's functionality, for example, a simple calculator. Ask them to sketch out how they would use local and global variables to store input numbers, intermediate results, and the final answer, explaining the scope choice for each.

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

Activity 03

• Problem-Based Learning
• 50 min · Individual

Program Design Workshop: Balanced Scopes

Individuals sketch a program outline using both scopes, code it, then swap with a partner for peer review on integrity risks. Revise based on feedback.

Design a simple program demonstrating the appropriate use of both local and global variables.

Facilitation Tip

In Balanced Scopes, assign roles so designers, coders, and testers rotate tasks, ensuring everyone engages with scope decisions.

What to look for

Pose the question: 'When might using a global variable be a necessary evil in a program, and what specific steps can a programmer take to mitigate the risks associated with its use?' Facilitate a class discussion where students share their ideas and justify their choices.

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

Activity 04

• Problem-Based Learning
• 35 min · Whole Class

Live Coding Demo: Scope Simulation

Whole class follows a projected code; predict variable values at breakpoints, vote on access issues, then run to verify. Extend to student-led examples.

Explain how local and global variables affect the integrity and predictability of a program.

Facilitation Tip

In Scope Simulation, pause frequently to ask students to predict outputs before revealing results, building anticipation and verification habits.

What to look for

Provide students with a short Python code snippet containing both local and global variables. Ask them to identify which variables are global and which are local, and predict the output of the program, explaining their reasoning for each variable's value.

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

A few notes on teaching this unit

Teach scope by making students feel the pain of global side effects first, then showing locals as safety. Avoid starting with definitions; instead, let students experience bugs from uncontrolled globals before introducing structured alternatives. Research shows that students grasp scope best when they debug intentional errors caused by misunderstanding boundaries, so use misuses as teaching tools rather than warnings.

Successful learning shows when students can predict variable behavior without running code, justify scope choices in discussions, and choose between local and global variables based on program needs. They should explain why some designs are brittle and others are robust, using precise terminology like 'encapsulation' and 'side effects'.

---

Watch Out for These Misconceptions

• During Global Variable Hunt, watch for students who assume all variables are global until they hit 'undefined' errors when accessing locals outside functions.

  Use the hunt’s printed code snippets to have students circle each declaration and label its scope before running tests, forcing explicit scope checks.

• During Code Refactor Relay, watch for students who defend globals as 'simpler' for sharing data across functions.

  Have teams present their refactored code and explain how parameters or returns prevent bugs they saw in the original, using their own test cases as evidence.

• During Program Design Workshop, watch for students who declare all variables globally to 'make them available everywhere'.

  Ask groups to sketch interaction diagrams showing data flow, highlighting where globals would cause conflicts and forcing them to redesign with locals and parameters.

---

Methods used in this brief

• Problem-Based Learning