What you'll learn
A computer is a stack of layers: logic gates at the bottom, a processor built from them, memory feeding that processor, and software sitting on top telling it what to do. This topic covers all of it. By the end of this guide you should be able to classify hardware and software, name the registers of the CPU and say what each holds, work through the fetch–decode–execute cycle in order, explain why clock speed, cores and cache all affect performance, distinguish RAM from ROM and cache from virtual memory, choose the right secondary storage for a purpose, and evaluate a Boolean expression or build its truth table from scratch.
Key terms and definitions
Hardware — The physical components of a computer system.
Software — The programs and data that tell the hardware what to do.
System software — Software that manages the computer itself, such as the operating system and utilities.
Application software — Software that performs a task for the user, such as a spreadsheet or a browser.
CPU — The central processing unit, which fetches, decodes and executes instructions.
ALU — The arithmetic logic unit, which performs calculations and logical comparisons.
Program Counter (PC) — The register holding the address of the next instruction to be fetched.
MAR — The memory address register, holding the address being read from or written to.
MDR — The memory data register, holding the data or instruction fetched from that address.
Accumulator (ACC) — The register holding the result of calculations performed by the ALU.
Volatile — Describes memory that loses its contents when power is removed.
Truth table — A table listing the output of a logic expression for every possible combination of its inputs.
Core concepts
Hardware and software
Hardware is everything you could drop; software is everything you could copy. The distinction matters because the two are replaceable independently: the same program can run on different machines, and the same machine can run different programs. That flexibility is not an accident of design — it follows directly from the stored program idea discussed below.
System and application software
System software looks after the machine. The operating system manages memory, files, peripherals, user accounts and the sharing of processor time between programs, and it hides the hardware from everything above it. Utility software maintains the system's condition: defragmenters, backup tools and virus scanners all belong here. Application software exists to serve the user's purpose instead — word processors, spreadsheets, browsers, games.
A useful test: if the program would still be needed on a computer that never did any work for anybody, it is system software.
The CPU and its registers
The CPU contains the ALU, which does the arithmetic and the logical comparisons, the control unit, which coordinates everything, and a small set of very fast storage locations called registers. Four registers matter for this course:
- The Program Counter holds the address of the next instruction.
- The MAR holds the address currently being accessed in memory.
- The MDR holds the data or instruction found at that address.
- The Accumulator holds the result of the ALU's work.
The MAR and MDR are the pair students most often confuse. One names a place; the other carries what was found there. Swapping them makes the whole cycle incoherent.
The fetch–decode–execute cycle
- Fetch — The address in the Program Counter is copied into the MAR. The contents of that memory location travel back along the data bus into the MDR. The Program Counter is incremented so it points at the next instruction.
- Decode — The control unit works out what the instruction in the MDR means and what data it needs.
- Execute — The instruction is carried out, with any result placed in the Accumulator.
The cycle then repeats, millions of times a second. A jump instruction works by overwriting the Program Counter with a new address rather than letting it simply increment — and that single mechanism is how loops, branches and subroutine calls are all implemented.
Von Neumann architecture
In the von Neumann or stored program model, instructions and data share the same memory and travel along the same bus. The benefit is enormous flexibility: because a program is just data sitting in memory, a computer can run any program without being physically rewired. The cost is the von Neumann bottleneck — an instruction and its data cannot be fetched at the same instant, so the processor spends time waiting on memory rather than computing.
What affects CPU performance
Clock speed sets how many cycles happen per second, so a higher speed means more instructions processed. Number of cores adds genuinely parallel processing units — but extra cores only help where work can actually be divided, which is why video editing benefits enormously and some older software barely notices. Cache size reduces the time spent waiting for main memory.
Memory: RAM, ROM, cache and virtual memory
RAM is volatile main memory holding the programs and data currently in use. ROM is non-volatile and holds the start-up instructions the machine needs before it can load anything else.
Cache is a small amount of very fast memory on or beside the processor, holding recently and frequently used instructions and data. It is much smaller than main memory, not larger — the speed comes partly from that small size and its position.
Virtual memory is an area of secondary storage used as though it were extra RAM. It lets a machine run programs needing more space than the installed RAM, and because secondary storage is orders of magnitude slower, relying on it heavily makes everything sluggish. A computer that crawls with several large programs open is usually short of RAM, not short of processor.
Secondary storage
Magnetic storage (hard disks) offers very large capacity at the lowest cost per gigabyte, with moving parts that are vulnerable to knocks. Solid state storage has no moving parts, so it is fast, silent, low-power and robust, at a higher cost per gigabyte. Optical discs are cheap to produce in quantity and hold only gigabytes each, which suits distributing many read-only copies. The right choice depends on what the task actually values: speed, capacity, cost, portability or durability.
Embedded systems
An embedded system is a computer built into a larger device to perform one dedicated task — a washing machine controller, a central heating timer. Because the job never changes, the system can be small, cheap, low-power and highly reliable.
Boolean logic: the three gates
All processing reduces to three operations.
NOT inverts its single input:
| P | NOT P |
|---|---|
| 0 | 1 |
| 1 | 0 |
AND outputs 1 only when every input is 1:
| P | Q | P AND Q |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
OR outputs 1 when at least one input is 1:
| P | Q | P OR Q |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
AND is the strict operator and OR the permissive one. NOT is the only one taking a single input.
Truth tables and combined expressions
A truth table is exhaustive, which is what makes it a proof rather than a sample: once every input combination is listed, the behaviour is completely described. The number of rows doubles with each extra input — two inputs need 4 rows, three need 8, four need 16.
When an expression combines gates, work outwards from the brackets, taking one gate at a time and giving each its own column.
Worked examples
Example 1: Evaluating a logic expression
Evaluate (P OR Q) AND NOT R when P = 1, Q = 0 and R = 1.
P OR Q is 1 OR 0 = 1. NOT R inverts 1 to give 0. That leaves 1 AND 0, and AND requires both inputs to be true, so the output is 0. Note that the brackets fix the order of evaluation, so the answer does not depend on how a circuit happens to be arranged.
Example 2: Building a truth table
Complete the truth table for (P OR Q) AND NOT R. Three inputs means 2³ = 8 rows.
| P | Q | R | P OR Q | NOT R | Output |
|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 1 | 0 |
| 0 | 0 | 1 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 | 1 |
| 0 | 1 | 1 | 1 | 0 | 0 |
| 1 | 0 | 0 | 1 | 1 | 1 |
| 1 | 0 | 1 | 1 | 0 | 0 |
| 1 | 1 | 0 | 1 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 | 0 |
The output is 1 in exactly three rows. Reading the pattern: the expression needs at least one of P and Q to be 1 and R to be 0.
Example 3: MAR and MDR during the fetch stage
The Program Counter holds 104. Describe the fetch.
104 is copied into the MAR. The contents of memory location 104 — the instruction itself — travel back into the MDR. The Program Counter is incremented to 105, ready for next time. The MAR held an address and the MDR received what was stored at it; neither ever holds both.
Example 4: Choosing storage for a purpose
A business must archive 40 TB of records that will rarely be read but must be kept cheaply for ten years.
Magnetic storage is correct. The data is rarely read, so access speed is nearly worthless here and cost per gigabyte is what matters. Solid state would work but costs far more for no benefit the task values; optical discs hold only gigabytes each, so 40 TB would need thousands; and RAM is volatile and would lose everything at power-down.
Common mistakes and how to avoid them
The commonest error is swapping the MAR and the MDR. The MAR holds an address, the MDR holds the contents of that address. Say "address" and "data" aloud as you write.
Do not claim ROM is volatile. RAM loses its contents when power is removed; ROM does not, which is why start-up instructions live there.
Cache is smaller than main memory, not bigger. Its advantage is speed and position, and that advantage depends partly on its small size.
With Boolean expressions, work outwards from the brackets and give each gate its own column. Applying a NOT to the whole expression instead of the single variable it belongs to is the usual source of lost marks.
Remember that more cores do not simply multiply performance. The work has to be divisible, and a task whose each step depends on the previous one cannot be split.
Finally, virtual memory is slower than RAM, not faster. It exists to let large programs run at all, not to run them quickly.
Exam technique for "Computer Systems"
Learn the four registers and one phrase for each. Questions on the fetch–decode–execute cycle are usually marked per correct step in the correct order, so number your steps and keep them in sequence rather than writing a paragraph.
For logic questions, always draw the table even when only one value is asked for — the intermediate columns earn method marks and stop you losing track of a NOT. Count the rows first using 2 to the power of the number of inputs, so you know how many you need before you start.
When asked to choose a storage medium or justify a performance upgrade, name the property the task actually values (capacity, speed, cost, portability, durability) and tie your answer to it. An answer that says "solid state because it is fastest" earns little if the scenario never needed speed.
Quick revision summary
- Hardware is physical; software is the programs. System software manages the machine; application software serves the user.
- The CPU holds the ALU, the control unit and registers: PC (next address), MAR (address being accessed), MDR (data found there), ACC (calculation result).
- The cycle is fetch → decode → execute; a jump overwrites the Program Counter instead of incrementing it.
- Von Neumann: instructions and data share one memory and one bus — flexible, but a bottleneck.
- Performance depends on clock speed, cores (only if work divides) and cache size.
- RAM is volatile main memory; ROM is non-volatile; cache is small and fast; virtual memory is disk pretending to be RAM and is much slower.
- Storage: magnetic = cheap capacity, solid state = fast and robust, optical = cheap read-only copies.
- AND needs every input to be 1; OR needs at least one; NOT inverts.
- A truth table needs 2ⁿ rows for n inputs, and work goes outwards from the brackets.