Notes · Computer ScienceUK · A-Levels

Fundamentals of computer systems

This chapter connects the software a programmer writes to the electronics that runs it. It classifies hardware and software and the operating system's role, distinguishes machine code, assembly and high-level languages and their translators, and then descends to the logic level: the six logic gates, the laws of Boolean algebra and how to simplify expressions, and the combinational and sequential circuits - the half and full adder and the flip-flop - from which a processor's arithmetic and memory are built.

5 sections~16 min reading time3 competenciesLevel Foundation 1 · Standard 2 · Advanced 2

T·0666 / 14

Exam profile

AO1 · Know the hardware/software classification, the operating system's roles, translators, the logic gates and Boolean laws, and adder and flip-flop circuitsAO2 · Complete truth tables, simplify Boolean expressions and design and analyse combinational logicAO3 · Evaluate the choice of translator and the design of a logic circuit

Operators:classifyexplaincompletesimplifydesigncompare

basic level

AS-Level expects hardware/software classification, translators, the logic gates and simple truth tables.

higher level

The full A-Level adds Boolean algebra and simplification (including De Morgan's laws), the half and full adder, and the D-type flip-flop as a single-bit store.

Depth

Text

Contents · 5 sections

Fundamentals of computer systems

Hardware, software and the operating system#

FoundationAQA 7517 4.6.1DfE GCE Computer Science - systems

Hardware is the physical components of a computer - processor, memory, storage, input and output devices - and software is the set of programs that tell the hardware what to do. Software divides into two classes. System software manages and maintains the computer itself: the operating system, utility programs (backup, compression, antivirus), library routines and the language translators. Application software is the programs that do useful work for the user: word processors, browsers, spreadsheets, games. The key discriminator is whom the software serves - the machine (system) or the user's task (application).

The operating system (OS) is the central piece of system software and acts as an intermediary between applications and hardware, providing services so that programs need not deal with hardware directly. Its principal roles are process (CPU) management - scheduling which program runs when and giving the illusion of several running at once; memory management - allocating memory to processes and, through virtual memory, letting programs use more than the physical RAM; file management - organising storage into files and folders; device (I/O) management - controlling peripherals through device drivers; and providing a user interface and security (accounts, permissions).

By managing these resources the OS provides abstraction and resource sharing: an application asks to 'open a file' or 'draw on the screen' without knowing which disk or graphics chip is fitted, and many programs and users share one machine safely and fairly. This is a concrete example of the layered abstraction that runs through the subject - applications sit on the OS, which sits on the hardware, each layer hiding the complexity of the one below.

Utility software performs specific housekeeping tasks that keep the system healthy - disk defragmentation, file compression, backup, and virus scanning - and is usually considered system software because it maintains the computer rather than doing the user's work. Distinguishing system from application software, and stating the OS's management roles precisely, are common AO1 marks.

Typical mistakes

Calling the operating system 'application software', or classing a utility (backup, antivirus) as an application rather than system software.
Listing only the user interface as the OS's job while omitting process, memory, file and device management.

Active revision

State whether each is system or application software and justify it: a web browser, a device driver, a disk defragmenter, a spreadsheet. Then describe two roles the operating system performs when two programs run at the same time.

Active recall

Recall the key points — then reveal.

Sources: GCE AS and A level subject content for computer science (Department for Education) · AQA A-level Computer Science 7517 specification (AQA)

Programming languages and translators#

StandardAQA 7517 4.6.2AQA 7517 4.6.3DfE GCE Computer Science - translators

Programming languages form a hierarchy of abstraction. Machine code is the binary instructions the processor executes directly - fast but unreadable and specific to one processor family. Assembly language replaces the binary with short mnemonics (ADD, LDA, STA) in a one-to-one correspondence with machine instructions; it is still low-level and processor-specific but far more readable, and is used where fine control of hardware or timing is needed. High-level imperative languages (Python, Java, C#) are close to human notation, portable across processors, and productive, at the cost of not mapping directly to any one machine.

Because the processor understands only machine code, every other language needs a translator. An assembler translates assembly language into machine code, essentially one mnemonic to one instruction. A compiler translates an entire high-level program into machine code (or an intermediate form) once, before it is run, producing a fast, standalone executable and reporting all errors together at compile time; the drawback is that a separate compilation is needed for each target platform. An interpreter translates and executes a high-level program statement by statement at run time, which makes it excellent for development and debugging (it stops at the first error and needs no separate build) but slower to run, because translation happens every time the code executes.

Many modern languages combine the approaches to get the benefits of both. Java and C# compile source to a platform-independent intermediate (byte) code, which is then interpreted (or just-in-time compiled) by a virtual machine on each platform. This gives portability - 'compile once, run anywhere' - while recovering much of the speed of compilation. Choosing the right translation model for a task, and stating the trade-offs of compiler versus interpreter, is a standard evaluative question.

The choice has clear consequences. A compiler suits finished, distributed software where run-time speed matters and the source should be hidden; an interpreter suits development, education and scripting, where quick edit-run cycles and helpful, immediate error reporting matter more than raw speed. Bytecode-plus-virtual-machine suits software that must run unchanged across many kinds of computer. Understanding why each is chosen - not just what each does - is what earns the marks.

Typical mistakes

Saying a compiler translates 'line by line as it runs' - that is an interpreter; a compiler translates the whole program in advance.
Claiming interpreted code runs faster than compiled code - interpretation is generally slower because translation is repeated at run time.

Active revision

A team is developing and frequently testing a program, then distributing the finished version to customers on several operating systems. Recommend a translation approach for the development phase and for distribution, justifying each choice.

Active recall

Recall the key points — then reveal.

Sources: AQA A-level Computer Science 7517 specification (AQA)

Logic gates and combinational logic#

StandardAQA 7517 4.6.4DfE GCE Computer Science - logic gates

Truth tables for the two-input gates

Fig. 1For every combination of inputs A and B, the output of each gate. AND needs both 1; OR needs at least one 1; XOR needs the inputs to differ; NAND and NOR are the inversions of AND and OR. NOT (not shown, single input) simply inverts: NOT 0 = 1, NOT 1 = 0.

A logic gate is an electronic circuit that implements a Boolean function of one or more binary inputs, and the whole processor is built from them. The six required gates are: NOT (inverts its single input,

\overline{A}

); AND (output 1 only when all inputs are 1,

A \cdot B

); OR (output 1 when any input is 1,

A + B

); XOR (exclusive OR: output 1 when the inputs differ,

A \oplus B

); NAND (NOT-AND,

\overline{A \cdot B}

); and NOR (NOT-OR,

\overline{A + B}

). Each gate's behaviour is completely defined by its truth table, which lists the output for every combination of inputs (shown opposite).

Combinational logic builds larger circuits by wiring gates together so that the output depends only on the current inputs (with no memory of the past). To find what a combinational circuit does, you work through it gate by gate, or build a truth table with a column for each intermediate signal and a final column for the output. This is the standard method for both analysing a given circuit and checking that a design meets a required truth table.

NAND and NOR are called universal gates because any Boolean function can be built from NAND gates alone (or NOR gates alone). This matters practically - a chip can be manufactured from one repeated gate type - and it is a favourite exam point: for example NOT is a NAND with its inputs tied together, and AND is a NAND followed by a NOT. Recognising that a small set of gates suffices to build everything is another instance of building complexity from simple, uniform parts.

Completing and reading truth tables is the core skill of this section, and precision matters: XOR (differ) is easily confused with OR (at least one), and NAND/NOR are the inversions of AND/OR, so their outputs are 1 in exactly the cases where AND/OR are 0. Constructing the truth table for a multi-gate circuit, and designing a circuit to match a required truth table, are routinely examined.

Worked example

Building a truth table for a circuit

Find the output $Q = \overline{A} + (B \cdot C)$ for all combinations, and list the input rows where Q = 1.

Identify the terms
Q is 1 when NOT A is 1 (i.e. A = 0), OR when both B and C are 1 - the two terms are combined with OR.
A = 0 rows
Whenever A = 0, NOT A = 1, so Q = 1 regardless of B and C: rows 000, 001, 010, 011 all give Q = 1.
A = 1 rows
When A = 1, NOT A = 0, so Q = B AND C: only 111 gives Q = 1; 100, 101, 110 give 0.

Result: Q = 1 for 000, 001, 010, 011 and 111 (five of the eight rows); Q = 0 for 100, 101, 110.

Typical mistakes

Confusing XOR (output 1 only when inputs differ) with OR (output 1 when at least one input is 1) - they differ only on the 1,1 row.
Getting NAND and NOR the wrong way round: NAND is NOT(AND), NOR is NOT(OR).

Active revision

Complete the truth table for the circuit output $Q = (A \cdot B) + \overline{C}$ for all eight combinations of A, B, C, and state for how many rows Q = 1.

Active recall

Recall the key points — then reveal.

Sources: AQA A-level Computer Science 7517 specification (AQA)

Boolean algebra and simplification#

AdvancedAQA 7517 4.6.5DfE GCE Computer Science - Boolean algebra

Verifying a Boolean simplification by truth table

Fig. 2The expression A.B + A.(NOT B) + (NOT A).B and its simplified form A + B agree on every one of the four input rows, confirming the simplification is an equivalence rather than merely shorter.

Boolean algebra is the algebra of the two values 0 and 1, and it lets logic circuits be manipulated symbolically - just as ordinary algebra manipulates numbers. Its laws let a Boolean expression be rewritten into an equivalent one, most usefully a simpler one that needs fewer gates: cheaper, faster and more reliable hardware. The basic identities are the ones you would expect:

A \cdot 1 = A

A \cdot 0 = 0

A + 0 = A

A + 1 = 1

, the complement laws

A \cdot \overline{A} = 0

and

A + \overline{A} = 1

, and idempotence

A \cdot A = A

A + A = A

The structural laws are the workhorses of simplification: commutation (

A \cdot B = B \cdot A

), association (bracketing does not matter for a chain of the same operator), distribution (

A \cdot (B + C) = A\cdot B + A\cdot C

, and its dual

A + B\cdot C = (A+B)(A+C)

), and absorption (

A + A\cdot B = A

and

A \cdot (A + B) = A

). Applying these in the right order collapses a large expression to a minimal one, and the standard technique is to factor out a common variable and then use a complement or absorption law.

De Morgan's laws are the most important and most examined:

\overline{A \cdot B} = \overline{A} + \overline{B}

and

\overline{A + B} = \overline{A} \cdot \overline{B}

. In words, the complement of an AND is the OR of the complements, and vice versa - 'break the bar and change the operator'. They let a NAND be turned into an OR of inverted inputs (and a NOR into an AND of inverted inputs), which is essential for redesigning circuits, converting to universal gates, and simplifying expressions that contain a bar over a whole term.

The point of all this is circuit minimisation: fewer gates mean lower cost, less power, less heat and higher speed. A useful check is that a simplified expression must have the same truth table as the original - equivalence, not merely fewer symbols. Simplifying a given Boolean expression using the named laws, and verifying the result with a truth table, is one of the highest-value skills in Paper 2.

\overline{A \cdot B} = \overline{A} + \overline{B}, \qquad \overline{A + B} = \overline{A} \cdot \overline{B}

De Morgan's laws

Break the bar and swap the operator: the complement of an AND is the OR of the complements, and vice versa.

A + \overline{A} \cdot B = A + B

A useful absorption variant

Adds the missing case: once $A$ is present, $\overline{A}\cdot B$ contributes only the extra $B$ .

Worked example

Simplifying a Boolean expression

Simplify $A \cdot B + A \cdot \overline{B} + \overline{A} \cdot B$ , naming each law.

Factor A from the first two terms
By distribution, $A \cdot B + A \cdot \overline{B} = A \cdot (B + \overline{B})$ , leaving $A \cdot (B + \overline{B}) + \overline{A}\cdot B$ .
Apply the complement law
$B + \overline{B} = 1$ (complement), so $A \cdot 1 = A$ (identity). The expression is now $A + \overline{A}\cdot B$ .
Apply the absorption variant
$A + \overline{A}\cdot B = A + B$ .

Result: The expression simplifies to $A + B$ . The truth table opposite confirms the two forms agree on all four rows - three gates' worth of logic replaced by one.

Typical mistakes

Misapplying De Morgan's law by forgetting to change the operator ( $\overline{A\cdot B}$ is $\overline{A}+\overline{B}$ , not $\overline{A}\cdot\overline{B}$ ).
Treating Boolean $+$ like ordinary addition ( $A + A = A$ , not $2A$ ; and $A + 1 = 1$ , not a carry).

Active revision

Simplify $A \cdot B + A \cdot \overline{B} + \overline{A} \cdot B$ using Boolean laws, naming each law you use, and confirm the result with a full truth table.

Active recall

Recall the key points — then reveal.

Sources: AQA A-level Computer Science 7517 specification (AQA)

Adders and the flip-flop#

AdvancedAQA 7517 4.6.6AQA 7517 4.6.7DfE GCE Computer Science - adders and flip-flops

A half adder

Fig. 3Two inputs A and B feed an XOR gate (giving the sum) and an AND gate (giving the carry). It realises the single-bit addition table but cannot accept a carry in from a lower column.

A half adder adds two single bits, A and B, and produces a sum and a carry. Its logic falls straight out of the addition table: the sum is 1 only when the inputs differ (that is XOR,

S = A \oplus B

) and the carry is 1 only when both are 1 (that is AND,

C = A \cdot B

). The half adder (shown opposite) is the simplest arithmetic circuit and a perfect example of combinational logic realising a truth table - but it has a limitation: it cannot accept a carry coming in from a lower bit.

A full adder fixes this by adding three bits: A, B and a carry-in from the previous column. It can be built from two half adders and an OR gate (shown opposite): the first half adder adds A and B, the second adds that partial sum to the carry-in to give the final sum, and the two carry outputs are combined with an OR to give the carry-out. Full adders chained together - each column's carry-out feeding the next column's carry-in - form a ripple-carry adder that adds multi-bit binary numbers, which is exactly how a processor's arithmetic-logic unit performs addition (and, via two's complement, subtraction).

Adders are combinational - their output depends only on the current inputs - but a computer also needs to remember, which requires sequential logic whose output depends on past inputs as well. The building block of memory is the flip-flop, a circuit with two stable states that stores a single bit. The D-type flip-flop (shown opposite) has a data input D and a clock input; on the active clock edge it captures whatever is on D and holds it at its output Q (with

\overline{Q}

available too) until the next clock edge. It is edge-triggered, so it changes only at a defined instant.

The flip-flop is profoundly important: a row of D-type flip-flops is a register, the fastest storage in the machine, and vast arrays of storage cells built on the same bistable principle make up static RAM and the processor's internal registers met in the architecture chapter. The clock synchronises when every flip-flop updates, which is why a processor has a clock speed. Together, combinational logic (adders, decoders) that computes and sequential logic (flip-flops, registers) that remembers are the two halves from which every digital system is built.

S = A \oplus B, \qquad C = A \cdot B

Half adder

Sum is the exclusive-OR of the inputs; carry is their AND - read straight off the single-bit addition table.

A full adder from two half adders

Fig. 4The first half adder adds A and B; the second adds that partial sum to the carry-in to give the final sum. The two carries are combined by an OR gate to give the carry-out. Chaining full adders builds a multi-bit ripple-carry adder.

A D-type flip-flop

Fig. 5On the active edge of the clock the flip-flop captures the value on the data input D and holds it at output Q (with the complement at Q-bar) until the next clock edge. A group of D-type flip-flops sharing a clock forms a register.

Worked example

The full adder truth table row for 1 + 1 + 1

For a full adder with inputs A = 1, B = 1 and carry-in = 1, work out the sum and carry-out using the two-half-adder structure.

First half adder (A, B)
Sum1 $= 1 \oplus 1 = 0$ ; Carry1 $= 1 \cdot 1 = 1$ .
Second half adder (Sum1, carry-in)
Sum $= 0 \oplus 1 = 1$ ; Carry2 $= 0 \cdot 1 = 0$ .
Combine the carries
Carry-out $=$ Carry1 OR Carry2 $= 1 + 0 = 1$ .

Result: Sum = 1, carry-out = 1 - correct, since $1 + 1 + 1 = 3 = 11_2$ (a 1 in the sum column and a 1 carried out).

Typical mistakes

Using an AND gate for the sum of a half adder instead of XOR - AND gives the carry, XOR gives the sum.
Confusing combinational logic (no memory - adders) with sequential logic (has memory - flip-flops); only the flip-flop stores state.

Active revision

Draw the truth table for a full adder (inputs A, B, carry-in; outputs sum, carry-out) and confirm that 1 + 1 + 1 gives sum 1 and carry-out 1. Then explain what a D-type flip-flop outputs on the clock edge if D = 1.

Active recall

Recall the key points — then reveal.

Sources: AQA A-level Computer Science 7517 specification (AQA)

References & sources

Sources

Department for Education

GCE AS and A level subject content for computer science

AQA

AQA A-level Computer Science 7517 specification

Fundamentals of computer systems

5 sections~16 min reading time3 competenciesLevel Foundation 1 · Standard 2 · Advanced 2

Fundamentals of computer systems

Key points

Key points

Key points

Building a truth table for a circuit

Key points

Simplifying a Boolean expression

Key points

The full adder truth table row for 1 + 1 + 1

Sources

Fundamentals of computer systems

Key points

Key points

Key points

Building a truth table for a circuit

Key points

Simplifying a Boolean expression

Key points

The full adder truth table row for 1 + 1 + 1

Sources