Secondary 3 G3 Computing vocabulary helps students explain what a program does, choose useful tests and repair errors with evidence. This guide teaches 100 words and phrases for program tracing, testing and debugging. Start by separating three questions: what should happen, what actually happens, and which instruction explains the difference. A student who can answer those questions has a practical way to improve a program.
Learn a small group of terms, trace a short example on paper, then check it in Python. Parents can help by asking for the predicted result and the reason behind a correction. This is an eduKate teaching selection, not an official SEAB list of 100 required words. Use it alongside the school’s current work and the 2027 G3 Computing K349 syllabus.
- For students: connect every term to a value, instruction, test or correction you can explain.
- For parents: look for independent reasoning, rather than judging progress only by whether a screen shows the expected answer.
- Core practice: trace variables, compare expected and actual results, test boundaries and explain repairs.
- Included: 100 terms, runnable Python examples, trace and test tables, diagnostic answers and a four-week plan.
- Course boundary: this is one programming theme; it does not cover the whole Computing subject or prescribe a school’s Secondary 3 sequence.
The 2027 K349 document includes manual dry runs, trace tables, diagnostic print statements, validation, error analysis and incremental testing within Algorithms and Programming. Computing also includes other modules, so proficiency with these exercises is one part of preparation. Your teacher’s current topics and assessment instructions determine what to practise first.
The Singapore–Cambridge Secondary Education Certificate begins in 2027. Check the examination year, subject level and subject code before applying a syllabus. A student’s school examination is not automatically identical to the later national examination. This article uses the published 2027 document as its reference without claiming that a later year’s requirements are already confirmed.
Some K349 algorithm tasks require students to work without particular shortcuts, including min(), max(), sum(), index(), find() or split(). Read the condition attached to the task. The worked accumulation and maximum examples below use explicit loops so that their reasoning remains visible.
All scenarios, datasets and code in this guide are original teaching examples. They use ordinary Python 3 features, with each input assumption stated. Named Python exceptions and terms such as short-circuit evaluation, regression testing and refactoring provide useful extra language; their inclusion is not a claim that SEAB separately requires every label. Follow the school’s software arrangements and Python conventions.
Before opening an editor, consider points = 4 followed by points = points + 3. What value does points have afterwards? Explain the right-hand side first: it uses the old value, calculates seven, then assigns the result to the name. The final value is 7. Reading the assignment as a permanent algebraic equality would produce confusion.
Next, imagine a program accepts scores from zero to one hundred inclusive. Would testing only fifty establish that both endpoints work? It would not. Zero and one hundred need attention because a mistaken strict comparison can reject them. Finally, ask whether a program that runs without an error message must be correct. It may still calculate the wrong answer.
These answers help locate the learning need. Confusion about assignment calls for tracing values. Missing endpoint tests calls for test design. Treating successful execution as proof calls for comparison with the requirement. Choose practice that addresses the actual difficulty.
CHAPTER 3 OF 20 · Learn the 100 terms
3. Words 1–10: Define the task before touching the code
- Algorithm. A precise sequence of steps for solving a problem. To find a total, start at zero and add each value. Explain the steps before deciding how Python will express them.
- Program. Instructions written in a programming language for a computer to execute. A program may implement a sensible algorithm incorrectly, so compare the intended steps with the actual code.
- Specification. A description of the required behaviour and relevant conditions. “Accept integer scores from 0 to 100 inclusive” provides a clearer testing target than “check that the score is sensible”.
- Requirement. Something the solution must satisfy. If a task requires an error message for an empty list, silently producing zero does not meet that requirement, even if the program runs.
- Input. Data supplied to a program or function. A list of four readings is input to a calculation. State the permitted data types and values before selecting tests.
- Output. A result produced by a program. It may be displayed, returned or written to a file. Compare the output with the requested result, including its meaning and required format.
- Processing. Operations that transform input into a result. Comparing each score with a threshold and increasing a count are processing steps; reading the scores alone does not perform the calculation.
- Decomposition. Breaking a problem into manageable parts. Separate accepting a score, calculating a result and displaying it. This helps you identify which part needs testing when something goes wrong.
- Abstraction. Keeping relevant details while setting aside unnecessary ones. A counting task may need attendance values but not students’ favourite colours. Decide relevance from the problem, rather than discarding awkward information.
- Precondition. A condition assumed to hold before an operation begins. A simple maximum-finding routine may assume a non-empty numeric list. Check that assumption before accessing its first item.
Use the set: rewrite a vague instruction as a testable requirement. Include the input, the required result and one condition that might otherwise be misunderstood.
- Variable. A name associated with a value that may change during execution. In a trace, record the current value of
countafter each relevant instruction, rather than relying on memory. - Assignment. Giving a name a value, or replacing its previous association. In
total = total + 5, calculate the right-hand side using the old total before recording the new one. - Initialisation. Giving something its starting value before use. A count usually starts at zero. Placing that initialisation inside the counting loop repeatedly erases progress and changes the result.
- Constant. A value intended to remain unchanged. A named threshold such as
PASS_MARK = 50communicates that intention; capital letters do not themselves prevent Python from assigning a different value later. - Integer. A whole-number value, which may be positive, negative or zero. The number of completed items is usually an integer; distinguish numeric
12from the text"12". - Floating-point value. A numeric representation used for quantities such as
2.5. Some decimal values are approximated internally, so exact equality can be unsuitable when comparing results of decimal calculations. - String. A sequence of text characters. In Python,
"6" + "2"produces"62". The digits remain text until an appropriate conversion is performed for a numerical calculation. - Boolean. A value representing truth or falsity:
TrueorFalse. The comparisonscore >= 50produces a Boolean result that can control a branch. - Conversion. Changing a value into another representation or type when supported.
int("17")produces an integer. Check that the text is suitable; conversion does not make arbitrary words numerical. - Expression. A combination of values, names and operations that produces a value.
quantity * priceis an expression. Evaluate it using the current values at that point in execution.
Use the set: explain why text entered through input() needs appropriate handling before arithmetic. The Python built-in function reference documents input, conversion and length operations.
- Arithmetic operator. A symbol that performs a numerical operation, such as
+or*. Check the intended calculation: multiplying a count by a price answers a different question from adding them. - Comparison operator. An operator that compares values, such as
<,>=or==. Replacing “at least” with a strict greater-than comparison incorrectly excludes the stated threshold. - Logical operator. An operation such as
and,orornotused to combine or reverse conditions. Requiring both conditions calls for different logic from accepting either condition. - Boolean expression. An expression whose result is true or false.
0 <= score <= 100checks both inclusive limits. State the permitted type ofscoreas well. - Precedence. The rules determining how operators bind within an expression.
2 + 3 * 4gives fourteen. Use parentheses when they clarify the intended grouping, and explain the calculation. - Selection. Choosing which instructions to execute according to a condition. An
ifstatement can select an acceptance message for valid data and a rejection message for invalid data. - Branch. One possible route through a selection structure. A program can work on the accepted-input branch while failing on the rejected-input branch, so test the routes relevant to the requirement.
- Nested selection. A selection structure placed inside another. A second check may occur only after an earlier condition succeeds. Trace that order instead of treating every condition as automatically executed.
- Short-circuit evaluation. Evaluating a later logical operand only when needed. In Python,
count != 0 and total / count > 10avoids division when the first condition is false. - Indentation. Leading spacing that identifies Python code blocks. Moving an update outside a loop changes when it executes. Inspect indentation as part of the program’s logic, rather than as decoration.
Use the set: compare score > 50 with score >= 50 at exactly fifty. The Python expression reference explains comparisons, logical evaluation and precedence.
CHAPTER 6 OF 20 · Learn the 100 terms
6. Words 31–40: Follow repetition without losing count
- Iteration. Repeating instructions as part of an algorithm. When adding four readings, one iteration can process one reading. Keep the number of repetitions separate from the values being processed.
- For loop. A Python loop that visits items from an iterable.
for score in scores:givesscoreeach successive item. It does not automatically give the item’s index. - While loop. A loop that repeats while its condition is true. The condition is checked before each repetition, so the body may execute zero times if the initial condition is false.
- Range. A Python sequence of integers following a specified start, stop and step.
range(1, 4)produces one, two and three; the stop value is excluded. - Loop variable. A variable used to track a loop’s current item or position. Name its role clearly:
readingsuggests a value, whilepositionsuggests an index. - Counter. A value used to count occurrences. Increase
countby one whenever an item qualifies. Adding the item’s value instead would turn the calculation into a different operation. - Accumulator. A value that combines contributions over successive steps, often as a running total. Add each qualifying score to
totaland retain the result for the next iteration. - Termination condition. A condition that determines when repetition ends. In a position-based loop, reaching the list’s length can signal completion. Check that updates actually allow that stopping point to be reached.
- Sentinel. A special value used to signal an instruction such as “stop entering data”. Choose it outside the ordinary permitted data values, and explain whether it is excluded from the calculation.
- Off-by-one error. A mistake in a count or boundary by one step. Using
<= len(items)for ordinary forward indexing attempts one position beyond the last valid non-negative index.
Use the set: predict how many times range(3) repeats before running it. The Python control-flow tutorial explains loops, ranges and functions.
CHAPTER 7 OF 20 · Learn the 100 terms
7. Words 41–50: Handle collections and functions
- List. An ordered, changeable collection of items in Python.
[14, 20, 9]contains three items. An empty list has no first item, even though the list itself exists. - Index. A position used to access an item in a sequence. In
scores[2], two is the index; it does not mean “find the score whose value is two”. - Zero-based indexing. Numbering forward positions from zero. A three-item Python list has non-negative indices zero, one and two. The last such index is one less than the length.
- Length. The number of items in a collection or characters in a string.
len([8, 6])is two. Length describes how many items exist, rather than the largest forward index. - Slice. A selected portion of a sequence.
items[1:3]takes positions one and two. Its stop position is excluded; distinguish slicing a portion from indexing one item. - Function. A named, callable unit of code that performs a task. Separating score validation into a function lets you test that decision with several inputs without repeating the whole application.
- Parameter. A name in a function definition that receives a supplied value. In
def acceptable_score(text):,textis the parameter representing the input being examined. - Argument. A value supplied when calling a function. In
acceptable_score("50"), the string"50"is the argument. Distinguish the supplied value from the parameter’s name. - Return value. A result passed back to the caller by a function. Returning
Trueallows other code to use the decision; printing a message serves a different purpose. - Scope. The region in which a name can be accessed. A value created as a local variable inside a function is not automatically available by that name everywhere in the program.
Use the set: distinguish items[2], len(items) and items[1:3]. Python also supports negative indices: for a non-empty list, items[-1] selects the last item. See the sequence-operation reference.
CHAPTER 8 OF 20 · Learn the 100 terms
8. Words 51–60: Make the program’s behaviour visible
- Dry run. Manually following instructions without executing the program on a computer. Use the actual starting values and conditions. Guessing the intended result does not reproduce what the code does.
- Trace table. A record of relevant values as execution progresses. Give columns meaningful headings and state when a row is recorded, such as after each loop body finishes.
- State. The relevant values and conditions at a particular point in execution. Two programs showing the same message may have different internal states, which can affect what happens next.
- Execution order. The sequence in which instructions are carried out. Assigning a value before using it can produce different behaviour from assigning it afterwards. Follow branches and loops carefully.
- Iteration number. A label identifying which repetition you are tracing. The first iteration may process index zero. Keep a human counting label separate from a Python sequence index.
- Initial state. The relevant values before the part being traced begins. Record
count = 0andtotal = 0before the first item, so later changes have a clear starting point. - Final state. The relevant values when the traced part finishes. Explain which of these values become output. A variable can change internally without being displayed to the user.
- Hand calculation. An independent calculation used to establish an expected result. Add the qualifying values yourself before running the program, so an incorrect output is not mistakenly accepted as the answer.
- Diagnostic output. Temporary information printed to help investigate behaviour. Display the position and running total at a useful point. Label them clearly so the output reveals which step first differs.
- Backtracking. Working backwards from an unexpected result to the instructions that produced it. If a total becomes zero unexpectedly, inspect the assignments affecting it before changing unrelated parts.
Use the set: identify the first row where actual and expected states differ. That row usually provides a more useful starting point than rewriting the whole program.
CHAPTER 9 OF 20 · Learn the 100 terms
9. Words 61–70: Design tests that can reveal mistakes
- Test case. A particular test with specified conditions, input and expected behaviour. “Try fifty and expect acceptance” is a test case; “check the program” leaves the test undefined.
- Test data. Values selected for testing. Choose data to examine a requirement or possible mistake. A long list of similar ordinary values can miss a short but revealing boundary case.
- Expected result. What should happen according to the specification. Establish it before inspecting the program’s output. Otherwise, a plausible wrong answer may influence your judgment of what was required.
- Actual result. What the program really produces during a test. Record it accurately, including an error or missing output. Do not replace it with what the program was meant to produce.
- Normal data. Ordinary valid input representing expected use. Fifty is normal data for an integer-score range from zero to one hundred, but it does not test either endpoint.
- Boundary data. Values at or immediately around a limit. Testing ninety-nine, one hundred and one hundred and one helps examine an upper bound of one hundred inclusive.
- Erroneous data. Input that fails the stated acceptance rules. A word entered where an integer score is required is erroneous data. The program’s expected response should be specified.
- Empty input. Input containing no items or characters, such as
[]or"". Empty input is valid for some tasks and invalid for others; decide from the requirement. - Test coverage. The extent to which tests examine relevant requirements, cases or routes. Testing both selection branches improves coverage, but does not automatically establish correctness for every possible input.
- Regression testing. Repeating relevant earlier tests after a change to check for newly introduced problems. A repair for the upper boundary should be followed by checks that ordinary valid values still work.
Use the set: write the reason for each chosen test. A boundary value can also be erroneous; test categories need not always be mutually exclusive.
CHAPTER 10 OF 20 · Learn the 100 terms
10. Words 71–80: Decide whether input is acceptable
- Validation. Checking whether data satisfies specified acceptance rules. A score within range can pass validation even if somebody typed the wrong real score. Plausibility does not prove factual accuracy.
- Presence check. Checking that required data has been supplied. An empty name may fail. Decide separately whether a string containing only spaces counts as missing in the particular task.
- Length check. Checking the number of characters or items against a requirement. A code requiring exactly four characters rejects three or five, but length alone does not verify the characters.
- Range check. Checking that a value falls within stated limits. A permitted score range of zero to one hundred includes both endpoints when the specification says they are inclusive.
- Format check. Checking that data follows a required pattern. A classroom code might require one uppercase letter followed by two digits. Define the pattern before deciding whether a sample matches.
- Existence check. Checking whether a value already occurs in the relevant stored data. A supplied class code may need to appear in a list of valid codes; its presence does not establish someone’s identity.
- Check digit. An extra digit calculated from other digits using a stated rule to help detect certain entry errors. A matching check digit does not guarantee that every original digit is correct.
- Acceptance criterion. A condition that must be met for input or a result to be accepted. State whether all criteria must hold together, such as the required format and permitted range.
- Rejection. Refusing input that does not meet the rules. A useful rejection response explains what the user can correct. Rejection should follow the specification, rather than an arbitrary assumption.
- Re-prompting. Asking for input again after an unsuccessful attempt. In an interactive task, this can let the user correct an entry. Explain how the program proceeds when valid input arrives.
Use the set: give a separate reason for a missing value, an overlong code and an out-of-range score. Each may require a different check even when all are rejected.
CHAPTER 11 OF 20 · Learn the 100 terms
11. Words 81–90: Name the error and explain its cause
The Python error tutorial distinguishes syntax problems from exceptions during execution. The following exception names help interpret messages; they are supporting Python terminology, not a separate official vocabulary checklist. See the exception reference for their formal descriptions.
- Syntax error. A violation of the language’s grammatical rules. A missing colon after an
ifheader can prevent parsing. Check the indicated location and the surrounding code. - Logic error. A mistake in the algorithm or its implementation that produces unintended behaviour. Counting scores strictly above fifty is wrong when the task requires fifty and above.
- Runtime error. An error encountered while code executes. Accessing a missing list position can cause one. A program may begin successfully before a later instruction reaches the problematic case.
- Exception. A condition reported through Python’s exception mechanism. Read its type and context to investigate. An exception message identifies a problem encountered, but does not always explain the underlying design mistake.
- NameError. Python’s exception for a name that cannot be found in the relevant lookup. A misspelt variable can cause it. Compare the spelling with the earlier assignment.
- TypeError. An exception associated with an inappropriate type for an operation. Combining a string and integer using
+causes one; decide whether conversion or a different operation fits the task. - ValueError. An exception for a value unsuitable for an operation that otherwise accepts that type.
int("hello")raises it because that string cannot represent the requested integer. - IndexError. An exception caused by a sequence index outside the valid range. With three list items, forward index three is outside the list. Inspect the loop boundary before blaming the data.
- ZeroDivisionError. An exception produced by division or a related operation with a zero divisor. Averages need attention when the count is zero; define the required response to that case.
- Infinite loop. Repetition that does not terminate under the conditions encountered. A counter that never changes can leave a condition permanently true. Use the environment’s stop control before investigating.
Use the set: distinguish the observed error from its cause. An incorrect loop limit is a logic mistake that may eventually trigger an IndexError; those descriptions address different aspects.
- Debugging. Systematically locating, explaining and correcting defects. Begin with a reproducible mismatch. Changing several unrelated lines at once makes it harder to know which change solved the problem.
- Isolation. Separating the relevant part of a program for investigation. Test the validation function independently when the acceptance decision is wrong, while supplying the inputs that function actually needs.
- Reproducibility. Being able to produce the same observed behaviour under the same relevant conditions. Keep the failing input and starting state, so another learner can follow the investigation.
- Minimal failing example. A reduced example that still shows the problem. If a maximum routine fails on one negative number, that small case can reveal an incorrect zero initialisation clearly.
- Hypothesis. A proposed explanation that can be checked. “The total is reset inside the loop” predicts a particular trace. Compare that prediction with the actual assignments and values.
- Correction. A change intended to remove an identified defect. Explain why moving an initialisation changes the repeated behaviour, then test whether the repair meets the requirement.
- Incremental development. Building and testing a solution in small additions. First handle one value correctly, then a list, then specified edge cases. Keep checking earlier behaviour as the program grows.
- Modularity. Organising a solution into parts with clear responsibilities and connections. A validation function should have a clear input and result, so its caller knows what to expect.
- Refactoring. Restructuring code while intending to preserve its externally observable behaviour. Clearer names may help reading, but they do not repair an incorrect condition by themselves. Recheck behaviour after restructuring.
- Documentation. Explanations that help someone understand requirements, choices, use or maintenance. Record why a boundary is inclusive or why empty input is rejected; avoid comments that simply repeat every instruction.
Use the set: write a repair record containing the failing input, expected result, actual result, cause, correction and follow-up tests. This turns an isolated fix into reusable understanding.
CHAPTER 13 OF 20 · Practise and check
13. Worked task 1: Trace a count and a running total
The requirement is to count the scores that are at least fifty and add those qualifying scores. The input is a list of integers. Predict the output before running this complete example.
scores = [42, 65, 50, 81]
count = 0
total = 0
for score in scores:
if score >= 50:
count = count + 1
total = total + score
print(count, total)
| Stage | Current score | Score at least 50? | Count | Total |
|---|---|---|---|---|
| Before loop | Not yet assigned | Not yet checked | 0 | 0 |
| Iteration 1 | 42 | False | 0 | 0 |
| Iteration 2 | 65 | True | 1 | 65 |
| Iteration 3 | 50 | True | 2 | 115 |
| Iteration 4 | 81 | True | 3 | 196 |
Answer: the program prints 3 196. The counter increases by one for each qualifying score; the accumulator increases by the score itself. Fifty qualifies because the comparison is inclusive. The initialisations occur before repetition, allowing the values to carry forward.
Now change the input to [50], then [49]. The expected outputs are 1 50 and 0 0. These short tests distinguish the threshold case from the value immediately below it. An empty list produces 0 0 under this counting-and-total requirement. If another task asks for an average, separately decide what zero qualifying scores should mean before dividing.
Repair challenge: imagine both initialisation lines were at the start of each loop body, before the condition. Earlier qualifying scores would be forgotten, and the original four-score example would finish with 1 81. Explain the repeated reset before proposing to move the lines.
CHAPTER 14 OF 20 · Practise and check
14. Worked task 2: Turn a specification into a test table
This classroom form accepts a score written as one to three ASCII digits, with a numerical value from zero to one hundred inclusive. Leading zeros are permitted within the length limit. Spaces, signs and decimal points are not permitted. These are exercise rules, not a claim about how every real form should work.
def acceptable_score(text):
if not (1 <= len(text) <= 3):
return False
for character in text:
if character not in "0123456789":
return False
value = int(text)
return 0 <= value <= 100
print(acceptable_score("50"))
print(acceptable_score("101"))
The function expects a string argument. It checks length and characters before converting, so unsuitable text does not reach int(). The two printed results are True and False. A returned Boolean lets another part of a program decide what message to display.
| Input string | Expected result | Reason for choosing it |
|---|---|---|
"50" | True | Ordinary valid value |
"0" | True | Lower accepted endpoint |
"100" | True | Upper accepted endpoint |
"101" | False | Digits and length pass; value exceeds the upper limit |
"-1" | False | Minus sign fails the specified character rule |
"" | False | Required input is absent |
"5.0" | False | Decimal point is not permitted |
"0050" | False | Four characters exceed the length limit |
"050" | True | Permitted leading zero within three characters |
Why the detail matters: rejecting "-1" does not demonstrate that the numerical range check handled that input; this program rejects the minus sign earlier. Identify the actual path taken. Similarly, the function’s agreement with these cases supplies useful evidence without proving every possible program property.
CHAPTER 15 OF 20 · Practise and check
15. Worked task 3: Repair a plausible maximum that is wrong
A student wants the greatest integer in a list and writes this program. It runs, but its starting assumption is unsuitable for the supplied data.
readings = [-8, -3, -11]
largest = 0
for reading in readings:
if reading > largest:
largest = reading
print(largest)
Actual result: zero. Expected result: negative three. None of the readings is greater than the initial zero, so the variable never changes. The defect is a logic error, not a syntax error. Testing only positive numbers could hide it.
The following repair defines an empty-input response and otherwise starts with an actual list item. It deliberately avoids max().
readings = [-8, -3, -11]
if len(readings) == 0:
print("No readings")
else:
largest = readings[0]
for reading in readings:
if reading > largest:
largest = reading
print(largest)
Answer: the repaired program prints -3. Comparing the first item with itself during the first iteration is harmless. The initial value already belongs to the list, and each later comparison retains the greatest value encountered so far.
Try [-4], [0, -1], [2, 9, 9] and []. Expected outputs are -4, 0, 9 and No readings. The cases examine one item, zero, repeated greatest values and an empty collection. Preserve the assumption that all supplied items are integers.
CHAPTER 16 OF 20 · Practise and check
16. Worked task 4: Explain an error after apparently successful output
This faulty program prints all three codes and then fails. Predict the final value of the index when the failing access occurs.
codes = ["A2", "B4", "C6"]
position = 0
while position <= len(codes):
print(codes[position])
position = position + 1
Answer: it prints A2, B4 and C6 on separate lines, then attempts codes[3]. The list has length three but its non-negative indices stop at two. The comparison still allows position three, leading to an IndexError.
Repair the condition to position < len(codes). The complete corrected program is:
codes = ["A2", "B4", "C6"]
position = 0
while position < len(codes):
print(codes[position])
position = position + 1
After printing the final code, position becomes three and the next condition is false. Test one item and an empty list too. With empty input, the corrected loop performs zero iterations; the original version immediately attempts an invalid access. This comparison explains why “I saw the right values on screen” is an incomplete success check.
CHAPTER 17 OF 20 · Practise and check
17. Independent check: explain before looking at the answers
- A. What values does
range(2, 5)produce? - B. A program accepts values strictly below one hundred. Which single accepted-endpoint test exposes its mistake if one hundred should be included?
- C. Does
int("seven")show a syntax error or an exception during execution? - D. Why can a validated score still be factually wrong?
- E. A maximum routine starts at zero. Give the smallest non-empty integer list that can reveal the problem.
- F. A correction fixes the failing test. What should you check next?
Answers and reasoning
A: two, three and four; the stop value is excluded. B: test one hundred and expect acceptance. C: the expression is grammatically valid, but conversion raises ValueError. D: validation checks rules; somebody could type a different in-range score from the real one.
E: a one-item negative list such as [-1]; an initial zero would incorrectly remain larger. F: repeat relevant earlier cases and add tests around the changed behaviour. Explain the cause as well as obtaining the expected output. If you needed the model answer, attempt a changed example before marking the skill secure.
Use the list as a reference throughout the month. There is no need to memorise all one hundred entries before writing a short program. A useful session contains a prediction, a check and an explanation of any difference.
- Week 1: values and decisions. Practise words 1–30 through very short assignments and comparisons. Trace values on paper, then run the code. Revisit the distinction between text, numbers and Boolean results.
- Week 2: loops and collections. Use words 31–60 with the counting task and list-index examples. Record a clear initial state, one row per iteration and the final result. Change the input after each successful explanation.
- Week 3: useful tests. Apply words 61–80 to a stated requirement. Write expected results before running tests. Include ordinary input, relevant boundaries and invalid cases, explaining what each investigates.
- Week 4: evidence for repairs. Use words 81–100 with the maximum and index tasks. Keep the failing example, explain the cause, make a focused correction and repeat earlier tests.
For an illustrative three-student lesson, rotate the roles of tracer, test designer and programmer. Begin with independent predictions, compare them, and let each student justify one test. Finish with a short individual task using changed values. This is a suggested activity, not a statement about tuition availability, lesson duration or guaranteed results.
Parents can ask, “Which line first behaves differently from your prediction?” and “Why did you choose that input?” A child who can explain the requirement but struggles with tracing needs different support from one who traces accurately but chooses weak tests. Use a recent school task and teacher feedback to identify the gap.
Independent practice may be enough when the student can diagnose and explain mistakes reliably. Ask the school for clarification when task conditions are unclear. Guided individual or small-group support may help when misconceptions persist; ask how each learner’s code and reasoning receive feedback. Check actual schedules, class sizes and fees directly with the provider.
CHAPTER 19 OF 20 · Find answers and sources
19. Questions students and parents often ask
Should I memorise the exception names first?
Begin with the distinction between syntax, logic and execution problems. Learn a named exception when it helps explain an actual example. The aim is to connect the message with the relevant operation and cause, not merely to recite labels.
Can I use a shorter built-in function?
Follow the task instructions. A real program may reasonably use a built-in function, while an algorithm exercise may require the steps to be written explicitly. A shorter answer is not suitable if it bypasses the skill the task asks you to demonstrate.
Does one hundred per cent of my selected tests mean the program is perfect?
It means the observed results matched those tests. Consider what was not examined: another branch, empty input, a boundary or a different assumption. State the evidence and its limits accurately.
Why trace by hand when Python can execute the program?
Hand tracing makes your prediction explicit. Running the program then checks that prediction. Using both helps distinguish a mistaken understanding from a defect in the code, especially when the output initially looks plausible.
Does this cover all of G3 Computing?
No. It develops a focused programming skill set. Continue with the other school topics and the correct examination-year syllabus. The curated vocabulary supports practice; it does not replace lessons or establish a predicted examination paper.
The official sources establish the course context and Python behaviour. The explanations, datasets, test selections and worked investigations above are original teaching material.
- SEAB: 2027 G3 Computing K349 syllabus.
- SEAB: 2027 G3 syllabus directory.
- Python tutorial: control flow and functions.
- Python reference: built-in types and sequence operations.
- Python reference: expressions and comparisons.
- Python reference: built-in functions.
- Python tutorial: errors and exceptions, with the exception reference.
For broader subject language, continue with the Secondary 3 advanced Computing vocabulary collection. For school revision planning, use the Secondary 3 G3 Computing EOY preparation guide.
Choose one short program now. Write what it should do, predict its result and test the prediction. If the result differs, keep the evidence and explain the first point of divergence. That is a useful next step in learning both the vocabulary and the programming.
