Assembly language is a low-level programming language that uses short human-readable mnemonics — like LDA, ADD, and STA — to represent individual CPU instructions. Unlike high-level languages such as Python, each assembly instruction maps directly to a single machine-code operation, giving the programmer precise control over the processor and memory.
What is the difference between assembly language and machine code?
At the lowest level, a CPU understands only machine code — binary instructions such as 10000101 00000001. Machine code is directly executable but impossible for humans to write or read reliably.
Assembly language is one step above: each mnemonic represents one machine-code instruction. An assembler program translates assembly mnemonics into the binary machine code the CPU actually runs.
| Level | Example | Readable? | Directly executable? |
|---|---|---|---|
| Machine code | 10000101 00000001 |
Very hard | Yes |
| Assembly language | LDA 1 |
Easier | No — needs assembling |
| High-level language | x = a + b |
Easy | No — needs compiling or interpreting |
Assembly sits between machine code and high-level languages — closer to the hardware than Python, but closer to human language than raw binary.
What is the Little Man Computer (LMC)?
At GCSE, assembly language is typically taught using the Little Man Computer (LMC) — an educational model of a simple processor developed by Dr Stuart Madnick in 1965. The LMC has:
- 100 memory locations (numbered 00–99), each holding a three-digit value.
- An accumulator register for arithmetic operations.
- A program counter that tracks which instruction to execute next.
- A simplified instruction set of nine mnemonics.
The LMC model is used by AQA in its GCSE Computer Science specification and by many UK exam boards as a concrete, tractable way to teach assembly concepts without the complexity of a real processor's instruction set.
What are the LMC instruction mnemonics?
| Mnemonic | Operation | Effect |
|---|---|---|
INP |
Input | Accept a value from the user and load it into the accumulator |
OUT |
Output | Display the current value in the accumulator to the user |
LDA address |
Load | Copy the value at the memory address into the accumulator |
STA address |
Store | Copy the value in the accumulator to the memory address |
ADD address |
Add | Add the value at the memory address to the accumulator |
SUB address |
Subtract | Subtract the value at the memory address from the accumulator |
BRA address |
Branch always | Jump to the instruction at the given address unconditionally |
BRZ address |
Branch if zero | Jump to the given address only if the accumulator = 0 |
BRP address |
Branch if positive | Jump to the given address only if the accumulator ≥ 0 |
HLT |
Halt | Stop the program |
DAT value |
Data | Reserve a memory location and optionally give it an initial value |
Worked example: add two numbers
Task: Accept two numbers from the user, add them, and output the result.
INP // Input first number → accumulator
STA num1 // Store accumulator in memory location 'num1'
INP // Input second number → accumulator
ADD num1 // Add 'num1' to accumulator (accumulator = num1 + num2)
OUT // Output the accumulator (the sum)
HLT // Stop
num1 DAT // Reserve a memory location labelled 'num1'
Trace through (user inputs 7, then 5):
| Step | Instruction | Accumulator | num1 | Output |
|---|---|---|---|---|
| 1 | INP | 7 | — | — |
| 2 | STA num1 | 7 | 7 | — |
| 3 | INP | 5 | 7 | — |
| 4 | ADD num1 (7 + 5) | 12 | 7 | — |
| 5 | OUT | 12 | 7 | 12 |
| 6 | HLT | — | — | — |
The program correctly outputs 12. Labels (like num1) make assembly programs readable — the assembler replaces them with actual memory addresses.
How does branching create loops in assembly?
The branch instructions (BRA, BRZ, BRP) are how assembly programs implement loops and conditional logic — the equivalent of while loops and if statements in Python.
Example: count down from 3 to 1 and halt
LDA three // Load 3 into accumulator
loop STA count // Store current count
OUT // Output it
LDA count
SUB one // Subtract 1
BRP loop // If result ≥ 0, loop back
HLT
three DAT 3
one DAT 1
count DAT
The BRP loop instruction causes the program to jump back to loop as long as the accumulator is non-negative (≥ 0). When the subtraction produces a negative result, the branch is not taken and execution falls through to HLT.
Frequently asked questions
Why is assembly language important if we have Python?
Assembly language is important for two reasons at GCSE. First, it teaches how a CPU actually works — the fetch–decode–execute cycle, registers, and memory addressing become concrete when you write the instructions yourself. Second, embedded systems (microcontrollers in washing machines, car engines, medical devices) sometimes use assembly because it gives maximum speed and minimum memory usage. High-level languages abstract these details away, which is excellent for most programming but unhelpful when you need to understand what is happening at the hardware level.
How is assembly language different from Python?
Python is a high-level language: one Python statement (x = a + b) may translate into dozens of machine-code instructions; the interpreter handles memory, variable names, and data types automatically. Assembly is a low-level language: each instruction does exactly one thing (load, store, add), and the programmer must manage all memory locations manually. Python is far quicker to write; assembly gives far more control over exactly what the CPU does.
Do I need to write assembly programs from scratch in the GCSE exam?
At AQA GCSE Computer Science, students need to be able to trace through simple LMC programs (determining what they output for given inputs) and to write short programs using the LMC instruction set. OCR uses a similar simplified assembly language. You will not be asked to write complex programs; the focus is on understanding the fetch–decode–execute cycle, how registers and memory work, and how simple control structures (branching and looping) are implemented at the lowest level.
What is a register in the context of assembly language?
A register is a tiny, extremely fast storage location built directly into the CPU. The LMC's accumulator is a register — it holds the value the CPU is currently working with. Real processors have many registers (general-purpose registers like R0–R15 in ARM assembly, plus specialised ones like the program counter and status register). Assembly language instructions operate on registers, not on variables with names as in Python. Understanding registers is central to understanding how the CPU executes fetch–decode–execute cycles.
For Socratic GCSE Computer Science tutoring on assembly language, CPU architecture, and low-level programming, visit aitutors.me.