Yu Ru | Mastering the 9210 AQA Skeleton Program for 2025 – Complete Python Coding Guide

In preparation for the GCSE Computer Science 2025 exams, students must develop a strong grasp of the AQA Skeleton Program. This blog post offers a detailed journey through key programming skills needed for success, including:

Building 1D and 2D arrays from scratch
Implementing structured menu systems
Validating user input and handling errors
Developing forward movement, backward movement, undo features, and diagonal moves in game-based Python tasks
Mastering the use of loops, if-else conditions, global/local variables, and modular design practices
Refining code for efficiency and preparing answers that align with AQA exam marking schemes

With real examples, step-by-step exercises, and practical debugging techniques, this guide is ideal for any student aiming to tackle the 2025 AQA Computer Science exam with confidence.

Class 1 (17 Dec 2024) - 40 min. class duration

a) Class Summary:

Explored the differences between SSDs and HDDs, focusing on performance, durability, and storage capabilities.
Practical Python Exercise:
Worked on generating a secure 3-digit password using the randint function and a loop, combining programming logic with hands-on coding practice.

b) Video (Tuesday):

Part 1: Understanding SSD vs HDD & Python Password Generator Exercise

d) Files:

e) Class Code:

f) Exercises:

g) HomeWork Solutions Posting (FB) :

Class 2 (20 Dec 2024) - 90 min. class duration

a) Class Summary:

Understanding Variable Scopes and Return Statements:
- Discussed local and global variable scopes, demonstrating how the return statement allows data to be accessed outside a method.
- Introduced examples using functions like sum_array, max, and min to explain the importance of returning values.
Exploring Mutable vs. Immutable Objects:
- Clarified the difference between mutable objects (e.g., lists) and immutable objects (e.g., strings).
- Demonstrated how passing references allows list modifications but not string changes unless explicitly returned.
Shuffling Arrays and Efficient Code Practices:
- Explained and improved the array shuffling process, emphasizing iteration and random swapping.
- Highlighted ways to optimize repetitive code, ensuring clarity and efficiency.
Generating Team Scores in 2D Lists:
- Guided Yu through creating a generate_scores() method to populate a 2D list with random scores, reinforcing concepts of nested lists and loops.
- Demonstrated best practices for naming conventions and structuring clean, readable code.
Personal Advice for Yu:
- Practice solving Python exercises, focusing on variable scopes, list manipulation, and 2D arrays.
- Review and rewrite provided code snippets to build familiarity with Python syntax and functionality.
- Gradually progress from simple to complex problems to enhance confidence and understanding.
- Regularly use print statements for troubleshooting and debugging to identify issues in the code.
- Approach coding with patience and persistence, treating it like mathematics—improvement comes with consistent practice.

b) Video (Friday):

Part 1: Mastering Python Scopes, Mutable Objects, and Array Shuffling Techniques

d) Files:

GetValue, CreateValues, and ShuffleCards Code: Exploration and Improvement.

e) Class Code:

Card Deck Simulation: Value Creation and Shuffling in Python

f) Exercises:

Generate Team Scores in 2D Arrays and Perform 1D Array Operations (Sum, Average, Max)

g) HomeWork Solutions Posting (FB) :

Class 3 (22 Dec 2024) - 105 min. class duration

a) Class Summary:

Understanding 2D Array Structure and Loops
Ahmed explained the structure of a 2D array and guided Yu on how to use nested loops to iterate through rows and columns, with hands-on examples.
Storing User Input in a 2D Array
The class covered how to take user input for each element in a 2D array using nested loops and the append method, ensuring data was stored correctly.
Creating Flexible Arrays for Variable Teams and Players
Ahmed demonstrated how to modify the code to handle varying numbers of teams and players, creating a dynamic 2D array to store scores.
Debugging and Improving Code Functionality
Key debugging techniques were discussed, including fixing array recognition issues, handling indentation errors, and understanding the difference between rows and columns.
Personal Advice for Yu
- Revisit the class recording at 1.5x or 2x speed to consolidate understanding.
- Practice small coding exercises to build confidence with 2D arrays.
- Avoid over-relying on external help; focus on fully grasping the basics.

b) Video (Sunday):

Part 1: Mastering 2D Arrays in Python: Loops, User Input, and Debugging Techniques

d) Files:

e) Class Code:

f) Exercises:

Exam Question: Division Counter Code

g) HomeWork Solutions Posting (FB) :

Class 4 (26 Dec 2024) - 90 min. class duration

a) Class Summary:

Initializing and Manipulating 2D Arrays:
- Discussed two methods for initializing 2D arrays and filling them with information.
- Explained practical exercises, such as iterating through an array for specific calculations.
Building Menu-Based Programs:
- Created a selection menu for operations like sum, average, max, and min.
- Emphasized the importance of proper input validation and handling invalid choices.
Troubleshooting and Debugging:
- Addressed errors such as undefined variables, division by zero, and issues with the sum keyword.
- Highlighted the importance of a systematic approach to debugging.
Efficient Use of Variables and Global Scope:
- Discussed when to use global variables versus passing variables as inputs.
- Improved code by reducing redundancy and ensuring efficient variable usage.
Personal Advice for Better Coding:
- Practice consistent troubleshooting to gain confidence and speed in debugging.
- Focus on understanding core concepts, such as loops, input validation, and variable scope, as they form the foundation of effective programming.

b) Video (Thrusday):

Part 1: Building Efficient Code: Loop Techniques, Input Validation, and Menu-Based Programming

d) Files:

Array Operations Menu Exercise

e) Class Code:

f) Exercises:

g) HomeWork Solutions Posting (FB) :

Class 5 (8 Feb 2025) - 90 min. class duration

a) Class Summary:

User Input & Range Validation – Yu practiced validating user input to ensure it meets specific conditions, such as checking if a score falls within a valid range (0-100).
Loops & Condition Control – Ahmed explained how to replace an infinite while True loop with a condition-based loop to improve efficiency and readability.
Subroutines vs. Functions – They discussed the differences between subroutines (procedures) and functions, focusing on how functions return values while subroutines execute actions.
Counting Elements in Strings – Ahmed demonstrated modifying an algorithm to count specific characters in a string, such as counting the occurrences of 'E'.
Debugging & Code Improvement – Yu encountered errors while implementing concepts, but with Ahmed’s guidance, she corrected them and gained confidence in writing structured Python code.

b) Video (Saturday):

Part 1: Python Programming: Input Validation, Loops & Functions

d) Files:

YU Ru AQA GCSE Python Basics Slides

e) Class Code:

f) Exercises:

Age Input Validation Exercise

g) HomeWork Solutions Posting (FB) :

Class 6 (19 Feb 2025) - 90 min. class duration

a) Class Summary:

Error Handling & Function Definitions: Ahmed guided Yu in handling Python errors using try and except, emphasizing their correct usage and simplifying redundant code to improve clarity.
Passing Variables & Data Manipulation: They discussed how variables in different function areas are stored separately and need to be explicitly passed or returned for proper data flow in a program.
Testing Subroutines & Functions: Yu practiced defining and testing functions, including a multiplication function, while learning the difference between subroutines (no return) and functions (with return).
Implementing a User-Friendly Menu System: Ahmed introduced the get_input function to validate user choices, guiding Yu in structuring a menu system that ensures correct input handling.
Validating User Input & Next Steps: They worked on refining a validate_choice function to accept values between 1 and 4, with Yu assigned homework to integrate and test this function within the menu system.

b) Video (Wednesday):

Part 1: Functions, Error Handling & Menu System Implementation in Python

d) Files:

Introducing Method Definitions and Method Calling

e) Class Code:

f) Exercises:

g) HomeWork Solutions Posting (FB) :

Class 7 (22 Feb 2025) - 90 min. class duration

a) Class Summary:

Even and Odd Number Validation:
- Ahmed explained how to determine even and odd numbers using the modulus operator.
- Yu practiced modifying numbers in a print statement to observe results.
Function Scope and Input Handling:
- Ahmed clarified how variables within a function remain local unless explicitly passed as arguments.
- They discussed how to correctly pass inputs between functions to avoid scope issues.
Helper Functions for Code Reusability:
- Yu learned how to use helper functions to validate inputs instead of rewriting code repeatedly.
- Ahmed guided Yu in modifying the validate_choice function to improve efficiency.
String Manipulation and Indexing:
- Ahmed introduced string indexing, including negative indexing to access characters from the end.
- Yu successfully completed an exercise extracting specific letters from a string.
Using random.choice() for Dynamic Functionality:
- Ahmed introduced random.choice() to generate random selections, such as ASCII characters.
- They discussed function adaptability for different input ranges, like menus or booking systems.

b) Video (Saturday):

Part 1: Understanding Functions, Scope, and String Manipulation in Python

d) Files:

e) Class Code:

f) Exercises:

Scope and functions exercises

g) HomeWork Solutions Posting (FB) :

Class 8 (08 Mar 2025) - 94 min. class duration

a) Class Summary:

Debugging and Input Handling: Addressed issues with Python code execution, including undefined variables and improper input validation.
Understanding 2D Arrays: Explained 2D arrays, their structure, and how to loop through them using nested loops.
Game Board Creation: Discussed building a game board using a 2D array, incorporating obstacles and player movement logic.
Code Refinement & Visualization: Worked on refining code for better readability, using print statements and global variables for visualization.
Checkerboard & Conditionals: Demonstrated the use of if statements to differentiate between border and inner spaces while printing a checkerboard-style output.

b) Video (Saturday):

Part 1: Mastering 2D Arrays and Debugging in Python: Input Handling & Game Board Design

d) Files:

e) Class Code:

f) Exercises:

g) HomeWork Solutions Posting (FB) :

Class 9 (15 Mar 2025) - 93 min. class duration

a) Class Summary:

2D Arrays & Logic Gates: Euro was guided on how to work with 2D arrays to store student data and find maximum marks, utilizing functions like index() to track specific student scores.
Modulus for Direction Control: Ahmed explained how the modulus operator is used to control movement direction in a program, particularly in the context of navigating a game board.
Creating Random Obstacles: They worked on implementing a random obstacle generator within the game board, using percentages to control the frequency of obstacles appearing.
Error Handling & Debugging: Ahmed helped Euro troubleshoot errors, particularly with using functions like sum() and index() correctly, while also explaining the importance of consistent practice in coding.
Skeleton Program Enhancement: They reviewed the skeleton program, discussing improvements like adding special moves for the player (e.g., diagonal movement), which could appear in future exams.

b) Video (Saturday):

Part 1: Python Programming: 2D Arrays, Logic Gates & Improving Skeleton Programs

d) Files:

e) Class Code:

f) Exercises:

Add Undo Command to the Skeleton Program (Exercise)

g) HomeWork Solutions Posting (FB) :

Class 10 (22 Mar 2025) - 93 min. class duration

a) Class Summary:

Troubleshooting the Undo Feature: Ahmed and Yu identified errors with the undo functionality in the code, including an extra "equal one" causing issues and proposed corrections to ensure it works properly.
Improving Code with Tuples & Functionality: They discussed using tuples to store positions efficiently and reviewed the logic behind the "Fd move" and how to better capture the last position.
Loop Functionality & Movement Logic: Ahmed explained the loop’s role in moving the arrow step-by-step and discussed the process of implementing multiple steps using a loop for forward movement.
Game Score Tracking & Leaderboard: They explored adding a feature to track the total number of moves in the game and implemented a minimum score algorithm to track the best scores, resetting after each session.
Diagonal Movement Implementation: Ahmed suggested that Yu implement diagonal movement as a feature, starting with the simpler "down-right" direction, and provided guidance on how to proceed with the coding task.

b) Video (Saturday):

Part 1: Improving Code Functionality: Undo Feature, Movement Logic & Game Score Tracking

d) Files:

Skeleton Program Improvement Exercises & Answers

e) Class Code:

f) Exercises:

Add Extra Command FD Max to the Skeleton Program (Exercise)

g) HomeWork Solutions Posting (FB) :

Class 11 ( 29 Mar 2025) - 95 min. class duration

a) Class Summary:

Implementing FD MAX (Forward Until Obstacle):
Yu learned how to replace a for loop with a while loop to handle continuous forward movement until hitting an obstacle, using refined parameter handling and conditionals.
Input Splitting & Command Processing:
Ahmed explained how the input string splits into arrays, how command parsing works, and why MAX needs to be properly indexed and interpreted within the function.
Code Debugging & Logic Optimization:
The class addressed common Python logic bugs like loop redundancy, capitalization inconsistencies, incorrect parameter values, and misaligned indents. Print statements were used to test and track values.
Diagonal Movement Functionality (Down-Right):
Ahmed introduced the concept of diagonal movement in a grid system, emphasizing edits to multiple functions (check_forward, move_forward, special_move) and the addition of a DOWN_RIGHT constant.

b) Video (Saturday):

Part 1: Advanced Python Movement Logic: Forward-Until-Obstacle & Diagonal Movement Coding Session

d) Files:

Skeleton Program – Short Answer for FD Max Command

e) Class Code:

f) Exercises:

Implementing Diagonal Move Down-Right (Exercise)

g) HomeWork Solutions Posting (FB) :

Class 13 ( 4 April 2025) - 95 min. class duration

a) Class Summary:

This class focused on refining control flow and enhancing the movement system in Yu's Python-based game project. We addressed several logic errors, implemented new functionality, and emphasized good coding practices such as consistency, modular design, and debugging techniques.

✅ Exercises/Tasks Covered
Debugging existing movement logic
Implementing move_backward functionality:
- Direction-based row/column logic
- Obstacle checking reuse
Building the diagonal_movement function:
- Renaming from "downright" for clarity
- Incorporating obstacle checks
Implementing the jump command:
- Handling obstacle skipping
- Adding error messages for invalid jumps
Fixing bug in process_input():
- Handling empty input
- Using len() and print checks for validation
Code cleanup & indentation best practices
Using print statements for flow tracking and debugging

b) Video (Saturday):

Part 1: Code Debugging & Movement Functions – IGCSE Python Class (Backward, Jump, Diagonal)

d) Files:

AQA_GCSE_Jump_Diagonal_Move_Exercise_Answers

e) Class Code:

f) Exercises:

AQA GCSE – Implementing the Backward Command (Exercise)

g) HomeWork Solutions Posting (FB) :

Class 14 ( 12 April 2025) - 95 min. class duration

a) Class Summary:

Enhanced Robot Navigation Features
Explored implementing diagonal and backward movement in a robot navigation project, including handling 45-degree directional logic.
Backward Movement Function Creation
Developed and tested a custom "move backward" function by reversing the existing "move forward" logic while preserving direction.
Circular List Concept Using Modulus
Introduced circular indexing with modulus to allow seamless directional rotation without index out-of-range errors.
Code Troubleshooting and Debugging Practice
Identified execution issues with the 'pk' command, walking through the code step-by-step to isolate bugs and inconsistencies.
Applied Use of Modulus in Programming
Explained modulus applications (e.g., modulus 2, 4, 10) and implemented it to control array bounds and simulate circular behavior in arrays

b) Video (Saturday):

Part 1: Modulus & Circular Arrays in Programming: Enhancing Robot Navigation Logic

d) Files:

Back Command & Circular Queue Exercises with Answers

e) Class Code:

f) Exercises:

Skeleton – 45° Rotation Feature Exercise

g) HomeWork Solutions Posting (FB) :

Class 15 ( 19 April 2025) - 110 min. class duration

a) Class Summary:

AQA Skeleton Program Prep:
Focused on exam-relevant Python tasks from the AQA Skeleton Program, including circular rotation using modulus and 45° direction changes.
Enhanced Direction Logic:
Expanded the direction array to eight possible angles to accommodate diagonal movements—critical for more accurate game logic.
Turn Function Debugging:
Identified logic errors in the turn_right functionality; used print statements and conditional checks to trace and resolve issues.
Diagonal Movement Task:
Ahmed assigned a new exercise to calculate maximum “downright” steps on the board, helping Yu build logic for movement-based questions.
Score File Writing in Python:
Reviewed how to write scores (including name, date, and number of commands) to a text file using basic file I/O syntax—crucial for the practical exam.

b) Video (Saturday):

Part 1: GCSE Python Tutoring: AQA Skeleton Program – Rotation, Diagonal Movement & File Handling Explained

d) Files:

Turn 45° & Diagonal Movement – Ideal Answer with Circular Logic Using Modulus

e) Class Code:

f) Exercises:

Exercise – Count Safe Diagonal Steps on the Grid

g) HomeWork Solutions Posting (FB) :

Class 16 ( 26 April 2025) - 101 min. class duration

a) Class Summary:

Skeleton Program Homework Review
Reviewed Yu’s code for a robot movement task, checked function execution issues, and suggested improvements for integrating function calls properly.
Debugging Function Execution & Input Errors
Identified problems with input handling (extra spaces, strip function issues) and guided Yu to clean and properly compare user commands in the code.
Fixing Variable Naming & Code Corrections
Fixed mismatched variable names (direction corrected to Drc) and corrected issues with "turn left" and "turn right" functions.
Implementing Diagonal Movement with Steps
Modified the diagonal movement function to accept a specific number of steps, similar to the forward movement command.
Developing Debugging & Persistence Skills
Encouraged Yu to be patient, practice independently, use print statements for tracking code behavior, and develop deeper problem-solving abilities.

b) Video (Saturday):

Part 1: Skeleton Program Debugging & Diagonal Movement Coding

d) Files:

AQA GCSE Safe Diagonal Movement Exercise Answer

e) Class Code:

f) Exercises:

Implementing the AUTO Command

g) HomeWork Solutions Posting (FB) :

Class 17 ( 3 May 2025) - 119 min. class duration

a) Class Summary:

Command Optimization Techniques: Ahmed demonstrated how to handle multiple commands more efficiently by splitting and organizing them into arrays for better code readability and performance.
Debugging and Error Handling: They worked through common coding errors, including undefined commands and string split issues, with Ahmed offering step-by-step guidance to resolve them.
String Manipulation Essentials: Ahmed introduced key Python string slicing methods, teaching Yu how to extract parts of strings safely using colon notation and the len() function.
Auto Command Logic Improvements: The session focused on refining how the program processes the "auto" command, suggesting separation into individual commands to avoid execution problems.
Code Backup and Replit Usage Tips: Ahmed advised Yu to download code regularly from Replit to prevent data loss due to free account limitations, emphasizing safe storage practices before exams.

b) Video (Saturday):

Part 1: Code Debugging & Command Optimization in Python

d) Files:

Implmenting AUTO Command answer

e) Class Code:

f) Exercises:

Dash Seprated robot commands exercise

g) HomeWork Solutions Posting (FB) :

Class 18 ( 10 May 2025) - 90 min. class duration

a) Class Summary:

IGCSE AQA Skeleton Program Training: Students practiced applying the Skeleton Program for the IGCSE AQA Computer Science curriculum, focusing on structured coding techniques.
Debugging and Variable Use: Yu and Ahmed resolved syntax and logic errors, emphasizing correct use of variables and functions essential for exam success.
Obstacle Handling Logic: The session covered how to design and refine the handleObstacle function, a key component in navigation logic.
Auto Mode Coding Strategy: They planned and discussed implementing an "auto mode" to repeatedly call movement functions until a clear path is found—teaching efficient loop and condition structures.
Code Testing and Direction Control: Yu was guided to test code changes and improve direction logic, reinforcing concepts like function calls, decision-making, and real-time debugging.

b) Video (Saturday):

Part 1: IGCSE AQA Skeleton Program Training: Debugging, Auto Mode, and Obstacle Handling

d) Files:

Where and How to Add New Features Guide

e) Class Code:

f) Exercises:

AutoNavigate to Goal (Steps 1–5)

g) HomeWork Solutions Posting (FB) :

Class 19 ( 17 May 2025) - 71 min. class duration

a) Class Summary:

Looping & Stuck Code Troubleshooting
Yu and Ahmed identified flaws in a loop that prevented proper termination and discussed how to isolate the cause using error messages and directional logic.
Maximum Attempt Logic Implementation
A 4-attempt limit was introduced to handle repeated obstacle encounters, along with best practices on where to place and reset counters.
Global Variable Access Fixes
Yu learned to correctly declare and access global variables within functions, helping resolve undefined variable errors during execution.
Enhancements to Movement Strategy
The session introduced forward movement attempts after diagonal failures, with forced direction handling to avoid robot backtracking.
Exam Practice Guidance & Next Steps
Ahmed emphasized the need for Yu to practice independently using provided templates and revisit earlier exercises, including implementing a command counter inside autoNavigateToGoal.

b) Video (Saturday):

Part 1: Obstacle Navigation & Debugging Strategies – GCSE Prep Session

d) Files:

e) Class Code:

f) Exercises:

Fewer Obstacle Rows – Practice Exercise

g) HomeWork Solutions Posting (FB) :

Class 20 ( 22 May 2025) - 82 min. class duration

a) Class Summary:

Input Validation & Commenting for Exams
Yu learned how to use and adapt input validation templates with meaningful code comments to clarify logic and support exam marking—even when full functionality isn’t reached.
Building & Printing Difficulty Lists
Ahmed helped Yu fix logic issues in difficulty list generation by ensuring the board is non-empty, printing the list on menu option 4, and calculating difficulty per row and column.
Game Board Scoring System
A scoring method was introduced that assigns obstacle weights to aid navigation logic. Yu suggested subtracting wall values for clarity, and Ahmed confirmed plans to expand this into auto-navigation.
Function Return Values & List Handling
Yu practiced storing return values from functions, especially lists, and modifying them post-return. Ahmed emphasized using variables to track and reuse these lists efficiently.
Bug Fixing, Code Review, and Menu Structuring
Together, they identified and corrected issues in menu input, command placement, and board initialization. Ahmed explained how to use provided templates instead of reinventing code from scratch.

b) Video (Thrusday):

Part 1: Game Board Difficulty & Exam Coding Techniques – Input Validation, Scoring, and Strategy
Grid Difficulty Scores

d) Files:

Exercise & Answer (Row & Column Difficulty Scores)

e) Class Code:

f) Exercises:

Hi, I’m Ahmed Elmalla, founder of Learn with Kemo, a trusted Computer Science tutoring service. With 19+ years of experience and certifications from top universities, I specialize in tutoring students in Java programming, AP CS A, and IGCSE Computer Science.

Whether you’re looking for exam prep, coding projects, or personalized tutoring, I’m here to help you succeed. Book your free 30-minute trial session today!