This mini-lesson covers AQA 4.6 — Fundamentals of computer systems: what software actually is, how source code becomes machine code, and the Boolean algebra that every circuit in the machine is built from.
Work through each screen, answer the questions as you go (some are recall, some are calculations you must actually work out) and collect ⭐ stars. Press Start when you're ready.
Hardware is the physical machinery. Software is the set of programs that tells it what to do — and it comes in two families:
The operating system sits between hardware and applications and hides the hardware's complexity. Its jobs:
Abstraction again: an application says "write this file". It does not know, and must not need to know, whether the storage is an SSD, a hard disk or a network share. The OS provides that abstraction.
Languages sit on a ladder from the machine's world to the human's:
| Level | What it looks like | Portable? |
|---|---|---|
| Machine code | Raw binary opcodes and operands | No — tied to one processor |
| Assembly language | Mnemonics: LDR, ADD, STR — one line = one machine instruction | No — processor-specific |
| High-level (imperative) | Python, Java, C# — one line becomes many machine instructions | Yes — recompile for a new machine |
Imperative high-level languages describe how to solve the problem, as a sequence of commands changing the program's state. (Declarative and functional languages instead describe what the answer is.)
Why write assembly at all? Only where you need absolute control of timing, of specific registers or of hardware — device drivers, embedded controllers, tight real-time loops. The price is that the code is unportable, slow to write and hard to maintain.
| Compiler | Interpreter | |
|---|---|---|
| When | Translates the whole program before it runs | Translates and executes one statement at a time, every time |
| Output | An executable object file | None — nothing is saved |
| Speed of running | Fast — already machine code | Slow — re-translates each pass of a loop |
| Errors | Reports all errors at the end of compilation | Stops at the first error it reaches |
| Source code | Not needed to run the executable | Needed every time, plus the interpreter itself |
| Best for | Shipping finished software | Developing and debugging; cross-platform scripting |
An assembler is a third kind: it translates assembly language to machine code, essentially one-to-one — one mnemonic becomes one instruction.
Bytecode: Java compiles once to platform-independent bytecode, which a virtual machine then interprets (or JIT-compiles) on any device. That is how "write once, run anywhere" works — you get the portability of an interpreter with much of the speed of a compiler.
| Gate | Notation | Output is 1 when… |
|---|---|---|
| NOT | Ā | the input is 0 |
| AND | A · B | both inputs are 1 |
| OR | A + B | at least one input is 1 |
| XOR | A ⊕ B | the inputs differ |
| NAND | A · B with a bar | not both inputs are 1 |
| NOR | A + B with a bar | neither input is 1 |
A truth table with n inputs has 2ⁿ rows — you must list every combination.
NAND is universal: every other gate can be built from NAND gates alone (and likewise from NOR alone). Chip fabrication exploits this — one gate type, mass produced, wired into everything.
Circuits are simplified algebraically. Fewer gates means cheaper, faster, cooler silicon.
| Law | Identity |
|---|---|
| Identity | A · 1 = A A + 0 = A |
| Null | A · 0 = 0 A + 1 = 1 |
| Idempotent | A · A = A A + A = A |
| Complement | A · Ā = 0 A + Ā = 1 |
| Absorption | A + (A · B) = A A · (A + B) = A |
| Distributive | A · (B + C) = A·B + A·C |
| De Morgan | NOT(A · B) = Ā + B̄ NOT(A + B) = Ā · B̄ |
De Morgan in words: break the bar and change the sign. NOT(A AND B) is the same as (NOT A) OR (NOT B).
A·B + A·B̄
= A · (B + B̄) distributive
= A · 1 complement law
= A — the value of B is irrelevant. Two gates become none.
A Karnaugh map simplifies a Boolean function visually. Cells are arranged in Gray code order (00, 01, 11, 10) so that any two adjacent cells differ in exactly one variable.
The rules:
F = 1 for the minterms 000, 001, 100, 101 (in ABC order).
In every one of those four rows, B = 0, while A and C each take both values.
A and C vary, so both are eliminated. F = NOT B — a three-variable expression collapses to a single inverter.
Why Gray code matters: if adjacent cells differed in two variables, grouping them would not eliminate anything. The whole method depends on that one-bit-at-a-time ordering.
A half adder adds two bits:
It cannot accept a carry in, so it is useless beyond the least significant bit. A full adder takes three inputs — A, B and Cᵢₙ — and produces Sum and Cₒᵤₜ:
Chain n full adders, carry-out to carry-in, and you have an n-bit ripple-carry adder — the arithmetic heart of the ALU.
A D-type flip-flop is a sequential circuit: its output depends on its inputs and on its stored state. On the rising edge of the clock, whatever is on D is captured on Q and held there until the next edge.
This is memory. A flip-flop stores one bit indefinitely. Put 64 side by side and you have a register; put millions together and you have SRAM cache. The clock is what turns a lump of combinational logic into a machine that can remember.
Tap an item, then tap the group it belongs to.
Tap an item on the left, then its partner on the right.
Software: system (OS, utilities, translators) vs application (general, special, bespoke)
OS roles: scheduling · memory management · file management · peripherals · security · user interface
Languages: machine code → assembly (one-to-one) → high-level imperative (one-to-many)
Translators: compiler = whole program, executable, all errors · interpreter = line by line, first error · assembler = one-to-one
Gates: NOT · AND · OR · XOR · NAND · NOR · truth table has 2ⁿ rows · NAND is universal
Boolean: A·B + A·B̄ = A · absorption A + A·B = A · De Morgan: NOT(A·B) = Ā + B̄, NOT(A+B) = Ā·B̄
Circuits: half adder: Sum = A ⊕ B, Carry = A·B · full adder adds Cᵢₙ · flip-flop stores one bit
That is the whole of AQA 4.6. Press Finish to see your score.
You've worked through Fundamentals of computer systems for AQA A-level Computer Science (7517). 🎉
Your stars: 0 / 0
Next: test yourself in the Evaluate stage Confidence Quiz, then lock it in with Verify.