Part two of my June 2025 Paper 1 (9618/12) walkthrough, covering three skills-based topics: assembly language and addressing modes, logic circuits and truth tables, and data communication. These reward method and precise definitions, so here's how to think about each.
📄 The original paper and mark scheme are on the Cambridge International past papers page. Questions below are paraphrased and explained in my own words, with my own examples.
Assembly language & addressing modes
One question asked candidates to translate a short assembly sequence into machine code and to explain the immediate, direct and indirect addressing modes.
The fundamentals. Assembly is a low-level language that uses mnemonics (like LDM, ADD, STA) in place of raw machine code. Each instruction is built from an opcode (the operation to perform) and an operand (the value, address or register it acts on). When you translate to machine code, each mnemonic maps to its opcode and the operand follows.
The key misconception: assuming the operand is always a data value. It isn't — what it means depends on the addressing mode, and that's the heart of this topic:
| Mode | What the operand is | Example (my own) |
|---|---|---|
| Immediate | The actual value to use | LDM #20 loads the number 20 straight into the accumulator |
| Direct | A memory address; use the contents of that address | LDD 50 loads whatever is stored at address 50 |
| Indirect | A pointer — the address of the address holding the data | LDI 50 reads address 50, finds another address there, and loads the data from that location |
The # symbol is your signal for immediate addressing; without it, the number is an address. Spotting that distinction is what earns the marks.
✏️ Practice it: "Using your own value, explain the difference in what gets loaded into the accumulator byLDM #30versusLDD 30."
Logic circuits & truth tables
Another question asked candidates to draw a logic circuit from a Boolean expression, complete its truth table, then explain the communication modes and define a protocol.
Logic gates process binary inputs: AND (output 1 only if all inputs are 1), OR (1 if any input is 1), NOT (inverts), plus NAND, NOR and XOR (1 only when inputs differ). To draw a circuit from an expression, work outwards from the brackets — each operator becomes a gate, and the output of one gate feeds the next.
Building the truth table: list every combination of inputs first. For 2 inputs that's 4 rows; for 3 inputs it's 8 (2ⁿ rows for n inputs). Work each gate's output column by column, left to right, until you reach the final output. The common slip is missing input combinations or evaluating gates out of order — be systematic.
✏️ Practice it: "Write the full truth table for the expression X = (A AND B) OR (NOT C). How many rows should it have, and why?"Data communication
The same question covered serial vs parallel, the three transmission modes, and the definition of a protocol.
Serial vs parallel. Serial sends one bit at a time down a single line; parallel sends several bits simultaneously down multiple lines. The misconception to avoid is "serial is slow, parallel is fast" — over long distances parallel actually suffers from skew (bits arriving slightly out of step) and crosstalk, which is exactly why high-speed long-distance links (USB, SATA, networking) are serial.
The three transmission modes are about the direction of data flow:
| Mode | Direction | Example |
|---|---|---|
| Simplex | One way only | Keyboard → computer |
| Half-duplex | Both ways, but one at a time | Walkie-talkies |
| Full-duplex | Both ways at the same time | A phone call |
A communication protocol is a set of agreed rules governing how devices exchange data — covering things like data format, transmission speed, and error checking. Without shared rules the two ends can't reliably interpret each other's signals.
✏️ Practice it: "Give one real device that uses half-duplex communication and one that uses full-duplex, and explain why each suits its mode."
Quick recap
- Assembly: instructions are opcode + operand, and addressing mode decides whether the operand is a value (immediate,
#), an address (direct), or a pointer (indirect). - Logic circuits: build outwards from the expression, and list all 2ⁿ input combinations when completing a truth table.
- Communication: serial isn't automatically slower (parallel skews over distance); know simplex/half-duplex/full-duplex and that a protocol is the shared rule set.
