Three learners review open books together at a classroom table, with stacks of textbooks, stationery and a whiteboard in the bright room.

Secondary 3 G3 Vocabulary | Top 100 Words for Computing: Program Tracing, Testing and Debugging

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.

CHAPTER 1 OF 20 · Understand the course

1. Where this theme fits in G3 Computing

Back to contents

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.

CHAPTER 2 OF 20 · Understand the course

2. A five-minute starting check

Back to contents

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

Back to contents

  1. 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.
  2. 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.
  3. 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”.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
  8. 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.
  9. 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.
  10. 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.

CHAPTER 4 OF 20 · Learn the 100 terms

4. Words 11–20: Track values accurately

Back to contents

  1. Variable. A name associated with a value that may change during execution. In a trace, record the current value of count after each relevant instruction, rather than relying on memory.
  2. 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.
  3. 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.
  4. Constant. A value intended to remain unchanged. A named threshold such as PASS_MARK = 50 communicates that intention; capital letters do not themselves prevent Python from assigning a different value later.
  5. Integer. A whole-number value, which may be positive, negative or zero. The number of completed items is usually an integer; distinguish numeric 12 from the text "12".
  6. 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.
  7. 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.
  8. Boolean. A value representing truth or falsity: True or False. The comparison score >= 50 produces a Boolean result that can control a branch.
  9. 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.
  10. Expression. A combination of values, names and operations that produces a value. quantity * price is 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.

CHAPTER 5 OF 20 · Learn the 100 terms

5. Words 21–30: Explain operations and choices

Back to contents

  1. 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.
  2. Comparison operator. An operator that compares values, such as <, >= or ==. Replacing “at least” with a strict greater-than comparison incorrectly excludes the stated threshold.
  3. Logical operator. An operation such as and, or or not used to combine or reverse conditions. Requiring both conditions calls for different logic from accepting either condition.
  4. Boolean expression. An expression whose result is true or false. 0 <= score <= 100 checks both inclusive limits. State the permitted type of score as well.
  5. Precedence. The rules determining how operators bind within an expression. 2 + 3 * 4 gives fourteen. Use parentheses when they clarify the intended grouping, and explain the calculation.
  6. Selection. Choosing which instructions to execute according to a condition. An if statement can select an acceptance message for valid data and a rejection message for invalid data.
  7. 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.
  8. 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.
  9. Short-circuit evaluation. Evaluating a later logical operand only when needed. In Python, count != 0 and total / count > 10 avoids division when the first condition is false.
  10. 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

Back to contents

  1. 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.
  2. For loop. A Python loop that visits items from an iterable. for score in scores: gives score each successive item. It does not automatically give the item’s index.
  3. 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.
  4. 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.
  5. Loop variable. A variable used to track a loop’s current item or position. Name its role clearly: reading suggests a value, while position suggests an index.
  6. Counter. A value used to count occurrences. Increase count by one whenever an item qualifies. Adding the item’s value instead would turn the calculation into a different operation.
  7. Accumulator. A value that combines contributions over successive steps, often as a running total. Add each qualifying score to total and retain the result for the next iteration.
  8. 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.
  9. 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.
  10. 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

Back to contents

  1. 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.
  2. 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”.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. Parameter. A name in a function definition that receives a supplied value. In def acceptable_score(text):, text is the parameter representing the input being examined.
  8. 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.
  9. Return value. A result passed back to the caller by a function. Returning True allows other code to use the decision; printing a message serves a different purpose.
  10. 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

Back to contents

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. Initial state. The relevant values before the part being traced begins. Record count = 0 and total = 0 before the first item, so later changes have a clear starting point.
  7. 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.
  8. 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.
  9. 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.
  10. 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

Back to contents

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
  8. 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.
  9. 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.
  10. 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

Back to contents

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
  8. 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.
  9. 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.
  10. 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

Back to contents

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.

  1. Syntax error. A violation of the language’s grammatical rules. A missing colon after an if header can prevent parsing. Check the indicated location and the surrounding code.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
  8. 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.
  9. 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.
  10. 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.

CHAPTER 12 OF 20 · Learn the 100 terms

12. Words 91–100: Make and justify a repair

Back to contents

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
  8. 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.
  9. 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.
  10. 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

Back to contents

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)
StageCurrent scoreScore at least 50?CountTotal
Before loopNot yet assignedNot yet checked00
Iteration 142False00
Iteration 265True165
Iteration 350True2115
Iteration 481True3196
Trace recorded after each loop body

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

Back to contents

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 stringExpected resultReason for choosing it
"50"TrueOrdinary valid value
"0"TrueLower accepted endpoint
"100"TrueUpper accepted endpoint
"101"FalseDigits and length pass; value exceeds the upper limit
"-1"FalseMinus sign fails the specified character rule
""FalseRequired input is absent
"5.0"FalseDecimal point is not permitted
"0050"FalseFour characters exceed the length limit
"050"TruePermitted leading zero within three characters
Selected tests for the stated score-entry rules

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

Back to contents

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

Back to contents

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

Back to contents

  • 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.

CHAPTER 18 OF 20 · Plan useful support

18. A four-week plan for students and parents

Back to contents

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

Back to contents

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.

CHAPTER 20 OF 20 · Find answers and sources

20. Sources and useful next reading

Back to contents

The official sources establish the course context and Python behaviour. The explanations, datasets, test selections and worked investigations above are original teaching material.

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.

Explore the connected learning guides

Choose the question that brought you here. Open one useful guide, try a small task, and stop when you have what you need.

Take one question further

The same learning habit can travel across subjects, while each subject keeps its own methods. These routes help you notice a difficulty, understand one part of it, and return to something you can do.

A word is familiar, but using it is difficult.

Move from recognising a word to retrieving it in a new context. Understand vocabulary plateaus.

Try it without the guide: Choose one word you already know. Close the guide and use it in a new sentence. Explain why it fits; try another context tomorrow.

A piece of writing has ideas, but the reader loses the thread.

Make the order of events and the links between sentences clear. Explore composition writing.

Try it without the guide: Choose one short paragraph. Read the relevant explanation, close it, and revise the paragraph. Ask someone to tell you what happened and why.

The Mathematics seems familiar, but marks still disappear.

Find the first point where the working stops being reliable. Find Secondary 4 A-Math mark leakage.

Try it without the guide: For a Secondary 4 A-Math question you have attempted, locate the first uncertain line. Repair that step, then try a comparable question without the worked answer.

A Science fact is remembered, but the explanation is incomplete.

Connect the evidence to a scientific idea and the resulting change. Follow the Primary Science learning route.

Try it without the guide: Choose a familiar Primary Science example. Explain the evidence, the idea and the result without notes. Then change one condition and explain your prediction.

Two accounts of the world seem to disagree.

Check the question, source, date and evidence before combining claims. Explore the World Knowledge research library.

Try it without the guide: Take one claim. Find the source best placed to support it, note its date, and state what remains uncertain. Return to your original question.

There is plenty of help, but independence is hard to see.

Check what the learner can understand and do after support is removed. Understand how education works.

Try it without the guide: Choose one small task the child has practised. Agree on a calm, brief attempt without prompts. Use what happens to choose one next step, then stop.

For the structure behind these connections, read the eduKateSingapore runtime manifest and the eduKate ecosystem boot contract. The reader map describes public navigation; those manifests preserve the wider ownership and return rules.