O-Level Computing Notes (Fourth Version, 2024)

Chapter 1: Computer Architecture

• What is a computer? A device that receives and processes data according to a set of instructions, producing processed data as output. Computer architecture describes how a computer is designed and built to function, including how its parts are designed, organised and connected.
• Historical context and data representation: Early computers relied on mechanical components (cranks, gears, pulleys, levers). Example toy Dig-Comp II demonstrates data as switches and ramps, illustrating a mechanical computer that performs addition without electricity. Modern computers are digital, using binary data; the smallest unit is a bit (0 or 1). Multiple bits form a byte (8 bits).
• Data units (Table 1.1 summary): data units increase in size by powers of 10 and powers of 2 depending on SI vs binary prefixes. Key terms include: bit, byte, kilobyte (kB), kibibyte (KiB), megabyte (MB), mebibyte (MiB), gigabyte (GB), gibibyte (GiB), terabyte (TB), tebibyte (TiB), petabyte (PB), pebibyte (PiB).
• Important note on prefixes: Since 1998 SI prefixes (kilo, mega, giga, etc.) follow standard meanings, while binary prefixes (kibi, mebibyte, gibi, etc.) represent powers of 1024. In practice, kilobyte and megabyte are still often used to mean 1024 bytes and 1024^2 bytes, respectively, despite the SI standard divergence. Quick Checks in 1.2 reinforce this distinction and conversions.
• System overview: Computers work with data stored/processed in binary; a bit is the smallest unit, a byte is 8 bits. Data representation forms the basis of how software, memory, and storage are designed.

Key terms (selected):

• Bit, Byte, Kilobyte (kB), Kibibyte (KiB), Megabyte (MB), Mebibyte (MiB), Gigabyte (GB), Gibibyte (GiB), Terabyte (TB), Tebibyte (TiB), Petabyte (PB), Pebibyte (PiB).

1.1 Learning outcomes (highlights):

• Understand what a computer is and how architecture describes its design and interconnections.
• Recognise the historical evolution from mechanical to digital architectures.
• Describe data representation units and their relationships (bits/bytes, prefixes).

1.2 Units of Data (in-context content):

• Bit: binary digit, 0 or 1. Byte: eight bits.
• Data units include kB, KiB, MB, MiB, GB, GiB, TB, TiB, PB, PiB with values tied to either 1000-based or 1024-based scales depending on the prefix family (SI vs binary).
• Quick checks address true/false statements about kilobyte vs kibibyte and unit conversions (e.g., 1 kB = 1000 bytes; 1 KiB = 1024 bytes).

1.1.3 Inside a computer (Chapter 1, Section 1.3 summary):

• Major components in a desktop computer case (Table 1.2):
  • Processor (CPU): processes data, executes instructions, speed described in Hz, e.g., 1 MHz, 1 GHz.
  • Memory (RAM): stores data/instructions temporarily for quick access; volatile (lost on power down);
  • Secondary storage: large-capacity storage that persists without power; non-volatile (e.g., HDD, SSD, optical media).
  • Data bus: transports data between memory and processor; bi-directional.
  • Address bus: carries memory addresses; unidirectional (processor -> memory).
  • Input/Output: devices that feed data to the system or present results to users.
• SoC (System on a Chip): merged components in mobile devices; benefits include smaller size and lower power, but greater design complexity.
• Processor details: CPU speed (MHz, GHz); multi-core designs (dual-core, quad-core) enable parallel instruction processing. GPUs are specialized for parallel graphics calculations and increasingly used in AI workloads.
• Main memory (RAM): volatile, fast, used to store program data/instructions temporarily; memory is often expandable via RAM modules; ROM stores non-volatile critical startup data and firmware.
• Secondary storage: slower than RAM but higher capacity; primary access is via RAM to CPU via buses.
• Memory organization basics: memory is composed of many switches (bits). Byte addressing uses addresses; memory location is the byte’s address.
• DID YOU KNOW? SoC advantages vs complexity trade-offs for modern devices.

1.3.1 Processor (CPU):

• Function: executes instructions in a program. Speed is the rate of instruction execution, measured in cycles per second (Hz).
• Core concepts: multi-core designs enable parallelism; GPUs provide parallel computation for image processing and AI tasks.
• Practical definitions:
  • Execute = follow/perform an instruction.
  • Software = set of instructions to perform tasks.

1.3.2 Main Memory (RAM):

• RAM holds data and instructions temporarily for quick processor access; it is volatile (data lost on power loss).
• RAM typically resides on removable/dimm modules; some systems have fixed RAM limits.
• Read-only memory (ROM) stores data/instructions that rarely change; retains data without power; essential for startup/bootstrap.
• Memory physical reality: memory is built from many switches; eight consecutive switches form a byte; addresses identify byte locations.
• Key terms: RAM (volatile), ROM (non-volatile), volatile vs non-volatile characteristics.

1.3.3 Secondary Storage:

• Definition: non-volatile storage for large data that persists without power; slower access than RAM but cheaper and higher capacity.
• Choosing storage media factors (Figure 1.6): durability, portability, typical capacities, cost per GB, speed.
• Three main storage media types (Table 1.3):
  • Magnetic: hard disks; durable vs faster random access trade-offs; large capacities; susceptible to magnetic fields and heat.
  • Optical: DVDs; medium durability; lower capacity than magnetic/SSD; read/write via laser; more resistant to heat but susceptible to scratches.
  • Solid-State: SSDs; most durable and fastest; smallest form factors; higher cost per GB than magnetic/optical.
• Data vs address transport: memory access uses data and address buses in read/write operations.
• 1.3.3.1 Choosing storage media: factors to consider when selecting storage type for a use case.
• 1.3.3.2 Types of Storage Media (Table 1.3 details): summarized below in bullet form.

1.3.4 Data and Address Buses:

• A bus is a collection of wires acting as a data highway between components.
• Data bus: transports data to and from CPU/memory; bi-directional.
• Address bus: transports address information; uni-directional (usually from CPU to memory).
• Examples illustrate how a memory read/write occurs: address sent on address bus, data on data bus, and memory locations are updated accordingly.
• Key terms: Bi-directional (data bus), Uni-directional (address bus).

1.3.5 Input and Output Interfaces:

• Input examples: keyboard, mouse, scanners, touch screens, microphones.
• Output examples: monitors, speakers, printers.
• Interfaces provide connectors and data transfer speeds, e.g., USB, HDMI, PCI Express.
• USB: common external interfaces for powering/communicating with devices; typical connectors include USB Type A/B, Micro USB, USB-C; speeds range from USB 2.0 (480 Mbps) to USB4 (80 Gbps).
• HDMI: for audio/video to displays; versions include HDMI 1.3-1.4b (10.2 Gbit/s) and HDMI 2.0/2.1 (up to 48 Gbit/s).
• PCI Express (PCIe): internal interface for expansion cards; described by lanes (x1, x4, x8, x16); speeds roughly double with major revisions; internal speeds expressed in GB/s (e.g., PCIe 5.0: 4 GB/s per lane; 6.0: 8 GB/s; 7.0: 16 GB/s).
• Notes on connectors and typical applications.
• Figure references illustrate bus and connectors in modern computers.

DID YOU KNOW? (Chapter 1 context)

• SoC integration in mobile devices provides compact designs with lower power, often improved performance, but adds design complexity.
• Early computers lacked electricity and used mechanical components; modern computers rely on digital/binary representations.
• The Dig-Comp II example shows a mechanical computer that performs computations via marbles and ramps; illustrates data representation via switches and ramps.

Summary connections to real-world relevance:

• Understanding the hardware foundations (CPU, RAM, secondary storage, buses) helps in optimizing software performance and understanding performance bottlenecks.
• The choice of storage media affects cost, speed, durability and portability for different use cases (e.g., laptops vs servers).
• IO interfaces determine how devices connect and communicate with the system; PCIe tends to be the fastest path for internal expansion cards, while USB/HDMI serve external peripherals.

Ethical/practical implications:

• SoC design emphasizes power/size trade-offs and specialized integration; hardware choices influence device capabilities and energy consumption.
• The use of AI acceleration in GPUs has broader implications for software design and performance, including parallelizable workloads and potential shifts in software architecture.
• The content highlights the historical evolution and encourages awareness of how architecture choices affect sustainability and cost.

Chapter 2: Data Representation

• 2.1 Introduction to Data Representation: Data in computers is organized to be stored, transmitted, and manipulated by programs; understanding representations is foundational to programming and system design.
• 2.2 Understanding Number Systems and Conversion Techniques: Conversion between base systems (binary, decimal, hex) is essential, with emphasis on binary data as the native representation in modern digital devices.
• 2.3 Representing Negative Numbers: Methods such as two's complement (commonly used in modern systems) for encoding negative values.
• 2.4 Representing Text: Text encoding schemes (e.g., ASCII, Unicode) and how characters map to binary values; implications for storage and processing of text.
• Quick Checks and CHECKS (1.2, 1.3 content) illustrate unit conversions and the functions of memory components; practice problems include converting between units, arranging units by size, and performing bit-level to byte-level conversions.

Chapter 3: Logic Gates

• Boolean logic foundations: variables with values true/false; use of NOT, AND, OR, XOR, etc.
• Truth tables: show how logical expressions evaluate for all input combinations.
• Logic gates: fundamental building blocks (AND, OR, NOT, NAND, NOR, XOR) used to build complex circuits.
• Logic circuits: combining gates to implement computational functions.
• Manipulating Boolean statements and solving system problems: simplification and derivation techniques.

Chapter 4: Programming (Python)

• 4.1 Introduction to Algorithms and Programming: Programming as a method to implement algorithms; understanding problem definitions.
• 4.2 Defining Problems: translating real-world problems into computable specifications.
• 4.3 Installing Python: practical steps for setting up the environment.
• 4.4 Comments: using comments to document code.
• 4.5 Literals and Variables: basic data storage; variable naming rules and typing.
• 4.6 Functions, Methods and Operators: composing programs from reusable blocks; basic operators (+, -, *, /, etc.).
• 4.7 Data Types: integers, floats, booleans, strings, lists, dictionaries, etc.
• 4.8 Input and Output: basic I/O methods for interacting with users and systems.
• 4.9 Booleans: truth-valued logic in programs.
• 4.10 Integers and Floating-Point Numbers: numeric representations and precision considerations.
• 4.11 Strings: sequences of characters; string operations.
• 4.12 Lists: ordered collections; basic operations.
• 4.13 Dictionaries: key-value mappings.
• 4.14 Control Flow: conditionals and loops controlling program execution.
• 4.15 User-Defined Functions: encapsulating logic for reuse.
• 4.16 with Statements: context managers in Python (e.g., with open(…)) for resource management.

Chapter 5: Input Validation

• 5.1 Why Validation is Needed: inputs may come from diverse sources and may not meet requirements; validation prevents erroneous or harmful behavior.
• 5.2 Recovering from Invalid Input: two basic approaches:
  • If user input is invalid, ask for re-entry (interactive input).
  • If data came from a file and is invalid, exit gracefully (or skip problematic data).
• 5.3 Common Validation Checks (a toolkit of checks):
  • Length checks: ensure strings/lists are within required length via len(x).
  • Range checks: ensure numeric inputs fall within specified bounds using comparisons (
  • Presence checks: ensure required fields are provided (non-empty results).
  • Format checks: ensure input matches a pattern (e.g., HH:MM), often via methods like isdigit() or regex checks.
  • Existence checks: ensure input exists in a collection (using in / not in).
  • Check digits: verify numbers via a mathematical check digit algorithm to detect input errors.
• 5.3.1 Length Checks: examples including a length-3 word-guess game; discuss len() usage and loop structure to enforce length constraints.
• 5.3.2 Range Checks: converting rounded percentage scores to grades (A1–F9 mapping) with a numeric range check.
• 5.3.3 Presence Checks: ensure required inputs are provided (non-blank checks).
• 5.3.4 Format Checks: ensure inputs follow required formats (e.g., HH:MM). Example uses str.isdigit() and pattern checks.
• 5.3.5 Existence Checks: ensure an input exists in a dataset (e.g., usernames in a system).
• 5.3.6 Check Digits: UPC-A barcode check digit example; how to compute and validate a final check digit.
• 5.3.7 Quick Check examples involve applying multiple validation checks and interpreting results.
• Practical tasks include designing date validation routines with length checks, digit checks, and range validations.

Chapter 6: Testing and Debugging

• 6.1 Bugs and Debugging: definition of a bug; debugging is the process of fixing bugs to restore intended behavior. Historical anecdote: the “first actual computer bug” was a moth in the Mark II (1947).
• 6.2 Types of Program Errors:
  • Syntax errors: easy to detect; caught at compile/run time; usually fixed quickly.
  • Logic errors: program runs but outputs are incorrect; require test cases to reveal.
  • Run-time errors: errors that occur during execution (e.g., Division by zero, ValueError when converting types).
• 6.3 Designing Test Cases: test case = inputs + expected outputs; testing three kinds of conditions: normal, boundary, and error conditions; the acronym problem serves as an extended case study with multiple test cases.
• 6.4 Common Debugging Techniques:
  • Trace tables: manual or automated trace of variable values and outputs.
  • Using print statements: inject debug prints to observe variable state across execution.
  • Dry runs: hand-run the algorithm step-by-step to construct a trace table.
  • Backtracking: work backwards from a bug to identify root cause.
  • Testing Incrementally: add small changes and test frequently to isolate bugs.
  • Testing small parts of a program: isolate function behavior with targeted tests.
• Example narrative: acronym generation debugging journey through several draft versions (across 6.x) demonstrating incremental improvement (handling spaces, case conversion, validation checks, and bug fixes).
• Quick checks and review questions accompany sections 6.1–6.4 to reinforce understanding of debugging strategies and error types.

Chapter 7: Algorithm Design

• 7.1 Introduction to Algorithm Design: computational thinking for problem solving.
• 7.2 Decomposition: break problems into smaller, self-contained parts; modular approach enables reusable functions; DRY principle.
• 7.3 Generalisation: identify common features across multiple instances and extract into reusable components; solving small instances first (incremental/decomposition approach).
  • Example: mean-subject grade (MSG) calculation decomposed into scoring and grading; each part can be solved separately.
  • Incremental approach vs decomposition: update one part and combine results; use loops to extend solutions from small to large inputs.
• 7.4 Common Problems and Solutions (patterns):
  • 7.4.1 Finding min/max values in a list; optionally with indices; handling empty lists; using None for missing results.
  • 7.4.2 Sum or average of values without built-in functions; present both explicit loops and built-ins (sum()).
  • 7.4.3 Finding the location of a value (linear search); discusses in-list and in-string variants; mentions binary search for sorted data.
  • 7.4.4 Extracting values based on criteria (digits, letters, odd numbers, etc.); uses test() functions; demonstrates extraction patterns.
  • 7.4.5 Splitting a string by a delimiter without using split(): shows an explicit algorithm to identify pieces between delimiters; also discusses using Python’s split() with and without arguments.
• 7.3.2 Adapting Solutions to Similar Problems: demonstrates how to adapt a digits-extraction solution to extract letters by swapping isdigit() for isalpha(); adaptation illustrates generalization principle.
• 7.2.6 Sample problems include computing factorials, weather category classification from Fahrenheit to Celsius, and other multi-step problems that can be decomposed and gradually generalized.
• 7.3.2 Adapting solution examples show that core structure can be reused with small changes (e.g., isdigit() -> isalpha()).

Chapter 8: Software Engineering

• 8.1 Stages in Developing a Program (Waterfall model with iterative flexibility):
  • 8.1.1 Gather Requirements: determine problem, what the program should do; specify inputs/outputs; interview users; draft test cases; example: library loan/availability system; inputs (availability.txt, search title) and outputs (Available/Not Available).
  • 8.1.2 Design Solutions: plan approach using decomposition and generalisation; manually solving simple examples; choose algorithms; estimate effort; compare against existing solutions; plan using flowcharts.
  • 8.1.3 Write Code: translate algorithm into code; potential need for further refinement after initial coding; examples show drafting and refining code for availability checking.
  • 8.1.4 Test and Refine Code: run test cases, fix bugs; address whether requirements address users’ needs; iterate to refine algorithm and code.
  • 8.1.5 Deploy Code: install, train users, gather feedback; example shows librarians using the program, with feedback about usability and speed.
• 8.1.5: The process emphasizes that even after initial implementation, refinement may be needed; iterative loops are common in practice.
• 8.2 Alternative Methodologies:
  • 8.2.1 Agile Development: break large projects into smaller increments; user stories; shorter cycles (sprints); working software at each sprint; continuous feedback.
  • 8.2.2 Test-Driven Development (TDD): tests drive development; tests written before code; iterative implementation to pass tests; automation via unittest and doctest.
• 8.2: Ethical/Practical notes: AI-assisted code generation (e.g., Copilot, ChatGPT) can help, but has license/ownership concerns and can produce code that requires careful verification; potential plagiarism concerns if presented as own work; importance of decomposing problems for reliable results.

Chapter 9: Spreadsheets

• 9.1 Understanding Spreadsheets: core idea that spreadsheets support data organization and computation; not detailed in this excerpt but forms part of the curriculum.
• 9.2 Logical Operators and Functions; 9.3 Mathematical and Statistical Operators; 9.4 Text Functions; 9.5 Lookup Functions; 9.6 Date Functions; 9.7 Goal Seek; 9.8 Conditional Formatting: typical coverage of spreadsheet tasks used for data analysis and automation.

Chapter 10: Networking

• 10.1 Introduction to Computer Networks: general overview of networks and communication.
• 10.2 Types of Computer Networks: LAN, WAN, etc.; 10.3 Protocols and Error Detection; 10.4 Home Networks and the Internet: practical networking topics.

Chapter 11–14: Security/Privacy, Intellectual Property, Impact of Computing, Emerging Technologies

• 11 Security and Privacy: definitions; threats and defences; analysis of security posture.
• 12 Intellectual Property: copyright, software licenses, software piracy, copyright infringement.
• 13 Impact of Computing: industry impacts and proliferation of falsehoods.
• 14 Emerging Technologies: Artificial Intelligence and other emerging technologies; implications for future tech.

Practical/Exam-oriented notes and examples (selected highlights):

• Data and address buses example: reading from memory involves sending address on the address bus (uni-directional) and data transfer on the data bus (bi-directional). A simplified illustration is given with binary data bytes (e.g., 01001011, 10100101, etc.) to demonstrate how data moves between CPU and RAM.
• I/O interfaces table (Table 1.4) summarises USB, HDMI, PCI Express including typical applications, connectors, and max speeds. Recognises that PCIe speeds are per-lane and scale with the number of lanes (x1, x4, x8, x16) and that PCIe generally outperforms USB/HDMI for internal devices.
• Check digits and data validation examples demonstrate how to implement robust input checking, including scenarios like NRIC check digits for Singaporean IDs (and why check digits do not fully replace identity verification).
• Debugging narrative in Chapter 6 demonstrates practices including creating trace tables (Table 6.15), using print statements (Figure 6.12), backtracking (Figure 6.13), and incremental testing with draft versions of an acronym generator to illustrate how bugs are isolated and fixed.
• Algorithm design emphasizes decomposition and generalisation as strategic approaches to solving problems; examples include building a small version of a problem (e.g., mean, sums, or digits extraction) and then expanding to larger instances, while reusing logic and functions.
• The “Tools” for debugging and testing include dry runs (printed trace tables), backtracking, and incremental development to avoid large-scale untested rewrites.
• The material stresses the difference between traditional waterfall and agile/TDD approaches, highlighting benefits and trade-offs of iterative development in real-world projects.

Formulas and equations (LaTeX format):

• Data size relations and prefixes (illustrative):
  • 1 ext{ kB} = 10^{3} ext{ bytes}, \, 1 ext{ KiB} = 2^{10} = 1024 ext{ bytes}
  • 1 ext{ MB} = 10^{6} ext{ bytes}, \, 1 ext{ MiB} = 2^{20} = 1{,}048{,}576 ext{ bytes}
  • 1 ext{ GB} = 10^{9} ext{ bytes}, \, 1 ext{ GiB} = 2^{30} = 1{,}073{,}741{,}824 ext{ bytes}
  • 1 ext{ TB} = 10^{12} ext{ bytes}, \, 1 ext{ TiB} = 2^{40} = 1{,}099{,}511{,}627{,}776 ext{ bytes}
• Data bus and address bus concepts are described qualitatively; no explicit numeric formulas beyond bit/byte/bus definitions are necessary.

Connections to foundational principles and real-world relevance:

• The material connects hardware architecture to software design choices (e.g., memory hierarchy affects performance; bus bandwidth constrains IO throughput; storage media choices affect application requirements).
• It anchors practical skills such as validating input data, designing robust test cases, and applying decomposition/generalisation to software development and problem solving.
• It presents ethical considerations for software development processes (e.g., responsible use of AI-assisted code generation and the importance of accountability and licensing).

Key takeaways for exam preparation:

• Understand the roles and interconnections of CPU, RAM, and secondary storage, plus data and address buses.
• Be able to compare data units (bits/bytes, kB/KiB, MB/MiB, etc.) and perform basic size conversions, noting SI vs binary prefixes.
• Recognize the primary IO interfaces (USB, HDMI, PCIe), their connectors, and how their speeds compare.
• Distinguish between the three main types of storage media and their trade-offs in durability, portability, capacity, cost, and speed.
• Explain the differences between memory (RAM) and ROM, and the concept of volatility in memory.
• Articulate the stages of software development (gather requirements, design, code, test/refine, deploy) and the agile/TDD alternatives.
• Define and differentiate common validation checks (length, range, presence, format, existence, check digits) and apply them to example problems.
• Understand debugging techniques (print statements, trace tables, dry runs, backtracking) and the benefits of incremental testing.
• Recognize how to generalize solutions from small instances to large inputs, and how to adapt existing solutions to related problems (e.g., digits extraction to letters extraction).
• Appreciate practical implications of system design choices for real-world applications (laptops, servers, mobile SoCs) and the importance of security/licensing in software development.

Notes on formula formatting in exams: When including mathematical expressions in your study notes, represent them using LaTeX within double dollar signs, e.g., a^2 + b^2 = c^2. For inline math, use … as appropriate in context.

Title: O-Level Computing Notes (Fourth Version, 2024)