HookThe master's thesis that built every processor
In 1937 a 21-year-old MIT student named Claude Shannon submitted a master's thesis that a later historian would call the most important of the century. Shannon had noticed that the true/false logic George Boole formalised in 1854 mapped perfectly onto electrical switching circuits: a switch is on or off, a proposition is true or false, and the algebra that simplifies one simplifies the other. It meant arithmetic and decision-making could be built out of nothing but switches wired to obey Boolean algebra — the idea every processor since has been made of, first with relays, then valves, then the billions of transistors on a modern chip.
That insight is the spine of this section, because a computer is a stack of layers, each hiding the one below it. At the bottom, logic gates turn Boolean expressions into physical circuits. Above them sits the hardware; above that, the system software and the operating system that manage it; above that, the translators that turn human-written code into instructions the hardware can run; and at the very top, the application you actually wanted to use. The exam asks you to see the whole stack at once and, for full marks, to move fluently between a truth table, the Boolean expression it describes and the gate circuit that implements it — three views of one thing.
ModelHardware, software and how they classify
Hardware is the physical components of a computer; software is the programs that tell those components what to do. The relationship is one of mutual dependence: hardware without software is inert, and software cannot run without hardware to execute it, so the two are designed as a pair. Software divides first into two classes. Application software performs a task the user cares about directly — a browser, a spreadsheet, a game, a photo editor. System software exists to run and manage the computer itself, and the user rarely sets out to interact with it.
System software has several categories worth naming. The operating system is the central one. Utility programs carry out maintenance jobs such as disk defragmentation, file compression, backup and antivirus scanning. Library programs are ready-written, tested, reusable blocks of code that other programs call on rather than reinventing. And the translators — compilers, interpreters and assemblers — convert program code from one form into another. The distinction is examined because candidates routinely miscategorise: a device driver is system software, a photo editor is application software, and a compiler is a translator rather than an application, even though all three are undeniably programs.
ModelThe operating system as resource manager
The operating system is the software layer sitting between applications and hardware, and its central job is resource management — sharing finite hardware among competing demands so that no individual program has to know the physical details. Processor scheduling decides which process runs next and for how long, creating the illusion that many programs run at once on a single processor by switching between them many times a second. Memory management allocates main memory to processes, stops them overwriting one another, and uses virtual memory — backing store standing in for RAM — when physical memory runs short.
Beyond those two, the operating system handles input and output through device drivers, manages the file system (the logical structure of folders and files laid over physical storage), responds to interrupts raised by hardware needing attention, provides a user interface, and enforces security through user accounts and permissions. The unifying idea is abstraction: an application simply says save this file and the operating system translates that request into the specific sector writes the particular drive requires, which is why the same program runs unchanged on machines with completely different hardware underneath.
ModelClassifying programming languages
Programming languages are classified by how close they sit to the hardware. Low-level languages map directly onto the processor. Machine code is the rawest form: binary instructions the processor executes directly, specific to one processor family and essentially unreadable to humans. Assembly language is one step up — mnemonics such as ADD, LDA and STA standing in for those binary instructions, with a broadly one-to-one relationship between an assembly instruction and a machine-code instruction — but it is still tied to a particular processor architecture.
High-level languages such as Python and Java are written closer to English, are portable across different processors and hide the hardware entirely. A single high-level statement typically becomes many machine-code instructions — a one-to-many relationship. Most high-level languages are imperative: they describe a sequence of commands that change the program's state, which is the paradigm the A-level treats as the default. The trade-off is the recurring one in this topic: low-level code can be faster, more compact and able to address specific hardware directly, while high-level code is far quicker to write, easier to read and debug, and will run on any machine that has a suitable translator.
MechanismTranslators: assembler, compiler, interpreter
Because a processor runs only machine code, every program not already written in machine code needs a translator, and the specification names three. An assembler converts assembly language into machine code, essentially one instruction at a time. A compiler translates an entire high-level program into machine code in one go, producing a standalone executable; the translation is slow and reports all errors together at the end, but the resulting program runs fast, needs no translator present to run, and keeps its source code private. An interpreter translates and executes the program one statement at a time, every time it runs; it stops at the first error it reaches, which makes it excellent for development and debugging, but it runs more slowly and requires the interpreter to be installed on every machine that runs the program.
Some systems combine the two: Java compiles to intermediate bytecode that a virtual machine then interprets, buying portability across any device that has the virtual machine. The exam almost always frames this as a choice — which translator suits which situation — so tie each property to a scenario rather than reciting a list of features in the abstract.
A worked comparison for a common exam scenario. You are shipping finished commercial software to paying customers: choose a compiler, because it produces a fast standalone executable, hides your source code from the customer, and the one-off slow translation is irrelevant once the product is built. Now suppose you are a learner debugging a script and want to see exactly where it fails: choose an interpreter, because it runs line by line and halts at the first error, so you locate the fault quickly and re-run instantly without waiting for a full recompile. The same program, opposite best tools — and stating why for the specific context given is what separates a two-mark answer from a four-mark one.
ModelLogic gates and truth tables
A logic gate is a circuit that takes one or more binary inputs and produces one binary output according to a Boolean rule, and everything a processor does is built from a handful of them. NOT inverts its single input. AND outputs 1 only when all its inputs are 1. OR outputs 1 when at least one input is 1. XOR (exclusive OR) outputs 1 only when its inputs differ. NAND and NOR are AND and OR each followed by a NOT, and NAND alone is functionally complete — any logic circuit whatsoever can be built from NAND gates only. A truth table lists the output for every possible combination of inputs, and a circuit with n inputs has 2ⁿ rows.
Gates are drawn with standard symbols and wired together into circuits; reading a circuit means working from the inputs through each gate to the output, building the truth table one column at a time. The A-level regularly asks you either to complete the truth table for a small given circuit, or to draw the circuit that implements a given Boolean expression — so practise moving in both directions between the diagram, the table and the algebra.
Build the truth table for a half-adder, the circuit that adds two single bits A and B and produces a Sum and a Carry. The sum bit is 1 when the inputs differ, which is exactly XOR; the carry bit is 1 only when both inputs are 1, which is exactly AND. So Sum = A XOR B and Carry = A AND B.
With A = 0, B = 0: Sum 0, Carry 0. With A = 0, B = 1: Sum 1, Carry 0. With A = 1, B = 0: Sum 1, Carry 0. With A = 1, B = 1: Sum 0, Carry 1. Read that last row as a binary number: 1 + 1 = 10, a sum bit of 0 and a carry of 1. Chain two of these together so that one adder's carry feeds into the next and you can add multi-bit numbers — which connects this section straight back to the binary arithmetic of data representation.
ModelBoolean algebra and simplification
Boolean algebra is the set of laws for manipulating logic expressions, written with A.B for AND, A+B for OR and a bar (or the word NOT) for negation. The point of it is simplification: a simpler expression is a smaller, cheaper, faster circuit, so reducing an expression before it is manufactured saves real hardware and power. The laws you are expected to apply include commutation and association (which behave as in ordinary algebra), distribution (A.(B+C) = A.B + A.C), absorption (A + A.B = A), double negation (NOT NOT A = A), and the two most heavily tested, De Morgan's laws: NOT(A.B) = (NOT A) + (NOT B), and NOT(A+B) = (NOT A).(NOT B). De Morgan's is the tool for pushing a negation through a bracket and for converting between AND-forms and OR-forms of an expression.
A simplification answer should name each law as you use it and show the expression after every step, because in the exam the method earns the marks just as much as the final simplified expression does — a correct end result with no working is a fragile answer.
Simplify A.B + A.(NOT B). Factor out the common A using the distributive law to get A.(B + NOT B). Now B + NOT B is always 1, because a value is either true or its negation is, so the bracket collapses to 1, leaving A.1, and anything ANDed with 1 is itself — so the whole expression reduces to A. A four-gate expression has become a single wire.
As a second, apply De Morgan's law to NOT(A + B): the negation splits across the bracket and the OR becomes an AND, giving (NOT A).(NOT B). That is the standard move whenever a NOT sits outside a bracket, and writing the named law beside each step — distribution, then the identity B + NOT B = 1 — is exactly what the mark scheme is looking for.
VocabularyKey terms the mark scheme pays for
TrapsMisconceptions that cost marks
ExamWhat examiners want
Computer systems is assessed on the written Paper 2 (7517/2). The logic content is the most predictable source of marks on the whole paper, so treat it as guaranteed points: complete truth tables carefully, because a mark is typically awarded per correct output column or per correct row, and a single mis-copied intermediate value cascades into several wrong rows. When simplifying a Boolean expression, name each law as you apply it — distribution, absorption, De Morgan's — and write the expression out after every step, since the method attracts the marks and a bare final answer is easy to lose credit on. Practise moving in both directions: expression to circuit diagram and diagram back to truth table.
Match the answer to the assessment objective. AO1 questions ('state', 'describe') want precise definitions and correct categories — a device driver is system software, a compiler is a translator not an application — so do not blur them. AO2 and AO3 questions ('justify', 'compare', 'recommend') almost always hinge on a context: choose a compiler for shipped commercial software and an interpreter for debugging, choose a low-level language for a driver and a high-level one for a portable app, and always give the reason tied to that scenario rather than a generic list. For operating-system questions, structure the answer around resource management — scheduling, memory, input/output, files, interrupts, security — and explain how abstraction lets one program run on many different hardware configurations, which is the point examiners most often reward.