Singapore A-Level H2 Computing (9569) overview: data representation, computer architecture, algorithms and data structures, programming and software development, databases, networks, and machine learning and emerging technologies

What H2 Computing really demands

H2 Computing (SEAB 9569) is a JC2 subject that joins a written theory paper with a practical, lab-based paper, and it rewards one move above all: turning understanding of how computing works into a correct, efficient, working solution. Across the syllabus you study how data is represented and how machines process it, how to design and analyse algorithms, how to write and test code, and how databases and networks underpin real systems, before applying these ideas to machine learning and its ethics. The gap between a capable candidate and a strong one is whether every algorithm is traced correctly and every design choice is justified, on grounds of correctness and efficiency, rather than described loosely.

This guide ties together the matching dot-point pages, each with its own practice. See the full set at /sg-a-level/computer-science/syllabus and the subject hub at /sg-a-level/computer-science. The strands below build on each other.

Data representation: the foundation

Everything a computer does rests on representing data as binary. This strand covers number bases and conversion, two's complement integers, floating-point representation, character encoding (ASCII and Unicode), and bitwise operations and masking. The essential skill is to convert fluently between bases and to explain how a chosen representation trades range against precision.

Computer architecture and operation

Hardware is the machine that runs your code. This strand covers CPU components and registers, the fetch-execute cycle, interrupts and I/O handling, logic gates and Boolean algebra, and the memory hierarchy and cache. The key idea is that the processor repeats a simple cycle very fast, and that design choices such as caching exist to bridge the gap between fast processors and slower memory.

Algorithms and problem solving

The analytical heart of the subject is designing and comparing algorithms. This strand covers linear and binary search, bubble and insertion sort, merge sort and quicksort, recursion and divide and conquer, graph traversal (BFS and DFS), and Big-O notation and complexity. The recurring move is to justify a choice: binary search runs in $O(\log n)$ but needs sorted data, while merge sort guarantees $O(n \log n)$ where bubble sort degrades to $O(n^2)$.

Data structures

Algorithms operate on data structures, and the right structure makes an algorithm fast. This strand covers arrays and records, linked lists, stacks and queues, hash tables, binary search trees, and graphs representation. The reward is choosing the structure whose operations match the task: a hash table for near-constant-time lookup, a queue for first-in-first-out processing, a tree or graph for hierarchical and networked data.

Programming and software development

Theory becomes a working solution in code. This strand covers Python control flow and functions, modularity and abstraction, object-oriented programming, exception handling and file I/O, the software development lifecycle, and testing and debugging strategies. The central idea is that good code is modular, tested and maintainable, and that systematic debugging is a designed skill, not luck.

Databases, networks, and machine learning

Three applied strands complete the subject. Data and databases is the design and querying of relational data: relational database design, entity-relationship modelling, database normalisation, SQL data definition and constraints, and SQL data manipulation. Networks and the internet covers the TCP/IP protocol stack, packet switching and routing, IP addressing and subnetting, DNS and web protocols, and network security and encryption. Machine learning and emerging tech applies these foundations: machine learning fundamentals, supervised versus unsupervised learning, neural networks and deep learning, and AI ethics and automation impact.

How H2 Computing is examined

• Trace and justify algorithms. In the written paper, trace an algorithm correctly step by step and justify an algorithm or data-structure choice using complexity analysis, not just description.
• Build and test working code. In the practical paper, produce Python that runs, validating input and handling errors, and design and query a normalised database against the task.
• Reason from foundations. Relate low-level ideas (two's complement, the fetch-execute cycle, the memory hierarchy) to why they matter for correctness and performance.

Check your knowledge

A mix of recall, technique, and application questions covering the H2 Computing strands. Attempt them under timed conditions, then check against the solutions.

1. Convert the unsigned binary number $1011_2$ to denary. (2 marks)
2. State the Big-O time complexity of linear search and of binary search, and the condition binary search requires. (3 marks)
3. Explain why a hash table can offer near-constant-time lookup. (2 marks)
4. State the difference between a stack and a queue in terms of how items are removed. (2 marks)
5. Explain what the fetch-execute cycle is and why a cache exists. (3 marks)
6. State what database normalisation aims to reduce, and name one benefit. (2 marks)
7. Explain the difference between supervised and unsupervised machine learning. (2 marks)
8. Explain why systematic testing and debugging matter as much as writing the code. (2 marks)