How to Survive G3 Computing | 2027 SEC K349 Python and Spreadsheets

To survive G3 Computing, start by separating a program that runs from a program that solves the problem correctly. If the code produces a number, ask whether it is the right number for ordinary inputs, boundary inputs and invalid inputs. If a spreadsheet formula looks right in its first row, ask whether copying it changes a reference that should stay fixed. Most frustrating mistakes are traceable: wrong requirement, wrong condition, wrong variable update, or an unchecked assumption. Fix the earliest wrong decision rather than memorising more syntax.

For the 2027 Singapore–Cambridge Secondary Education Certificate (SEC), G3 Computing is syllabus K349, formerly O-Level 7155. The written Paper 1 lasts two hours, has 80 raw marks and counts 60%. The lab-based Paper 2 lasts 2 hours 30 minutes, has 70 marks and counts 40%. Paper 2 uses a computer with spreadsheet, Python and JupyterLab access; it includes one spreadsheet question and four to five programming questions, with time for saving required work. Both papers are compulsory. Knowing this scheme early helps you plan both concepts and hands-on practice.

Computing can support interests in software development, cybersecurity, data, engineering, design, business systems, science and many technical or creative fields. The most transferable skills are defining a problem, expressing a logical solution, testing it honestly and understanding the consequences of technology. The subject does not guarantee any post-secondary place or technology career. Different JC, MI, polytechnic and ITE routes have course-specific requirements; the first SEC cohort in 2027 will apply under updated post-secondary arrangements from 2028.

Here is your first twenty-minute recovery task: choose one broken piece of Python or a spreadsheet formula, write the expected behaviour in ordinary language, trace the actual result, identify the first mismatch and run a corrected version on fresh data. This guide provides the official exam structure, worked examples, a realistic study plan, secure computing habits and parent advice, without assuming that being confident with a phone is the same as knowing how computer systems work.

Quick rescue plan

Paper 1: maintain coverage of all five modules and written explanations.
Paper 2: practise Python and spreadsheets with genuine saved files.
For every task: identify input, expected output, boundary and invalid conditions.
Use trace tables and changed test data rather than assuming a program that runs is correct.
Rehearse saving deliverables within the full 2 hour 30 minute lab time.

The written and lab papers test different kinds of competence

Paper 1 assesses all five K349 modules. It combines multiple-choice questions with single or multiple answers, short-answer questions, matching, cloze passages and structured questions. Relevant formulae are provided, and an approved calculator may be used. The important skill is selecting the correct model and explaining computing concepts, not simply recognising familiar code formatting.

Paper 2 is a lab-based examination of 2 hours 30 minutes, carrying 40%. It assesses programming and spreadsheets, with one spreadsheet question and four to five Python programming questions. Candidates submit softcopy files and must allocate time for saving their work. The examination centre provides appropriate software and a computer for the individual candidate. Students should practise the relevant applications, not assume any laptop tool of their choice will be available.

A useful preparation plan divides errors into concept, algorithm, syntax, logic, spreadsheet reference, data validation, testing and file-handling. A candidate who loses marks because a program crashes needs a different repair from one whose code runs but ignores the task’s business rules.

The five K349 modules belong on one revision map

Module 1 is Computing Fundamentals, covering computer systems, data representation and logic. Module 2 is Algorithms and Programming. Module 3 is Spreadsheets. Module 4 is Networking. Module 5 is Impact of Computing. Paper 1 can assess all five, while the lab paper targets Modules 2 and 3.

Make a weekly map of those modules so that Python does not consume all the available time. Students who enjoy programming may neglect networking, number systems and ethical questions, even though these contribute to the larger written paper. Conversely, excellent theory notes cannot replace the ability to debug and save a working lab response.

Sample one small question from each module during diagnosis. Use the result to allocate targeted practice while maintaining regular contact with the other topics. The goal is breadth plus depth, not equal numbers of worksheets regardless of difficulty.

Problem analysis begins with inputs and correct outputs

The syllabus asks students to identify necessary inputs, validation requirements and correct outputs before constructing solutions. If you cannot describe what success means, you cannot design reliable tests. A program that receives any text without crashing is not necessarily correct when the task requires an integer from one to one hundred.

Imagine a school club collecting the number of participants for an activity. The task may require an integer from 1 to 40, and output a total. Validating this input is separate from calculating the total correctly. A response that accepts negative participants or counts a rejected value fails the requirements even if it prints a number.

Write an input–process–output table for every new problem. Add one row for invalid data. Then decide what output or error response is required. Many later bugs disappear when the requirements are defined clearly at the start.

Computer architecture: different components have different jobs

A processor executes instructions, main memory holds data and programs being used, and secondary storage keeps information for longer-term retrieval under normal operation. Interfaces and buses move information within the system. Students who use words such as RAM, CPU and storage interchangeably may struggle when asked to explain performance or a particular hardware role.

An original scenario describes a program opening a large dataset. The computer may need to read the file from secondary storage into memory for processing, while the CPU performs relevant operations. Adding more storage capacity is not automatically the same as increasing processing speed. A system has multiple constraints.

Practise drawing a simplified path from input or storage through memory and processing to output. Label each stage’s role and avoid inventing unnecessary architectural detail beyond K349’s prescribed scope.

Bits, bytes and decimal versus binary units

K349 includes bits and bytes, larger units and distinctions such as kilobyte versus kibibyte. A byte ordinarily contains eight bits. Decimal kilo represents a factor of one thousand, while binary kibi represents 1,024. Students should read the specific unit before multiplying or dividing.

An original task asks how many bits are in 2,048 bytes. The answer is 16,384 bits. If instead it asks for bytes in 2 KiB, the answer is 2,048 bytes. A claim that 2 KB and 2 KiB are always identical would be wrong under the prescribed definitions.

Write a units table and practise small conversions before handling very large values. Include the distinction between storage size and transmission rate, because a number labelled in bits per second is not directly a file size in bytes.

Binary, denary, hexadecimal and two’s complement

Number representations are systems of notation. Binary uses powers of two, while hexadecimal groups binary digits compactly. K349 also includes two’s complement for fixed-width signed integers. A student should understand that the bit width determines the range of representable values.

Original example: denary 13 is binary 1101, or 00001101 in an eight-bit representation, and hexadecimal D. For eight-bit two’s complement, negative 3 is formed from positive 3, 00000011, by inverting bits to 11111100 and adding one to give 11111101. The eight-bit width is part of the reasoning.

Check the bit pattern by interpreting its signed value, and avoid treating every leading one as a positive magnitude. Work with a fixed width when the question specifies one; changing width without explanation can alter the representation.

Logic gates: a truth table has no room for guessing

AND, OR, NOT, NAND, NOR and XOR are part of the syllabus. Given a circuit, label intermediate outputs before calculating the final result. For a circuit with two inputs, evaluate all four combinations. For three inputs, there are eight input rows. Logical expressions and circuit diagrams should agree.

Original comparison: A AND B is true only when both inputs are true. A XOR B is true when exactly one of the two is true. Students who mistake XOR for ordinary OR will predict a true output when both inputs are true, which is incorrect for XOR.

Use truth tables to verify De Morgan’s laws in small examples, such as NOT(A AND B) being equivalent to (NOT A) OR (NOT B). The point is not memorising a phrase alone but seeing that the outputs agree for every input combination.

Sequence, selection and iteration: identify the control flow

Sequence performs instructions in order. Selection chooses a path based on a condition. Iteration repeats a block under a specified rule. Misplacing one update or using the wrong comparison can cause a program to return an incorrect result or keep running unexpectedly.

Consider a program summing a list of numbers. If total is reset to zero inside the loop, the result may contain only the last item. The intended structure is to initialise total once before iteration and update it with each item. This is a logic error even if the Python is syntactically valid.

Practise tracing the values of variables through each loop step on paper. A dry run with three items is often sufficient to expose a misplaced initialisation before a full lab exam.

Selection conditions must match the task boundaries

A program classifying a score should follow the exact range boundaries in the question. If the pass threshold is 50, a condition using greater than 50 excludes a score of exactly 50. This is a boundary bug, not a cosmetic syntax issue.

Write test cases just below, exactly at and just above the threshold. For the example, try 49, 50 and 51. Explain which branch each should follow. Then check what happens if the input is not numeric or lies outside the permitted range.

Students who only test 75 may incorrectly believe the program is complete. Testing near the decision boundary checks whether the implementation matches the definition.

Python lists and indices: keep positions distinct from values

Python list indexing begins at zero. In a list [4, 7, 9], the first element is at index 0 and the final element is at index 2. A search for the value 9 should return 2 when the task asks for a zero-based index. Returning 3 is a different representation and would need explicit instruction.

Students sometimes mix a list element with its index in loops. Write the variable’s meaning beside the relevant line: is it a position, a value or a count? This small step can prevent errors in searching, filtering and combining data.

Practice with small lists containing duplicates, missing targets and empty data when appropriate to the requirements. A search algorithm should handle a missing value in the specified way rather than assuming every item always appears.

String operations: symbols and spaces are part of data

Strings contain sequences of characters, including spaces, punctuation and digits represented as text. Splitting a comma-separated line is different from splitting on whitespace. Case handling and input cleaning may matter, but should follow the problem’s requirements rather than alter legitimate information silently.

Original task: the string ‘Ada,Bo,Chen’ can be split on commas into three names. The string ‘Ada Bo Chen’ contains spaces instead, so the same comma-based operation does not produce the same result. A student should understand which delimiter is actually present.

Practise indexing, slicing, searching and checking characters using teacher-approved examples. Ask how an empty string or missing delimiter should be treated. Reliable string handling is a foundation for file processing.

Dictionaries: a key is not the same as a position

A Python dictionary stores key-value relationships rather than promising that the key’s meaning comes from its numeric location in a list. In a fictional attendance dictionary, the key may be a club identifier while its value is a count. Looking up a missing key needs the handling specified by the task.

Students can create a small dictionary, query an existing key, update a value and delete a key. Then explain how this differs from retrieving the third item of a list. The goal is choosing a suitable data structure for the information, not memorising syntax without purpose.

A good error diagnosis asks whether the bug concerns the wrong key, an overwritten value, or an assumption that every key exists.

Functions and variables: track scope and return values

Functions divide a problem into manageable pieces and may accept parameters or return a value. A function that prints an intermediate number does not necessarily return it to the caller. Local variables exist in a different scope from global variables, so changes are not always visible in the place a student expects.

An original function named calculate_total accepts a list of numbers and returns the sum. Its caller then uses that return value to display a result. If the function instead only prints a value but the caller tries to add its return to another number, the design may fail because there is no suitable return value.

Design small functions with one clear purpose and test them independently. This helps isolate errors and supports incremental development during the lab paper.

Testing: correct code survives changed data

The syllabus expects syntax, logic and run-time errors to be distinguished. Syntax errors stop code from being interpreted; run-time errors occur during execution; logic errors may allow execution but produce incorrect behaviour. Each calls for a different debugging response.

If a division uses a denominator that can be zero, a suitable test should reveal the problem and the code should handle it according to requirements. If a score classifier uses the wrong threshold, its error is logical. If a bracket is missing, the problem is syntactic. Students should not use ‘bug’ as the only explanation when the question asks for cause.

Keep a test table with input, expected output, actual output and result. Use normal, boundary and invalid data. The program should work for more than the single sample given in the question.

File input and output: keep the record trustworthy

K349 includes basic file operations such as opening, reading, writing and closing, alongside programming techniques. Students should identify whether a file is a data source or output destination and handle the format specified by the task. Overwriting a file when append was intended can destroy previous results.

Imagine a program reading one line per participant and counting valid entries. It should not interpret the heading as a participant if the format specifies a header. If the task requires storing results, the candidate should save the correct file in the required location.

Use small invented files for practice and follow school lab rules. The lab exam includes time for saving deliverables, so file naming and checking saved contents are part of competence.

Algorithms: don’t rely on forbidden shortcuts

The syllabus names standard algorithms such as finding minimum or maximum without using built-in min or max, calculating totals without sum, searching manually and extracting items meeting criteria. A question may require an implementation without a convenience function, so students should understand the underlying loop.

To find a maximum in a non-empty list, start from a genuine list value, then compare each remaining value with the current candidate. Initialising the maximum to zero could fail for a list containing only negative numbers. That is a good boundary test.

Practise explaining the state of the algorithm at each iteration. A correct final answer achieved through a prohibited shortcut may not demonstrate the required method, so read restrictions carefully.

Spreadsheet references: copying exposes hidden mistakes

Spreadsheets can use relative, absolute and mixed references. A formula may be correct in one row but wrong after copying if a fixed rate cell moves. Suppose B2 holds an amount and E1 holds a common multiplier. A copied formula should anchor E1 appropriately, such as with $E$1 where absolute reference is intended.

Try entering the formula in one row, copying it to five more and checking each result against hand calculation. If the reference shifted to an empty cell, the formula needs correction. The visible number in the first row did not prove the structure was suitable.

Practise relative, absolute and mixed references with a clear explanation of what must change when the formula moves horizontally or vertically. The method is general across many spreadsheet tasks.

Spreadsheet logic, lookups and conditional formatting

The syllabus includes logical, mathematical, text, statistical, lookup and date functions, as well as Goal Seek and Conditional Formatting. Students should not memorise functions as isolated names. Choose each one for a clear operation: classify, total, count, locate or solve for a target.

Original example: classify amounts as ‘Within budget’ when the expense is less than or equal to a supplied threshold, and ‘Review’ otherwise. A suitable IF formula needs the correct comparison and should reference the threshold cell as required. Test equality at the threshold, not only numbers far above or below it.

With lookup tables, decide whether exact or approximate matching fits the task. An incorrect approximate match can assign a category silently. Use an appropriate table structure and verify boundary values.

Goal Seek and spreadsheet checking

Goal Seek can determine what input cell value would make a formula-driven result reach a selected target, subject to the spreadsheet model. It does not independently prove the model’s assumptions are sensible. If the formula is wrong, Goal Seek can find a numerical solution to the wrong question.

An original scenario calculates revenue as unit price multiplied by quantity. Goal Seek could determine the quantity needed for a specified revenue target with a fixed price. But if the required quantity is fractional and the business sells only whole items, an additional feasibility check is needed.

After using a tool, substitute the resulting input into the formula and interpret the answer. The same check applies to copied formulas and conditional formatting rules.

Networking: protocols, LANs and routers

A network links computing devices to exchange data. LANs operate across a relatively limited area, while WANs connect larger geographic scopes. The internet connects many networks. Students should distinguish a router, switch, modem and wireless access point according to their roles rather than treat every box in a home network as ‘the Wi-Fi’.

Data travel under communication rules called protocols, often as packets. MAC and IP addresses serve different purposes at relevant network layers. Students should learn what information a local switch or router uses under the syllabus model and how the network arrangement affects data transmission.

Draw a simple school-approved home network diagram and trace data from a laptop through local networking equipment toward an external service. This is conceptual learning, not an instruction to reconfigure an unknown person’s network.

Network privacy and cybersecurity ethics

K349 covers security and privacy, including the roles of anti-malware programs, firewalls, encryption and Singapore’s Personal Data Protection Act in the stated syllabus scope. Security concerns protecting systems and data; privacy concerns appropriate collection, use and disclosure of personal information. A stronger answer specifies the risk and the mechanism that addresses it.

Phishing may try to trick a user into providing credentials via deceptive messages. Encryption can protect information from unauthorised reading in suitable contexts, while a firewall follows configured rules about network traffic. Neither guarantees protection from every threat. Students should avoid experimenting with other people’s accounts or software systems without permission.

Practice with defensive scenarios: identify suspicious requests, verify the source through trusted channels and explain how data minimisation reduces unnecessary exposure. Ethical behaviour is part of technical competence.

Impact of computing, copyright and AI

The impact module includes communication, education, transport and retail, as well as copyright, licenses, false information and emerging technologies. A program can be useful and still create social or privacy concerns. Students should be able to discuss benefits and limits using evidence rather than assume all technology is automatically helpful.

AI and machine learning are included in the syllabus, with a simple nearest-neighbour classification exercise based on two quantitative features. This introduces the idea that a model’s result depends on training examples and similarity criteria. A plausible classification does not prove the model is fair, suitable or free from bias.

Software ownership and licensing should be respected. Free of charge does not necessarily mean public domain or permission to copy and redistribute without conditions. Academic and professional computing both require honest use of sources and data.

Four-week plan for written and lab readiness

Week one: sample all five modules and identify the largest knowledge gaps. Attempt one spreadsheet formula copy, one short Python loop and one data-representation question. Week two: repair the common mistakes in data types, algorithm structure, reference anchors and boundary conditions using small fresh examples.

Week three: integrate program design, testing and file output into short lab tasks, while keeping written-paper networking and ethics practice alive. Week four: rehearse timed Paper 1 and Paper 2 sections, including saving the final lab files. Follow the school’s actual software setup and allowed resources.

Parents can support by asking the student what the program was intended to do, how it was tested and what changed after a bug was found. A useful tutor teaches the student to trace and solve the next problem independently rather than simply rewriting the code for them.

Twenty original worked Computing checks

These are hypothetical classroom scenarios with invented data, not SEAB examination questions. The examples are defensive and educational: use only authorised practice software and synthetic data.

Worked example 1: an accumulator that resets inside a loop

Suppose a program should calculate the sum of [3, 5, 7]. The expected result is 15. If the total variable is set to zero at the beginning of every iteration, the loop calculates 3, then discards it before calculating 5, and eventually finishes with 7. That is a logic error even though the program may execute without a syntax message.

The correct design initialises total once before the loop and adds each value inside it. Trace the total after each item: 3, 8, 15. Retest with [2, 4] to obtain 6. A student who understands the position of the initialisation can transfer the idea to counting, averaging and other accumulation tasks.

Worked example 2: an off-by-one grade boundary

A fictional task labels scores of 50 and above as Pass. A condition testing only scores greater than 50 will label 50 incorrectly. A program tested solely with 75 may appear successful, while the exact boundary fails. This is a classic reason to define expected outputs before writing the final condition.

Prepare test cases of 49, 50 and 51, along with invalid inputs such as −1 or 101 if the allowed range is 0–100. Distinguish the pass threshold from input validation. The algorithm must both reject invalid data and classify valid data according to the prescribed rule.

Worked example 3: a maximum that fails on negative values

A program finds the largest value in a non-empty list but begins with maximum set to zero. If the list is [−8, −3, −5], none of its values exceeds zero, so the program incorrectly returns 0, which is not even present. The problem is the starting assumption, not the loop’s comparison operator.

Initialise the candidate maximum from the first actual list element, then compare subsequent values and update when a larger item appears. The correct maximum is −3. This also illustrates why the question’s guarantees about an empty or non-empty list matter before choosing an algorithm.

Worked example 4: index versus list position

Consider the list [4, 7, 9]. Its Python indices are 0, 1 and 2. If a question requests the zero-based index of 9, the correct answer is 2. A program returning 3 has confused the human-style third position with the specified index. Always read whether the task requests the item, its index or a one-based position.

Test a search with the target absent as well as present. The program needs an explicit missing-target response matching the requirements. Students should not quietly return an unrelated number just because the normal test contained the target.

Worked example 5: a string split on the wrong delimiter

The text ‘Ada,Bo,Chen’ contains comma-separated values, while ‘Ada Bo Chen’ uses spaces. Splitting the first by commas can produce three names, but applying that same delimiter to the second may return one whole string. A student who assumes all text is separated the same way has ignored the input specification.

Check sample lines from the actual file format before programming. Try an empty field and an extra delimiter if the task might permit those cases. When writing the solution, explain what the delimiter represents rather than copying a method from a different exercise.

Worked example 6: dictionary key not found

A dictionary uses club names as keys and attendance counts as values. Looking up a name that is absent may cause an error if the code directly requests a nonexistent key. A task may require reporting ‘unknown club’, adding a new entry or rejecting input. Those are different behaviours and the specification decides.

Test one existing key and one missing key. The student should explain how a dictionary differs from indexing a list and why data validation precedes updates. Handling unexpected inputs is evidence of understanding, not an optional embellishment.

Worked example 7: trace table for a conditional loop

An algorithm repeatedly subtracts 3 from a starting value of 10 while the result remains positive. A trace table should record the value after each iteration: 7, 4, 1, then the next condition must be evaluated carefully. If subtraction is performed again, the value becomes −2 before the loop stops under a suitable while-condition design.

Specify exactly when the condition is checked and what output is required. A student who relies on intuition without tracing can easily make an off-by-one error. Small manual examples reveal what the loop actually does, especially when the final value crosses a boundary.

Worked example 8: a function prints instead of returning

A task requires a function to compute a total so that another calculation can use the result. If the function only prints the total and returns no usable value, the caller may fail when it tries to add the function’s result to a number. Printing for display and returning for computation serve different purposes.

Write a minimal test calling the function with [2, 3, 4] and expecting the number 9. Then use that return value in a second calculation, perhaps multiplying it by two. A student should explain where the result travels, not only whether it appeared on screen.

Worked example 9: negative values in two’s complement

In eight-bit two’s complement, positive 3 is 00000011. Inverting the bits gives 11111100, and adding one produces 11111101 for negative 3. The bit width matters. A student cannot interpret every bit pattern with a leading 1 as if it were an unsigned positive integer when the task specifies signed two’s complement.

Check by interpreting the fixed-width value using the prescribed representation. Practise with positive and negative small integers, then check what the minimum and maximum representable values are for that width.

Worked example 10: XOR versus OR

Two inputs A and B feed an XOR gate. When exactly one input is true, the output is true. When both inputs are true, XOR is false. Ordinary OR, by contrast, is true when either or both inputs are true. The difference appears in the both-true row.

Draw the four-row truth table with input pairs 00, 01, 10 and 11. Explain the results before sketching a circuit. Testing every combination is quicker and more reliable than inferring gate behaviour from a name you half remember.

Worked example 11: decimal versus binary storage units

A small file is 2,048 bytes, so its size is exactly 2 KiB under the binary unit definition. The same quantity is 2.048 KB using decimal kilo. These are close but not equal. The distinction becomes much larger when capacities use bigger multiples.

Convert 2,048 bytes into bits to obtain 16,384 bits. Always keep the label attached to the value, and distinguish file size from a network transmission rate measured in bits per second. A large number alone cannot communicate what is being measured.

Worked example 12: spreadsheet cell reference changes on copying

A spreadsheet has amounts in B2 through B6 and a fixed multiplier in E1. A formula in C2 multiplies B2 by E1. If the formula is copied down with both references relative, it may use E2, E3 and later cells, giving incorrect or blank results.

When the task requires a fixed multiplier, anchor the E1 reference appropriately with an absolute reference such as $E$1. Then copy the formula and verify a few results by hand. A formula correct in its starting cell does not prove copied instances are correct.

Worked example 13: conditional formatting is not a calculation

A table marks expenses above a fixed limit in a different colour through Conditional Formatting. The colour can update as values change, but visual highlighting is not itself the formula calculating the total or validating the input. A student should distinguish formatting rules from data transformation.

Change one expense from just below to exactly at the limit, then above it. Check whether the rule uses greater-than or greater-than-or-equal according to the task. This exposes the same boundary reasoning that matters in Python conditions.

Worked example 14: exact lookup versus approximate lookup

A spreadsheet uses a table connecting student IDs with names. An exact lookup is appropriate when each ID has a particular matching record. Approximate lookup can return an unintended neighbouring result if the table and matching mode are wrong. Do not choose the approximate mode merely because it appears shorter.

Contrast this with a sorted table of score ranges where an appropriate approximate match can classify a numeric value into a band. Test values exactly on the boundary and outside the expected range. A correct choice depends on what the table represents.

Worked example 15: Goal Seek finds a number, not business truth

A spreadsheet model multiplies unit price by quantity to calculate revenue. If the price is $12 and a business hopes for $1,200 revenue, the target quantity is 100 units under that formula. Goal Seek can help find the input required to reach the stated output.

But the software has not proved that 100 units can be produced or sold. A different price, cost or demand assumption changes the decision. Students should verify the formula and interpret the result. In the lab exam, always check saved spreadsheet values and the actual task’s output.

Worked example 16: network addresses and devices

An invented home network has a modem connecting to its service, a router directing traffic between networks and a local switch connecting several wired devices. A wireless access point supports local wireless connectivity. Students should describe each role rather than call every device the ‘Wi-Fi box’.

Trace the path a laptop’s data might take towards an external site at a conceptual level. Explain why MAC addresses help within a local network and IP addresses guide communication across networks under the syllabus model. This is defensive system understanding, not an instruction to modify another person’s network.

Worked example 17: a phishing message versus a real service notice

A hypothetical email imitates a school portal and asks a learner to enter their password on an unfamiliar site. The safe response is to verify the communication through known official channels, not simply trust a familiar logo. The message’s appearance does not prove it came from the institution.

Explain what phishing tries to obtain and how user caution, authentication and relevant security practices reduce exposure. Firewalls and encryption have different roles and cannot guarantee protection if a user voluntarily enters secrets into a fraudulent page. Never experiment with real credentials to learn this concept.

Worked example 18: privacy and a spreadsheet of classmates

A fictional student project records classmates’ attendance alongside names and contact details. Before collecting personal information, consider whether every field is needed, what purpose has been communicated and how long data should be retained. The Personal Data Protection Act principles in the syllabus promote responsible handling, not unrestricted sharing for convenience.

Use synthetic records for practice rather than collecting real people’s identifying details without appropriate authority. When demonstrating sorting or counting, a list of invented identifiers can teach the same technical concept without unnecessary privacy risk.

Worked example 19: nearest-neighbour classification

An illustrative machine-learning task assigns two numerical features, such as height and width, to each training example. A new object is classified based on the nearest example under the stated distance rule. This demonstrates a basic idea behind nearest-neighbour methods, not proof that every AI model works the same way.

Change one training example and see whether the classification changes. Then discuss why biased or unrepresentative examples can lead to poor outcomes. The learner should distinguish a model’s computed result from a claim that it is fair or appropriate for high-stakes decisions.

Worked example 20: lab submission must include saved work

A candidate writes working Python in JupyterLab and a correct spreadsheet, then reaches the end of the 2 hour 30 minute lab without saving required softcopies to the instructed location. The technical solution may exist on screen but the assessed deliverable has not been properly prepared.

Make saving, file naming and verification part of timed practice rather than an afterthought. Confirm that the required file opens and contains the expected output without relying on autosave assumptions. Follow the examination centre’s actual instructions, not the student’s usual home folder conventions.

Frequently asked questions about K349

What is the 2027 G3 Computing syllabus code?

K349, corresponding to former O-Level Computing 7155.

How is the examination weighted?

Paper 1 written is 60%, 80 marks and two hours; Paper 2 lab is 40%, 70 marks and 2 hours 30 minutes.

Which software is used in the lab paper?

The official syllabus specifies access to spreadsheet software, Python and JupyterLab at the examination centre.

How many lab questions are there?

One on spreadsheets and four to five programming questions, with all questions compulsory.

Which modules are included in Paper 1?

Computing Fundamentals, Algorithms and Programming, Spreadsheets, Networking, and Impact of Computing.

Can calculators be used?

An approved calculator may be used in both papers, subject to examination instructions.

Will valid Python syntax guarantee a correct answer?

No. A program can run with logic errors or fail to meet input, output and boundary requirements.

What is the first step when debugging?

Record expected and actual behaviour, trace variables to the first mismatch, and test the correction with changed data.

Why do spreadsheet references matter?

Relative and absolute references behave differently when formulas are copied; a fixed rate may need anchoring.

Does the practical exam require saving files?

Yes. Required work is submitted as softcopy, and the paper’s duration includes time for saving.

Does Computing guarantee a software career?

No. It supplies useful foundations; later courses and careers involve additional skills and eligibility rules.

Can the child practise without paid software?

Appropriate freely available learning environments may help, but confirm the exact software and functionality required by the school and assessment.

Official K349 syllabus and connected eduKate guides

The 2027 SEAB K349 document is the authority for paper format, permitted resources, content and lab-deliverable rules. Related eduKate articles are supporting learning resources; check course admission requirements independently.

Tomorrow’s one useful debugging decision

Open a small piece of code or spreadsheet that failed, state what it should have done, record what it actually did, and locate the first point where the two diverged. Fix that step and try different data. G3 Computing becomes less intimidating when programs, formulas and systems are understood as testable decisions rather than magic instructions.

Explore eduKate Singapore’s approach to learning and parent–student consultations

How to survive G3 Computing? | Python, Spreadsheets, Algorithms and Lab Exam