CS Fundamentals — MCQs & Practice Questions

A computer is built from electronic switches, each of which has only two reliable states — on and off, or high and low voltage. Binary has exactly two digits, so each digit maps directly onto one switch, making the hardware simple and resistant to electrical noise.

Place values 16, 8, 4, 2, 1: 16 + 8 + 0 + 2 + 0 = 26.

It is far shorter and easier to read — one hex digit replaces four bits, so a 32-bit address takes 8 hex characters instead of 32 binary ones — while converting between the two needs no arithmetic at all.

1. 2 in hex is 0010 in binaryfour bits per hex digit[1]
2. C is 12 in decimal, which is 1100A=10, B=11, C=12, D=13, E=14, F=15[1]
3. Together: 00101100₂concatenate the groups, do not add them[1]
4. Decimal: 32 + 8 + 4 = 44or 2×16 + 12 = 44 directly from hex[1]

2C₁₆ = 00101100₂ = 44₁₀

1. Adds column by column from the right, carrying where a column totals 2[1]
2. Result within 8 bits: 01000010 with a carry out of the leftmost column[1]
3. In decimal 202 + 115 = 317, which exceeds the 8-bit maximum of 255[1]
4. Overflow occurs — the true answer needs 9 bits, so the stored 8-bit result is incorrectthe consequence must be stated[1]

Carry out of the final column; overflow occurs because 317 > 255.

1. 2⁷ = 128 characters[1]
2. Urdu uses a different script with many additional letterforms, and 128 slots are already taken by English letters, digits and punctuation — so Unicode is used insteadnaming Unicode expected[1]
3. 2²⁴ = 16 777 216 coloursaccept "about 16.7 million"[1]
4. Total pixels = 100 × 200 = 20 000[1]
5. Each pixel takes 24 bits = 3 bytes, so 20 000 × 3 = 60 000 bytesconverting bits to bytes is the step most often missed[1]
6. 60 000 / 1024 = 58.6 KBaccept 58.6 or 60 KB if 1000 bytes per KB is stated[1]

(a) 128, too few for a second script (b) 16 777 216 (c) about 58.6 KB

Advantage: it represents over a million characters, covering every writing system including Urdu and Chinese, where ASCII covers only 128. Disadvantage: each character may need up to four bytes rather than one, so files are larger.

2⁸ = 256 colours.

Sample rate is the number of measurements taken per second, in hertz. Sample resolution is the number of bits used to store each measurement. The first controls accuracy in time, the second accuracy in amplitude.

1. Total pixels = 1024 × 768 = 786 432[1]
2. Total bits = 786 432 × 16 = 12 582 912[1]
3. Bytes = 12 582 912 ÷ 8 = 1 572 864dividing by 8 is the step most often missed[1]
4. Kilobytes = 1 572 864 ÷ 1024 = 1536 KB[1]

1536 KB (1.5 MB)

1. Bits = 44 100 × 16 × 30rate × resolution × seconds[1]
2. = 21 168 000 bits[1]
3. Bytes = 2 646 000, so ÷ 1 048 576 = 2.52 MBaccept 2.65 MB using 1 000 000[1]
4. Stereo records two channels, so the file size doubles to about 5 MB[1]

About 2.5 MB mono, doubling to about 5 MB in stereo

1. Reduce the resolution — fewer pixels means a smaller file, at the cost of visible detail[1]
2. Reduce the colour depth — fewer bits per pixel, at the cost of colour accuracy and possible banding in smooth gradientsaccept compression as a third method[1]
3. The file size is width × height × colour depth, and only the depth has changed[1]
4. 24 is three times 8, and the size is directly proportional to the depth, so the file is three times as largethe proportionality is the mark[1]
5. Consecutive codes mean sorting alphabetically is the same as sorting numerically[1]
6. And converting between upper and lower case is a fixed addition or subtraction of 32, both of which would be far harder with arbitrary assignments[1]

(a) fewer pixels or fewer bits per pixel (b) size is proportional to depth, and 24 is 3 × 8 (c) sorting and case conversion become arithmetic

Inputs 00 → 1, 01 → 1, 10 → 1, 11 → 0. NAND is the inverse of AND, so it outputs 0 only when both inputs are 1.

(A · B)′ = A′ + B′ and (A + B)′ = A′ · B′. Complementing a whole expression swaps AND for OR and complements each variable.

Because any logic function whatsoever can be built using copies of just one of them. NOT, AND, OR and every larger circuit can be constructed from NAND alone, or from NOR alone, which is why chip manufacturers can make a whole processor from one repeated gate design.

1. Four rows for two inputs, with columns for A′ and B′[1]
2. A=0,B=0 → 0; A=0,B=1 → 1A′·B is 1 in the second row[1]
3. A=1,B=0 → 1; A=1,B=1 → 0[1]
4. Output is 1 exactly when the inputs differ, so this is an XOR gatethe identification is the point of the question[1]

The table matches XOR: output 1 when A and B differ.

1. Expand: A·A + A·B′ + B·A + B·B′distributive law[1]
2. A·A = A (idempotent) and B·B′ = 0 (complement)[1]
3. X = A + A·B′ + A·Bthe zero term disappears[1]
4. By absorption A + A·anything = A, so X = Anaming the law is required by the question[1]

X = A

1. 0+0 → Sum 0, Carry 0; 0+1 → Sum 1, Carry 0[1]
2. 1+0 → Sum 1, Carry 0; 1+1 → Sum 0, Carry 1the last row is the whole point — 1+1 in binary is 10[1]
3. Sum is produced by an XOR gateoutput 1 when the inputs differ[1]
4. Carry is produced by an AND gateoutput 1 only when both are 1[1]
5. A half adder has only two inputs, so it has nowhere to accept the carry produced by the previous column[1]
6. A full adder is needed instead, taking three inputs — A, B and carry-innaming the full adder is expected[1]

(b) XOR for Sum, AND for Carry (c) it has no carry-in input, so a full adder is required

(A · B)‾ = Ā + B̄ and (A + B)‾ = Ā · B̄. In words: break the bar and change the operation between the terms.

This is Gray code order, in which adjacent headings differ in exactly one variable. That adjacency is what makes grouping valid: within a group only one variable changes, so it can be eliminated. With ordinary binary order, neighbouring cells would differ in two variables and grouping would not simplify correctly.

Groups must contain a number of cells that is a power of two (1, 2, 4, 8…); groups must be rectangular and as large as possible; groups may overlap, and the map wraps round so opposite edges are adjacent.

1. (a) A·B + A·B̄ = A·(B + B̄) — factorising, using the distributive law.Taking out the common factor is the first move.[1]
2. B + B̄ = 1 by the inverse law, so A·1 = A by the identity law.Both laws should be named for full credit.[1]
3. (b) A + Ā·B = (A + Ā)·(A + B) by distributionThis is the less obvious route; the absorption-style result can also be quoted.[1]
4. = 1·(A + B) = A + BUsing the inverse and identity laws again.[1]
5. (c) Functionally complete means any logic circuit can be built using only that one type of gate.The definition must mention building any circuit.[1]
6. A NOT gate is made by connecting both inputs of a NAND together: NAND(A, A) = (A·A)‾ = Ā.The working using the idempotent law makes it convincing.[1]

(a) A; (b) A + B; (c) any circuit from one gate type; NAND(A,A) = NOT A

A simpler expression needs fewer gates, which makes the circuit cheaper to manufacture, smaller, and lower in power consumption. Fewer gates in a signal path also means less propagation delay, so the circuit runs faster.

RAM is volatile, fast and comparatively small; it holds the programs and data currently in use and loses everything when the power goes. Secondary storage such as an SSD is non-volatile, slower and much larger; it keeps data permanently.

The control unit, which fetches and decodes instructions and sends control signals to the rest of the system; and the arithmetic and logic unit, which performs calculations and logical comparisons.

It holds the address of the next instruction to be fetched. It increments during the fetch stage so that the following cycle picks up the next instruction rather than repeating the current one.

1. Fetch: the address in the program counter is placed on the address bus and the instruction is brought back along the data bus into the instruction registermention of a bus expected[1]
2. Decode: the control unit interprets the instruction to determine the operation and its operands[1]
3. Execute: the ALU carries out the operation[1]
4. Store: the result is written back to a register or to memory, and the cycle repeatsthe repetition should be stated[1]

Fetch, decode, execute, store — repeated for every instruction.

1. The address bus carries the memory address being accessed[1]
2. The data bus carries the actual data or instruction[1]
3. The control bus carries signals such as read and write[1]
4. The address bus is unidirectional — addresses only ever travel from the CPU to memory, whereas data travels both waysthe reason is required[1]

Address = where (one-way), data = what (two-way), control = read or write.

1. Laptop B[1]
2. Four cores can execute four instruction streams at once, so it handles several programs far better than one faster core[1]
3. 16 GB of RAM means far less swapping to disk, and the SSD has no moving parts so it reads much faster than a hard diskeither point accepted[1]
4. Laptop A has 1 TB of storage against 512 GB, so it holds roughly twice as many filescapacity is the only advantage here[1]
5. Clock speed measures cycles per second on ONE core, so it says nothing about how many cores there are[1]
6. It also ignores cache size and the amount of RAM, both of which decide how often the CPU has to wait for data[1]

(a) Laptop B — more cores, far more RAM, and an SSD (b) twice the storage capacity (c) clock speed ignores cores, cache and RAM

In the von Neumann architecture, program instructions and data are held in the same memory and travel over the same bus. The limitation is the von Neumann bottleneck: instructions and data cannot be transferred simultaneously, so the processor is often left waiting for memory.

The address in the PC is copied to the MAR. The PC is then incremented. The contents of the memory location addressed by the MAR are read into the MDR, and from there the instruction is copied into the CIR ready for decoding.

A jump instruction writes a new address into the PC during execution. If the increment happened afterwards, that new address would be increased by one and the jump would land at the wrong instruction. Incrementing during the fetch means a jump can simply overwrite the PC and execution continues correctly.

1. (a) The address bus is unidirectional; the data bus is bidirectional.Both directions must be stated.[1]
2. The address bus is one-way because only the processor generates addresses — memory never sends one back.The reason is the mark, not the direction alone.[1]
3. (b) Cache is faster than main memory and holds recently or frequently used data, so more requests are met without a slow main-memory access.The speed difference must be mentioned.[1]
4. This reduces the time the processor spends idle waiting for data.Linking to the bottleneck earns the second mark.[1]
5. (c) The program is single-threaded, so the work is not divided between cores and only one core is used.The software, not the hardware, is the limitation.[1]
6. (d) Advantage: several isolated systems on one machine, using hardware efficiently. Disadvantage: slower than running directly on hardware, because of the extra software layer.One of each is required.[1]

(a) address one-way, data two-way; (b) fewer slow memory accesses; (c) single-threaded; (d) isolation vs overhead

SIMD applies a single instruction to multiple data items at the same time — used by graphics processors operating on many pixels identically. MIMD executes different instructions on different data simultaneously — used by multi-core processors running separate tasks.

The core of the OS, permanently resident in memory, which manages the CPU, memory and devices and controls access to them. Other parts of the OS such as the user interface can be restarted or replaced; the kernel cannot.

Through time-slicing: the operating system gives each program a few milliseconds of CPU time in turn and switches between them far faster than a person can perceive. Only one instruction is ever executing, so the simultaneity is an illusion.

Any program that runs inherits the permissions of the account that started it. Malware launched from an administrator account can therefore alter system files and install itself permanently, whereas the same malware run from a standard account is confined to that user's own files.

1. Process management — scheduling which program uses the CPU and for how long[1]
2. Memory management — allocating RAM to each program and keeping them separate[1]
3. File management — organising storage into files and folders and controlling access to them[1]
4. Device management — communicating with hardware through drivers; also accept security and user accounts[1]

Process, memory, file and device management — plus security and the user interface.

1. RAM has filled, so the OS is moving pages of memory out to disk — paging or swappingthe constant disk light is the clue[1]
2. Disk access is thousands of times slower than RAM, so every switch between programs now waits on the diskthe speed gap is the explanation[1]
3. Solution: close unused applications and reduce the number of programs starting automatically[1]
4. Solution: install more RAM, which removes the need to page rather than merely making paging fasteran SSD helps but does not fix the cause[1]

RAM is full and the OS is paging to disk. Close programs, or add RAM.

1. Office machines: a single-user multi-tasking operating system, since one person at a time runs several applications togetheraccept multi-user for shared machines[1]
2. Patient monitor: a real-time operating system[1]
3. Real-time guarantees that a response occurs within a fixed maximum time, not merely quickly on averagethe guarantee is the distinguishing feature[1]
4. For a patient monitor an alarm raised late is as dangerous as no alarm, so a predictable worst case matters more than average speed[1]
5. File permissions grant read, write and execute rights separately to the owner, a group and others[1]
6. So clinical staff can be given read access to records while administrative staff cannot open them at all, and only authorised users may alter themthe example must fit the hospital[1]

(a) multi-tasking for the office, real-time for the monitor (b) a guaranteed maximum response time (c) separate read and write rights per group

A finite sequence of unambiguous instructions that solves a problem or completes a task, with clearly defined inputs and outputs.

Abstraction is removing the details that are not relevant to the problem being solved, so that the essential structure is easier to work with. A metro map shows the order of the stations and the connections between lines, but omits real distances and street layout — which makes it more useful for planning a journey, not less.

A flowchart is graphical, using standard shapes and arrows, and shows the flow of control visually. Pseudocode is textual, resembles program code and is quicker to write and to translate into a real language. Flowcharts become unwieldy for long algorithms, where pseudocode stays readable.

1. INPUT mark[1]
2. Validation: WHILE mark < 0 OR mark > 100 → OUTPUT "Invalid" and INPUT mark againa loop, not a single if — the user may enter a bad value twice[1]
3. IF mark >= 40 THEN OUTPUT "Pass"the >= is required; > alone fails a mark of exactly 40[1]
4. ELSE OUTPUT "Fail" ENDIF[1]

Input with a validation loop, then IF mark >= 40 output Pass ELSE output Fail.

1. Columns for n, i, total, and outputone column per variable[1]
2. After pass 1: i = 2, total = 1; after pass 2: i = 3, total = 3[1]
3. After pass 3: i = 4, total = 6; after pass 4: i = 5, total = 10[1]
4. The loop ends because 5 > 4; output is 10the algorithm sums 1 to n[1]

Output 10 — the algorithm computes 1 + 2 + 3 + 4.

1. Break the system into separate sub-problems, such as: record one student's attendance; store a day's records; calculate one student's monthly totalat least two named sub-problems[1]
2. And: produce the report; handle login. Each is small enough to be designed and tested on its ownthe reason for decomposing is part of the answer[1]
3. Abstraction: store only what the task needs — a student's roll number and present/absent flag — and ignore irrelevant details such as their address or hobbies[1]
4. The unnecessary detail would make the system larger and slower without improving the report[1]
5. Boundary data tests the values at the edges of what is acceptable, which is where most errors occur[1]
6. Example: a month with 31 days, or a class with exactly one student, or an attendance percentage of exactly 75% if that is the pass thresholdany sensible boundary value[1]

(a) split into recording, storing, calculating and reporting (b) store only roll number and present/absent (c) edges are where errors hide — e.g. exactly 75% attendance

The data must already be sorted. The algorithm discards half the list at each step by comparing with the middle item, which is only valid if the order is known.

A measure of how the number of operations grows as the size of the input grows, written in big-O notation. It describes the trend, not the exact running time on a particular machine.

About 10, because 2¹⁰ = 1024. Each comparison halves the remaining list, so the maximum is log₂ n rounded up.

1. After pass 1: 3, 5, 1, 8[1]
2. After pass 2: 3, 1, 5, 8[1]
3. After pass 3: 1, 3, 5, 8[1]
4. Three passes; a fourth confirms no swaps[1]
5. A flag records whether any swap was made; if a whole pass makes none, the list is sorted[1]
6. O(n²)[1]
7. Doubling the data quadruples the work, so it becomes impractically slow[1]

1. Initialises low = 1 and high = 5000[1]
2. Loops while low <= high[1]
3. Calculates mid = (low + high) DIV 2[1]
4. Compares and returns mid if the name matches[1]
5. Otherwise sets high = mid − 1 or low = mid + 1 correctly[1]
6. Returns a value such as −1 or FALSE once low > high[1]
7. Binary search: at most 13 comparisons, since 2¹³ = 8192[1]
8. Linear search: up to 5000, so binary search is dramatically faster[1]

1. Merge sort or quicksort (average case)[1]
2. The log n factor grows very slowly compared with the extra factor of n[1]
3. So the gap between the two widens rapidly as n increases[1]
4. Doubling n slightly more than doubles n log n[1]
5. So roughly 4.2 to 4.5 seconds, a little over doubleaccept "just over 4 seconds" with reasoning[1]

Advantage: any element can be reached directly from its index in constant time. Disadvantage: inserting at the front requires every later element to be shifted.

A stack is last-in-first-out: items are added and removed at the same end. A queue is first-in-first-out: items are added at one end and removed from the other.

On a push the pointer is incremented and the new item is written at that position. On a pop the item at the pointer is read and the pointer is decremented. The pointer must be checked against the array bounds first.

1. Jobs must be printed in the order they were submitted[1]
2. A queue removes items in the same order they were added, which is first-in-first-out[1]
3. In a linear queue the front pointer moves forward and the space behind it is wasted[1]
4. A circular queue wraps the rear pointer round to the start of the array[1]
5. So the freed space is reused and the array does not appear full while space remains[1]
6. That the queue is not full[1]

1. 50 at the root with 30 on its left and 70 on its right[1]
2. 20 and 40 as the children of 30[1]
3. 60 as the left child of 70[1]
4. Visits left subtree, then node, then right subtree[1]
5. 20, 30, 40, 50, 60, 70[1]
6. The values in ascending order[1]
7. It can therefore be used to sort the data, or to output it in order without re-sorting[1]

(b) 20, 30, 40, 50, 60, 70

1. Traverse from the head until the node after which Chand belongs is found, here Bilal[1]
2. Create the new node and set its pointer to whatever Bilal was pointing at, that is Danish[1]
3. Set Bilal's pointer to the new nodethis order matters or the rest of the list is lost[1]
4. The nodes are not stored in consecutive memory locations[1]
5. Order is held by the pointers, so changing two pointers is enough[1]

An imperative program specifies how to obtain the result, as an ordered sequence of statements that change the program state. A declarative program specifies what result is required and leaves the method of obtaining it to the system — SQL being the standard example.

Encapsulation means bundling data together with the methods that operate on it inside a class, and making the data private so it can only be accessed through those methods. The benefit is that the data cannot be set to an invalid value by unrelated code, since every change passes through a method that can validate it — so the object stays in a consistent state.

Polymorphism means the same method call behaves differently depending on the object it is applied to. For example, calling Area() on a Circle runs the circle's formula while the same call on a Rectangle runs a different one — the calling code does not need to know which type it holds.

1. (a) It separates the normal flow from error handling: risky code goes in TRY, and control passes to a CATCH block if an exception occurs.The separation of normal and error paths is the point.[1]
2. (b) FINALLY runs whether or not an exception occurred, so the file is closed either way.The "either way" behaviour is what makes it useful.[1]
3. Without it a file could be left open after an error, locking it or losing unwritten data.A concrete consequence earns the second mark.[1]
4. (c) Different errors need different responses, and a generic handler treats them identically.Loss of specificity is the core issue.[1]
5. It can also hide genuine bugs, since an unexpected error is caught and silently ignored rather than being noticed.The masking of programming errors is the stronger half of the answer.[1]
6. (d) The normal logic stays readable, uncluttered by a check after every operation, and an error can be handled at whatever level makes sense rather than at the point it occurred.Either readability or the level of handling is acceptable.[1]

(a) separates normal and error paths; (b) files close either way; (c) loses specificity and hides bugs; (d) readability

Writing a device driver or code for an embedded microcontroller. Direct access to specific registers, memory addresses and hardware timing is required, and the precise number of clock cycles may matter — control a high-level language deliberately abstracts away.

It must have a base case that returns a value without calling itself, and each recursive call must make progress towards that base case — typically by reducing the parameter.

Each call pushes a stack frame containing the return address, the parameters and any local variables, so the suspended call can be resumed. Frames accumulate as the recursion descends. When the base case returns, the frames are popped in reverse order — last in, first out — with each completing its calculation as it goes.

It calls itself indefinitely, pushing a new stack frame each time and never returning. The stack eventually runs out of memory and the program terminates with a stack overflow error.

1. (a) Base case: S(1) = 1. Recursive case: S(n) = n + S(n−1).Both must be identified separately.[1]
2. (b) S(5) calls S(4), which calls S(3), S(2) and finally S(1). Five frames are pushed.The descent, with nothing computed yet.[1]
3. S(1) returns 1 — the base case.This starts the unwinding.[1]
4. S(2) = 2 + 1 = 3; S(3) = 3 + 3 = 6; S(4) = 4 + 6 = 10; S(5) = 5 + 10 = 15.Returns in reverse order of the calls.[1]
5. (c) Advantage: the code closely matches the mathematical definition, so it is shorter and clearer.Readability is the usual advantage.[1]
6. Disadvantage: each call uses a stack frame, so it needs more memory and risks stack overflow for large n.Memory cost is the standard disadvantage.[1]

(a) S(1)=1 and S(n)=n+S(n−1); (b) S(5) = 15; (c) clarity vs stack memory

Recursion is preferable for recursive data structures such as traversing a tree, or for divide-and-conquer algorithms like quicksort, where an iterative version would need an explicit stack of its own. Iteration is preferable for simple repetition such as summing a list, where recursion would waste memory on stack frames for no gain in clarity.

A LAN covers a small geographical area such as one building and its hardware is usually owned by the organisation. A WAN covers a large area and typically uses third-party communication links.

An IP address identifies a device on a network and can change when the device moves to a different network. A MAC address is fixed in the hardware and uniquely identifies the network adapter itself.

The data is divided into equal-sized blocks. Each packet carries a header with the source and destination addresses and its sequence number, and packets may travel by different routes and are reassembled in order at the destination.

1. A LAN[1]
2. The computers are all within a single building and the school owns the cabling[1]
3. A switch connects devices within the LAN[1]
4. It forwards each frame only to the port of the intended recipient, using MAC addresses[1]
5. A router connects the LAN to another network, usually the internet[1]
6. It forwards packets between networks using IP addresses[1]
7. Advantage: files and printers can be shared[1]
8. Advantage: software and backups can be managed centrally[1]

1. The browser sends the domain name to a DNS server[1]
2. The server looks up the matching IP address[1]
3. The IP address is returned and the browser requests the page from that server[1]
4. HTTPS encrypts the data in transit, HTTP sends it in plain text[1]
5. So HTTPS protects information such as passwords from being read if intercepted[1]
6. To block access to unsuitable or unauthorised sites[1]
7. To inspect incoming traffic and block unauthorised access to the network[1]

1. Faster and more reliable, with less interference[1]
2. Devices can be moved freely and no cabling is needed[1]
3. Use WPA encryption on the wireless network[1]
4. Data sent over the air is scrambled[1]
5. So anyone intercepting the signal cannot read it without the keyaccept MAC filtering or a strong passphrase, explained[1]

The internet is the global infrastructure of interconnected networks that carries data. The world wide web is a collection of pages and resources accessed over that infrastructure — one of several services using it, alongside email and file transfer.

It translates a domain name that people can remember into the IP address the network needs to route data. This also allows a site to move to a different server without its address changing for visitors.

Keeping a user logged in as they move between pages of a site, and remembering preferences such as language, currency or the contents of a shopping basket.

1. The browser extracts the domain name and requests its IP address from a DNS server[1]
2. The DNS server returns the IP address, querying other DNS servers if necessary[1]
3. The browser sends an HTTP request to that address and the server responds with the HTML[1]
4. The browser requests the further resources the page references, then parses the HTML, applies the CSS and renders the page[1]

DNS lookup → HTTP request → server response → further resource requests → parse and render.

1. The data is encrypted in the browser before it is transmitted[1]
2. so anyone intercepting it on the network sees only ciphertext and cannot read the card details[1]
3. A digital certificate issued by a trusted authority supplies the public key and confirms the site's identity[1]
4. The padlock does not guarantee the site is honest — only that the connection is encrypted and the site is genuinely the one named on the certificatea fraudulent site can hold a valid certificate[1]

Encryption in transit plus a certificate proving identity; the padlock says nothing about the site's honesty.

1. A session cookie is held in memory and deleted when the browser closes — used to keep the customer logged in while moving between pages[1]
2. A persistent cookie is stored on disk and survives until it expires — used to remember preferences or a basket between visits[1]
3. A cookie set by an advertiser present on many different sites can be read on each of them[1]
4. so a record of the user's browsing can be assembled across sites without their being aware of itthe cross-site point is the concern[1]
5. A cookie is a small text file, not a program, so it cannot be executed[1]
6. It can only be read by the site that set it, and cannot access other files on the machine — the genuine risk is to privacy, not to the computer[1]

(a) session in memory until the browser closes; persistent on disk until expiry (b) cross-site tracking builds a browsing profile (c) it is data, not a program

Artificial intelligence is the broad field of making machines perform tasks that would ordinarily require human intelligence. Machine learning is a subset of AI in which the system learns patterns from data rather than being given explicit rules. All machine learning is AI; not all AI is machine learning.

Learning from data in which each example is labelled with the correct answer. The model learns to reproduce those labels on new data. Example: training on photographs already tagged "cat" or "dog" so the system can classify unseen photographs.

Because a model can score perfectly on data it has effectively memorised, which says nothing about how it will behave on new examples. Only unseen data measures whether it has learned the general pattern — the property that actually matters in use.

1. Supervised: trained on labelled data — for example spam detection from emails already marked spam or not[1]
2. Unsupervised: trained on unlabelled data and finds structure itself — for example grouping customers into segments[1]
3. Reinforcement: learns by acting and receiving rewards or penalties — for example a program learning to play a game[1]
4. The distinguishing factor is what the training data contains: answers, no answers, or a reward signalthe unifying statement earns the fourth mark[1]

Labelled data, unlabelled data, and reward feedback respectively.

1. The model learns the patterns in the historical decisions, including any that were unfair[1]
2. If certain groups were refused disproportionately in the past, the model reproduces that pattern while appearing objectivethe appearance of objectivity is part of the harm[1]
3. Reduce it by examining the training data for representativeness, and testing outcomes separately for each group[1]
4. And by keeping a human decision-maker for consequential decisions, with a documented route to appealaccept requiring the model to be explainable[1]

The model learns historical unfairness. Audit the data, test outcomes per group, and keep human oversight.

1. Historical records of past students — attendance, assessment marks, homework completion — each labelled with whether that student ultimately passed or failedlabelled data, so this is supervised learning[1]
2. The data is split into a training set and a test set; the model learns from the first and is measured on the second[1]
3. Unfairness: if the historical data reflects a group that was under-supported in the past, the model predicts failure for that group and the prediction becomes self-fulfilling[1]
4. Or: a feature that correlates with background rather than ability — such as distance travelled to school — drives the predictioneither example accepted[1]
5. A prediction is a statistical likelihood about a group, not a fact about the individual student in front of the teacher[1]
6. The model cannot explain its reasoning, and being labelled "likely to fail" could itself affect how a student is treated and how they see themselves[1]

(a) labelled historical records, split into training and test sets (b) it reproduces past under-support as a prediction (c) a prediction is about likelihood, not about the individual, and cannot justify itself

AI can analyse medical images such as chest X-rays and flag those most likely to show disease, so a radiologist reviews the urgent cases first. The benefit is speed and consistency: it works continuously without fatigue, letting a small number of specialists cover a large population.

It usually cannot explain how it reached a decision, so a person affected cannot be told why. And it reproduces the biases in its training data while appearing objective, which can make unfair outcomes harder to challenge.

A farmer can photograph an affected leaf with a phone and a model identifies the crop disease and suggests treatment. This reaches farms that an agricultural extension officer could not visit often enough, and gives an answer within seconds rather than days.

1. Benefit: they do not tire, become distracted or drive under the influence, and human error causes most collisions[1]
2. Benefit: they can give independent mobility to people unable to drive, and can coordinate to reduce congestion[1]
3. Risk: an unfamiliar situation not represented in training may be handled badly, and roads present many such situations[1]
4. Risk: responsibility for a collision is unclear — the owner, the manufacturer or the software developer — and the vehicle is a target for interferenceaccept job losses among professional drivers[1]

Benefits: no fatigue or distraction, and mobility for non-drivers. Risks: unfamiliar situations, and unclear liability.

1. There are millions of transactions, far more than any human team could examine[1]
2. Fraud shows as an unusual pattern, and finding patterns in large volumes of data at speed is exactly what these systems do well[1]
3. Problem: false positives — a legitimate but unusual transaction is blocked, such as a card used abroad on holiday[1]
4. The customer is inconvenienced and may not be told why, since the system cannot explain the pattern it reacted tothe inability to explain is the sharper point[1]

The volume and the pattern-matching suit AI; the cost is blocked legitimate transactions with no explanation.

1. In favour: decisions would be made far faster and applicants would wait less[1]
2. In favour: the same rules would be applied to every applicant, removing the inconsistency between individual assessors[1]
3. Against: trained on past decisions, it would reproduce any historical unfairness while appearing objective[1]
4. Against: an applicant refused assistance could not be told why, and would have no meaningful basis for appealthe accountability point[1]
5. Recommendation: use the system to sort and prioritise applications, with a human assessor making every final decision[1]
6. Justified because the speed and consistency are gained while accountability and the right to an explanation are preserved, and unusual cases still reach a personthe justification must address both sides[1]

(a) speed and consistency (b) inherited bias and no explanation (c) AI prioritises, humans decide — keeping the benefit and the accountability