2024 CCEA GCSE Digital Technology 2650 Practice Paper with Answers

Converting \( 00101101_2 \) to denary using place values 128, 64, 32, 16, 8, 4, 2, 1: the set bits correspond to 32, 8, 4 and 1, so \( 32+8+4+1 = 45 \).

[1] for selecting B (45). No partial credit for a multiple-choice item.

The operating system is system software that manages hardware resources (CPU, memory, storage, peripherals) and provides the platform on which application software runs. Utility software performs maintenance tasks; open-source and custom-written software describe how software is licensed/produced, not its function.

[1] for selecting B (Operating system).

A primary key is a field, or combination of fields, whose value(s) uniquely identify every record in a table, ensuring no two records are identical. A foreign key links to another table's primary key; an index speeds up searching; a query retrieves data.

[1] for selecting C (Primary key).

COUNTIF(range,criteria) counts the number of cells in a range that meet a stated criteria, so =COUNTIF(B2:B20,">50") counts how many cells hold a value greater than 50. SUM would total values rather than count them; AVERAGEIF returns a mean; VLOOKUP performs a lookup, not a count.

[1] for selecting B (COUNTIF).

RAM (Random Access Memory) is volatile working memory that holds currently-running programs and data for fast CPU access, and is cleared when power is lost. ROM is non-volatile and holds fixed startup instructions; HDDs and SSDs are non-volatile secondary storage.

[1] for selecting C (RAM).

A router forwards data packets between different networks (e.g. a home network and the internet) using IP addresses to determine the best path. A switch forwards data within a single local network using MAC addresses; a hub broadcasts to all connected devices; a NIC connects a single device to a network.

[1] for selecting B (Router).

A Trojan horse is malware disguised as legitimate, desirable software; once run it performs a harmful action but, unlike a virus or worm, does not self-replicate to spread to other files or systems on its own.

[1] for selecting B (Trojan horse).

Infrastructure as a Service (IaaS) provides raw virtualised hardware resources (virtual servers, storage, networking) that the customer configures and manages. PaaS additionally provides a development platform; SaaS provides a complete ready-to-use application.

[1] for selecting C (Infrastructure as a Service).

The Computer Misuse Act 1990 makes unauthorised access to computer material (e.g. hacking into an account without permission) a criminal offence, alongside unauthorised access with intent to commit further offences and unauthorised modification of data. Data-handling obligations fall under the Data Protection Act 2018, not the Computer Misuse Act.

[1] for selecting B (Unauthorised access to computer material).

A spreadsheet or database application can store structured order records, perform automatic calculations (e.g. totals, VAT) using formulas or queries, and generate invoices from that data. The other applications are designed for documents, slideshows and graphics respectively, not structured calculation and record-keeping.

[1] for selecting B (A spreadsheet or database application).

Environmental impact refers to the positive or negative effects that digital technology has on the natural environment across its life cycle — manufacture, use and disposal. Example: extracting rare-earth metals such as cobalt and lithium, needed for batteries and circuit boards, causes habitat destruction, water pollution and high energy consumption during mining and refining.

[1] for an accurate definition of environmental impact (the effect of producing/using/disposing of devices on the environment); [1] for a valid, relevant example (e.g. rare-earth mining, e-waste, manufacturing energy use). Accept any other valid example. Do not accept a vague statement such as 'it's bad for the environment' with no supporting detail.

Prolonged, unbroken keyboard and mouse use can cause repetitive strain injury (RSI) — pain, tingling or stiffness in the wrists, hands or fingers from repeated small movements. This can be reduced by taking regular breaks (e.g. five minutes every hour), using an ergonomic keyboard and mouse, and maintaining a correct wrist position, for example with a wrist rest, to avoid awkward angles.

[1] for a valid health risk linked to prolonged laptop use (RSI, eye strain, back/neck problems); [1] for a valid reduction method that is clearly matched to that risk. Reject an unrelated risk/reduction pairing.

Allowing personal USB sticks to be connected risks introducing malware, picked up elsewhere (e.g. on a home computer), onto the company network as soon as the stick is plugged in, potentially spreading to other systems. This risk can be reduced by disabling USB ports on company computers via group policy, or by installing endpoint security software that automatically scans any removable media for malware before its contents can be accessed.

[1] for a valid risk related to removable media (malware transfer, data theft or leakage); [1] for a valid countermeasure clearly matched to that risk (disabling ports, scanning software, a policy banning personal devices). Reject a generic 'use antivirus' answer with no link to USB use.

The primary key of tblLoan is LoanID. BookID is unsuitable as the primary key of tblLoan because a single book can be borrowed and returned multiple times, so the same BookID value could legitimately appear in several loan records (breaking the uniqueness requirement of a primary key), whereas LoanID is generated fresh for every individual loan transaction and so is always unique.

[1] for correctly identifying LoanID as the primary key; [1] for a valid explanation of why BookID cannot serve as the primary key of tblLoan (it can repeat across multiple loan records).

BookID in tblLoan is a foreign key: it is not unique within tblLoan (the same book may be loaned more than once) but it matches the primary key BookID in tblBook, creating a relationship between the two tables so that details of the borrowed book can be looked up for any loan record.

[1] for correctly identifying BookID as the foreign key; [1] for correctly stating it links to tblBook. Do not accept MemberID unless the candidate correctly explains it would link to a members table not shown here.

Only record B001 (The Hobbit) satisfies both criteria simultaneously: its Genre is Fantasy and its Available field is No. B002 (Data Structures) and B003 (Silent Spring) fail the Genre criterion, and B003 additionally fails the Available criterion, so neither is returned.

[2] for correctly identifying that only B001 / The Hobbit is returned, with a valid reason; [1] for identifying the correct record without a clear reason, or for correct logic but an incomplete record identifier.

The Available field only ever holds one of two possible states (Yes or No), which is exactly what a Boolean (Yes/No or logical) data type is designed to store efficiently.

[1] for Boolean, Yes/No, or logical data type. Do not accept 'Text' or 'Short Text' as the best answer for this mark.

A presence check ensures a value must be entered in the BookID field before the record can be saved, preventing incomplete records. A format check (e.g. must start with 'B' followed by three digits) or a uniqueness check would also be valid.

[1] for any valid validation rule appropriate to a unique identifier field (presence check, format check, uniqueness/no-duplicates check).

L001 has a DateDue of 2026-05-15, which is earlier than 2026-05-16, so it satisfies the criteria. L002 has a DateDue of 2026-05-17, which is not earlier than 2026-05-16, so it is excluded.

[1] for L001 only.

The formula =B2*C2 multiplies the number of units sold (B2 = 120) by the price per unit (C2 = 0.50), giving \( 120 \times 0.50 = 60 \).

[1] for a correct formula multiplying B2 by C2; [1] for the correct resulting value of 60 (accept 60.00).

Using absolute references ($F$1) fixes both the column and row of the F1 reference so that, when the formula is copied down from C2 to C5, F1 always stays fixed while C2 changes relatively to C3, C4 and C5.

[1] for correctly using the $ symbols to make F1 an absolute reference; [1] for the formula otherwise correctly multiplying the relevant price cell by F1.

B3 holds 75, the UnitsSold value for Notebooks. Since 75 is not greater than 100, the IF condition is false, so the formula returns the value for the false case, "OK", rather than "Reorder".

[1] for correctly stating the result is "OK"; [1] for a valid explanation that references B3 = 75, which is not greater than 100.

The UnitsSold column is column B, and the four items occupy rows 2 to 5, so the full range of UnitsSold values is B2:B5.

[1] for B2:B5.

B4 (Rulers UnitsSold) is 40 and C4 (Rulers Price) is 0.30, so \( 40 \times 0.30 = 12 \).

[1] for 12 (accept 12.00 or £12).

Dividing any number by zero is undefined, so spreadsheet software displays the error value #DIV/0! rather than a numeric result.

[1] for #DIV/0! (accept without exclamation mark).

The Price values are 0.50, 1.20, 0.30 and 0.25. Of these, 0.50, 0.30 and 0.25 are less than 1, while 1.20 is not, so COUNTIF returns 3.

[1] for 3.

Because no $ symbols are used, B2 and C2 are relative references, so when the formula is copied down, the row number automatically adjusts (to B3*C3, B4*C4, B5*C5), correctly pairing each row's own UnitsSold and Price values.

[1] for identifying a relative reference with a valid reason (automatic adjustment to match each row).

Clock speed measures how many processing cycles the CPU can carry out per second; a higher value (here \( 3.8\text{GHz} = 3.8 \) billion cycles per second) generally means individual instructions are carried out more quickly. Having four cores means the CPU can process four separate instruction streams truly simultaneously rather than one at a time, which is particularly beneficial for multitasking and for software written to run in parallel (such as many modern games).

[1] clock speed correctly explained (cycles per second; higher value processes instructions faster); [1] cores correctly explained (multiple instructions processed simultaneously/in parallel); [1] for linking both specifications to an overall effect on performance or multitasking capability.

An SSD stores data electronically in flash memory chips rather than on spinning magnetic platters, so it has no moving parts. This gives it significantly faster read and write speeds than an HDD, resulting in quicker boot times, faster file transfers and reduced application loading times.

[1] for a valid advantage (speed, durability due to no moving parts, lower power consumption, silent operation); [1] for a brief, accurate justification of that advantage.

A microphone combined with voice-recognition software allows the user to issue spoken commands that are converted into text or system actions. This is appropriate for a visually impaired user because it does not depend on being able to see a keyboard, mouse pointer or screen layout, and spoken commands can be mapped directly to on-screen actions (e.g. 'open email', 'scroll down'), reducing reliance on sight for basic navigation.

[1] for a correctly named device/technology (microphone with voice-recognition software); [1] for a justification clearly linked to visual impairment; [1] for further valid development (e.g. commands mapped to on-screen actions, reduces reliance on sight/hand precision).

RAM (Random Access Memory) is volatile, meaning its contents are lost as soon as power is removed, and it can be both read and written to constantly while the computer runs. ROM (Read Only Memory) is non-volatile, retaining its contents without power, and typically holds fixed instructions (such as startup/boot instructions) that cannot be altered during normal use.

[1] for correctly distinguishing volatility (RAM loses its contents when power is removed; ROM retains its contents); [1] for correctly distinguishing writability (RAM can be read from and written to; ROM is read-only/fixed).

This is a star topology, in which every device connects individually to a central point (here, a switch) rather than to each other directly. One advantage is that if a single cable or single device fails, only that device loses connectivity — the rest of the network continues operating normally, unlike in a bus topology where a single cable break can disable the whole network.

[1] for correctly naming star topology; [1] for a valid advantage (fault isolation/resilience, easy to add new devices without disrupting the network, good performance since data does not pass through other devices).

(a) Bandwidth is the maximum rate at which data can be transferred across a network connection, typically measured in bits per second (e.g. Mbps). (b) A switch examines the MAC address of incoming data and forwards it only to the specific port/device it is addressed to, rather than broadcasting to every connected device as a hub would.

[1] for bandwidth; [1] for switch. No credit for other word-bank terms used in either blank.

Download speed is the rate at which data can be received from the internet by a device, usually measured in megabits per second (Mbps). Buffering can still occur because each 4K video stream requires a high, sustained bitrate; when several such streams run at once, their combined bandwidth demand can approach or exceed the connection's total 100 Mbps capacity once it is shared across all active devices, causing individual streams to receive data more slowly than they need it.

[1] for a correct definition of download speed; [1] for a valid explanation linking multiple simultaneous high-bitrate streams to shared/exceeded bandwidth.

A firewall sits between a network and external connections (such as the internet), inspecting all incoming and outgoing traffic. It compares this traffic against a defined set of security rules and blocks any traffic that does not meet those rules, preventing unauthorised users or malicious data from reaching devices on the internal network while still allowing legitimate traffic through.

[1] for stating a firewall monitors/filters network traffic; [1] for explaining that it blocks traffic which does not meet defined security rules, thereby preventing unauthorised access.

(a) Phishing is a social-engineering technique in which a fraudulent message impersonates a trustworthy organisation to trick the recipient into revealing sensitive information. (b) Two-factor authentication requires two different forms of evidence of identity — here, something the user knows (a password) and something the user has (a one-time code sent to their phone) — before granting access.

[1] for phishing; [1] for two-factor authentication.

A data transfer protocol is an agreed set of rules that determines how data is formatted, addressed, transmitted and received so that different devices and systems can communicate reliably. SFTP (Secure File Transfer Protocol) is an example of a protocol that transfers files over a network while encrypting the data in transit, protecting it from interception.

[1] for a valid definition of a protocol as a set of communication rules; [1] for a valid named secure transfer protocol (SFTP, FTPS or HTTPS).

Lossy compression reduces file size by permanently removing data that is judged least noticeable to a human viewer/listener, which reduces quality slightly but achieves much smaller files — examples include MP3 (audio) and JPEG (images). Lossless compression reduces file size by removing statistical redundancy without discarding any actual data, meaning the original file can be perfectly reconstructed — examples include PNG (images), FLAC (audio) and ZIP (general files).

[1] for the correct distinction (lossy permanently discards data/reduces quality; lossless preserves all data exactly); [1] for at least one correct matching example format.

Reducing the video's resolution or bitrate (or applying stronger lossy compression) decreases the amount of data stored per frame, shrinking the overall file size and making the video quicker to load on the website. The drawback is a reduction in visual quality — the video may appear pixelated, blurry, or show compression artefacts, which is more noticeable when viewed on a large or high-resolution screen.

[1] for a valid optimisation technique (lower resolution/bitrate, lossy compression, trimming length); [1] for a valid drawback clearly linked to that technique (reduced visual quality/detail).

Sample rate describes how many times per second an analogue sound wave's amplitude is measured and converted into a digital value during recording; a higher sample rate captures the original sound more accurately but produces a larger file.

[1] for a correct definition referring to the number of samples/measurements taken per second.

(i) Ransomware is malicious software that encrypts a victim's files or locks them out of their system, then demands payment (a ransom) in exchange for the decryption key or restored access. Protection: keeping regular offline/off-site backups means data can be restored without paying the ransom, combined with up-to-date anti-malware software and staff training not to open suspicious attachments or links.
(ii) A DDoS attack floods a server or network with an overwhelming volume of traffic, often generated simultaneously by a large number of compromised devices (a botnet), so that the server cannot respond to requests from legitimate users, effectively denying them the service. Protection: using a content delivery network (CDN) or specialist traffic-filtering/load-balancing service that can detect and absorb abnormal traffic spikes before they reach the origin server.
(iii) SQL injection occurs when an attacker enters malicious SQL code into an unprotected input field (such as a login box) which is passed directly to the database and executed, allowing the attacker to view, modify or delete data they should not have access to. Protection: validating and sanitising all user input, and using parameterised queries so that anything entered by a user is always treated as data rather than executable code.

Level-based mark scheme (6 marks). Level 0 [0]: Not worthy of credit. Level 1 [1–2]: Basic, partial description of one or two threats, with little or no reference to a matching protection method; limited use of specialist terms; weak grammar/spelling. Level 2 [3–4]: Satisfactory description of at least two threats, each with at least one appropriate, correctly linked countermeasure; some specialist terminology used correctly; satisfactory grammar/spelling. Level 3 [5–6]: Comprehensive, accurate description of all three threats, each paired with a correctly explained, appropriate countermeasure; accurate specialist terminology used throughout (e.g. 'botnet', 'parameterised queries', 'encryption'); clear, well-structured response.

One health implication is reduced physical fitness or weight gain caused by long periods of sedentary sitting, which could be addressed by scheduling regular activity breaks away from the screen (e.g. every hour). A second implication is disrupted sleep caused by blue light exposure and mental stimulation from gaming close to bedtime, which could be addressed by setting a curfew that stops screen use at least an hour before sleep.

[1] first valid health implication clearly described; [1] second valid, distinct health implication clearly described; [1] for at least one relevant way of addressing an implication, clearly matched to it. Accept eye strain, RSI or social isolation as alternative implications.

A positive social implication is that online multiplayer gaming allows players to form friendships and join communities with people they would never otherwise meet, based on shared interests rather than geography, which can be particularly valuable for players who find in-person socialising difficult. A negative social implication is that open online interaction can expose younger or vulnerable players to harassment, bullying, or inappropriate contact from strangers, since many games allow voice or text chat with people outside the player's normal social circle.

[1] for a valid, clearly identified social implication (positive or negative); [1] for a developed explanation of why or how it arises specifically from online multiplayer gaming.

Haptic feedback built into a game controller produces physical vibrations or resistance in response to in-game events (such as an explosion or a bumpy road surface), giving the player a physical sensation that matches what is happening on screen, which increases the feeling of being present inside the game world.

[1] for a valid, correctly named gaming technology feature (e.g. haptic feedback, VR headset, 3D positional audio); [1] for an explanation of how it specifically increases immersion.

Cloud storage is defined by definition (ii): it stores files on remote servers, owned and maintained by a provider, which the user accesses over the internet rather than on a local device.

[1] for (ii).

Scalability, as applied to cloud computing, is defined by (i): the ability to flexibly increase or decrease allocated resources (such as storage or processing power) in response to changing demand, without needing to buy new physical hardware.

[1] for (i).

Open-source software matches definition (ii): its source code is made publicly available so that anyone can view, modify and redistribute it, usually under a licence that preserves these freedoms.

[1] for (ii).

Utility software matches definition (ii): it exists to manage, maintain or optimise the computer system itself (e.g. anti-virus, disk defragmenters, backup tools) rather than to perform an end-user task directly.

[1] for (ii).

E-commerce matches definition (i): it refers to the buying and selling of goods or services conducted over computer networks such as the internet.

[1] for (i).

Video conferencing matches definition (iii): it enables live, real-time audio and video communication between participants who are in different physical locations.

[1] for (iii).

An IP address matches definition (ii): it is a unique numerical label assigned to each device connected to a network, used to identify that device and route data to and from it.

[1] for (ii).

A peripheral device matches definition (ii): it is connected to a computer to add input, output or storage functionality (e.g. a printer, keyboard or external drive) but is not itself an essential internal processing component.

[1] for (ii).

This is governed by the Data Protection Act 2018, which incorporates the UK GDPR. Among its requirements, the company must practise data minimisation (only collecting data that is genuinely necessary for its stated purpose), keep the data accurate and secure, and only retain it for as long as necessary; it must also have a lawful basis for processing the data, such as consent.

[1] for correctly naming the Data Protection Act 2018 / UK GDPR; [1] for a valid requirement (data minimisation, consent, right to be forgotten/erasure, keeping data accurate and secure, limited retention).

This breaches the Copyright, Designs and Patents Act 1988. Under this Act, the creator (or rights holder) of a creative work such as a film automatically owns exclusive rights to control how it is copied, distributed and performed. Downloading the film without payment or licence, and then sharing further copies with friends, both reproduces and distributes the work without the copyright owner's permission, directly infringing those exclusive rights.

[1] for correctly naming the Copyright, Designs and Patents Act 1988; [1] for a valid explanation linking unauthorised copying/distribution to infringement of the copyright owner's exclusive rights.

One ethical concern is that, although such tracking may be technically permitted under a platform's terms and conditions, most users do not read or fully understand these terms, so their 'consent' to being profiled is not genuinely informed. This raises a broader concern about privacy: detailed behavioural profiles can reveal sensitive information about a person's interests, habits or vulnerabilities, which is then used to influence their behaviour through targeted advertising, without the user having made a clear, conscious choice to be tracked in that way.

[1] for a valid, clearly identified ethical concern (privacy, lack of genuinely informed consent, manipulation or targeting of vulnerable users); [1] for a developed explanation of why it is an ethical, not merely a legal, issue.

The correct HTML element for embedding an image is , with the image file referenced via its src attribute, e.g. . is not a valid HTML tag.

[1] for selecting B.

The anchor tag , with an href attribute giving the destination URL (e.g. Next), creates a hyperlink. is used to link external resources such as stylesheets, not clickable page links; href is an attribute, not a tag; groups navigation links but does not itself create a hyperlink.

[1] for selecting C.

[1] for selecting B.

HTML defines six heading levels, to , with representing the largest, most important heading. The other options are not valid HTML tag names.

[1] for selecting A.

Buffering is the process (and the visible pause) of temporarily storing a portion of streamed data locally before it is played back, so that playback can continue smoothly even if the network connection briefly slows. Buffering pauses occur more often when the available network bandwidth is lower than the bitrate the video stream requires, because data cannot be downloaded fast enough to keep the playback buffer full.

[1] for a valid definition of buffering; [1] for a valid factor increasing its frequency (low bandwidth, high video bitrate/resolution, network congestion).

A wireframe is a simple, low-fidelity sketch or diagram showing the basic layout, structure and placement of elements on each screen, without visual styling or working functionality. Using a wireframe at this early stage allows the designer, client and users to review and change the layout quickly and cheaply, since no code has been written yet — mistakes are far more costly to fix once development has begun.

[1] for a valid prototyping method (wireframe, storyboard, low-fidelity mock-up); [1] for a valid, well-explained benefit of prototyping before development (cheaper/faster to change, early user feedback).

A touchscreen interactive kiosk application, combining short video clips, animations and simple quizzes, would be suitable. This is justified because a walk-up exhibition audience needs content that is quick to engage with and does not require prior instructions; interactivity (e.g. letting visitors sort virtual waste items) actively involves them rather than passively presenting information, improving both engagement and retention of the recycling message.

[1] for a valid, relevant digital application suited to the scenario; [1] for a developed justification linking the application's features to the exhibition audience/purpose.

This describes a flowchart, which uses standard symbols to represent the sequence of screens and the decision points between them. Producing it before development begins allows the whole team to check that every possible user decision leads somewhere sensible and that no screen or path has been forgotten, catching logical design problems while they are still cheap and easy to fix.

[1] for correctly naming flowchart (or storyboard, if justified by the decision-sequence description); [1] for a valid benefit of early design tools; [1] for developing that benefit with reference to catching errors early; [1] for a clear, well-expressed answer overall.

A natural user interface (NUI) is a way of interacting with a device that mimics natural human behaviour, such as touch, gesture, or speech, rather than requiring learned, indirect input methods such as a keyboard and mouse. For example, a touchscreen tablet allows a user to tap, pinch and swipe directly on the content they see, which most users find intuitive with little or no instruction, because it closely resembles how people physically interact with real objects.

[1] for a correct definition of NUI (intuitive/natural interaction, contrasted with keyboard/mouse); [1] for a correctly named example technology (touchscreen, gesture control, voice recognition); [1] for explaining why the example is 'natural' (mimics real-world action); [1] for a clear, developed overall answer.

Effective GUI (Graphical User Interface) design is generally guided by several key principles. Consistency means using the same layout, colours, icons and terminology throughout an interface, so users can transfer what they learn on one screen to another rather than relearning it each time. Clear visual hierarchy uses size, colour and position to draw the user's attention to the most important elements first (e.g. a prominent 'Buy Now' button), helping users complete tasks efficiently. Feedback means the interface clearly confirms the result of a user's action (e.g. a button changing colour when clicked, or a confirmation message after a form is submitted), reassuring the user that the system has responded correctly. Simplicity and familiarity mean avoiding unnecessary clutter and using widely-recognised conventions (e.g. a magnifying glass icon for search), reducing the mental effort a user needs to understand and operate the interface. These principles matter for user experience because a GUI that follows them is faster and less error-prone to use, reduces user frustration and abandonment, and increases user confidence and satisfaction, which is especially important for users who are not confident with technology.

Level-of-response mark scheme (4 marks). Level 0 [0]: not worthy of credit. Level 1 [1]: basic mention of one principle with little or no explanation of its importance; limited specialist terms. Level 2 [2–3]: satisfactory description of two or more principles (e.g. consistency, feedback, visual hierarchy, simplicity) with some explanation of why they matter to the user; some specialist terminology used correctly. Level 3 [4]: comprehensive description of several principles, each clearly linked to a specific benefit for user experience (fewer errors, faster task completion, increased confidence/satisfaction); accurate specialist terminology; clear, well-structured response.

This describes a storyboard, a sequence of panels (similar to a comic strip) that shows each screen a user encounters along with notes describing their actions and the app's responses. A storyboard is more useful than a wireframe when the aim is to communicate the flow and narrative of the user's journey through multiple screens over time, whereas a wireframe is better suited to showing the detailed static layout of a single screen.

[1] for correctly naming storyboard; [1] for a valid situation where it is more useful than a wireframe; [1] for a clear comparison/justification referencing the sequential/user-journey nature of a storyboard.

This is voice (speech) input, a natural interface modality that recognises and interprets spoken commands. One limitation of relying on it alone is that speech-recognition accuracy can drop significantly in noisy environments or when interpreting unfamiliar accents and speech patterns, leading to misunderstood commands; it also offers no discreet or private way to interact when other people are present, unlike touch or text input.

[1] for correctly identifying voice/speech input as the modality; [1] for a valid limitation of that modality; [1] for developing the limitation with a clear example/reason.

This breaches the principle of consistency, which states that an interface should use the same visual style, layout conventions and interactive elements throughout, so that a user's understanding of one screen transfers directly to the next. When icon styles, colours and button shapes vary between screens, users cannot rely on previously learned patterns; they must consciously re-examine each new screen to work out how to interact with it, which slows task completion, increases the likelihood of mistakes (e.g. tapping the wrong control) and can make the app feel unpolished or untrustworthy.

[1] for correctly naming consistency as the principle breached; [1] for a valid negative effect on users (confusion, slower task completion, more errors); [1] for developing a clear link between the inconsistency described and that effect.

The statement selects the Name and Age columns from tblMember, restricted using a WHERE clause to only rows where MembershipType equals 'Junior'. Applied to the sample data this would return A. Doyle (17) and C. Osei (16).

[1] SELECT with the correct field list (Name, Age); [1] FROM tblMember; [1] WHERE clause present; [1] correct condition MembershipType = 'Junior'. Accept equivalent valid SQL syntax/quoting conventions.

The statement selects Name and Age from every row of tblMember, and ORDER BY Age DESC sorts the results by Age in descending order, so the oldest member (D. Reyes, 45) appears first and the youngest (C. Osei, 16) appears last.

[1] SELECT with correct field list; [1] FROM tblMember; [1] ORDER BY Age; [1] DESC used correctly to sort oldest to youngest. Accept ASC with fields reversed only if the candidate explicitly notes it sorts youngest-first (then only 3 marks maximum, as it does not answer the question as set).

COUNT(*) counts the number of rows returned; restricting with WHERE Activity = 'Swimming' means only Swimming bookings are counted. Applied to the sample data, this returns 2 (K101 and K103).

[1] correct use of an aggregate function (COUNT); [1] correct table/WHERE clause referencing Activity = 'Swimming'; [1] statement is syntactically complete and valid.

This statement selects the Name field from tblMember for every record where Age is less than 18. From the sample data, A. Doyle (17) and C. Osei (16) both satisfy Age < 18; B. Kaur (34) and D. Reyes (45) do not.

[2] for correctly identifying both A. Doyle and C. Osei with no extras; [1] for identifying only one of the two correct names, or including an incorrect additional name.

Since Activity and BookingDate are stored in tblBooking, and each booking record already stores the MemberID directly, the statement filters tblBooking rows where MemberID = 'M03', returning Badminton, 2026-06-02.

[1] correct field list (Activity, BookingDate); [1] correct table (tblBooking); [1] correct WHERE condition (MemberID = 'M03').

In a mail merge, the main document is the fixed template text that stays the same for every letter, while the data source supplies the variable information that changes from one copy to the next. tblMember would be used as the data source because it holds the individual Name and MembershipType values for each member that need to be automatically inserted into the standard letter template.

[1] for correctly identifying tblMember as the data source (not the main document); [1] for correctly explaining what a data source provides in a mail merge; [1] for linking this specifically to the Name/MembershipType fields in tblMember.

A merge field, such as <>, acts as a placeholder within the fixed template text. When the mail merge is carried out, the software replaces each merge field with the actual value taken from the matching column of the data source for that particular record, so each generated letter is personalised without the template itself needing to be rewritten.

[1] for identifying a merge field as a placeholder; [1] for explaining it is replaced with a value from the data source; [1] for explaining this happens individually per record, producing personalised output.

For MemberID M04, tblMember gives Name = D. Reyes and MembershipType = Senior, so the merge fields <> and <> are replaced with these values, producing the output: "Dear D. Reyes, your Senior membership is due for renewal."

[2] for the correct full sentence with both values correctly substituted; [1] for correctly substituting only one of the two merge fields.

The student could apply lossy compression and/or reduce the images' pixel dimensions to the actual size they will be displayed at on the page, significantly reducing each image's file size. This improves the website because smaller image files download more quickly, reducing page load time, which improves the user experience (particularly on mobile or slower connections) and can also improve search engine ranking, since load speed is a ranking factor.

[1] for a valid optimisation technique (compression, resizing to display dimensions, choosing an appropriate file format); [1] for explaining the resulting effect (faster page load); [1] for a further valid benefit (better user experience, improved SEO, lower bandwidth/hosting cost).

The developer should thoroughly test the app on real devices running both Android and iOS, rather than assuming that a feature working on one platform will automatically work identically on the other. This matters because the two operating systems differ in screen sizes and resolutions, available hardware sensors, and how they handle permissions, navigation gestures and background processes, so a feature that works perfectly on one platform can behave unexpectedly, look incorrectly laid out, or fail entirely on the other if it has not specifically been tested there.

[1] for valid cross-platform advice (test on both platforms, use a cross-platform framework, follow each platform's design guidelines); [1] for explaining why differences between platforms cause problems; [1] for a developed, specific example of a difference (screen size, permissions model, navigation conventions).

A file containing HyperText Markup Language is saved with the extension .html (or the older three-letter form .htm), which tells the operating system and web browser how to interpret and render the file's contents.

[1] for .html or .htm; [1] for correctly explaining that the extension identifies the file type/how it should be opened or rendered.

Increasing the level of (lossy) compression applied to an image reduces its file size, which is beneficial because it makes the web page load more quickly. However, this comes at the cost of image quality — heavier compression introduces more visible artefacts, blurring or blockiness, particularly noticeable on a full-width background image. The developer must therefore balance faster loading against acceptable visual quality, often by testing different compression levels to find where quality only just remains acceptable.

[1] for correctly stating the benefit of higher compression (smaller file, faster load); [1] for correctly stating the cost (reduced visual quality/artefacts), framed as a trade-off.

The developer should use responsive design techniques, such as CSS media queries and flexible (percentage- or relative-unit-based) layouts, so that page elements automatically resize, reflow or rearrange depending on the width of the screen displaying them. This ensures the same underlying page works correctly whether it is viewed on a wide desktop monitor or a narrow mobile phone screen, rather than requiring a completely separate version of the site for each device type.

[1] for correctly naming responsive design/media queries as the technique; [1] for a valid brief explanation of how it adapts layout to different screen sizes.

An animation showing the layers of the Earth, magma rising through a chamber, pressure building, and the eruption occurring, would be a good choice. This is justified because volcanic formation happens underground over a process that cannot be directly observed or easily explained in static text; a step-by-step animation can simplify and visually sequence the process in a way that is more engaging and easier for young children to follow than reading a written explanation.

[1] for a valid, relevant multimedia component (animation, video, interactive diagram); [1] for a justification linking the component's features to explaining a process; [1] for further development linking specifically to the young-child audience; [1] for a clear, well-expressed overall answer.

This is a conditional (IF...THEN...ENDIF) construct: it evaluates whether basketTotal is greater than 50, and only if this condition is true does it execute the OUTPUT statement, displaying the free-delivery message; if the condition is false, nothing is displayed and the ENDIF simply ends the construct without an action. It is described as interactive because basketTotal is not a fixed value — it changes as the user adds or removes items from their basket — so the message shown to the user responds dynamically to their own actions rather than always displaying the same fixed content.

[1] for correctly explaining the IF condition and its effect (message shown only if basketTotal > 50); [1] for correctly identifying that basketTotal changes based on user action; [1] for explaining why this makes the script 'interactive' (output responds dynamically to the user).

An event handler is a section of script code that is attached to a specific element and is triggered automatically to run whenever a defined event occurs, such as a mouse click, a key press, or a page finishing loading. For example, a 'Submit' button on a form could have a click event handler attached to it, which runs a validation script to check the form fields are correctly filled in as soon as the user clicks the button, rather than the script running constantly or at a fixed time.

[1] for a correct definition of an event handler (code that runs in response to a specific event); [1] for a valid named example event (click, page load, key press); [1] for a developed, coherent example scenario showing the event handler in use.

The tag creates a hyperlink, with the visible clickable text being 'About Us'. The href attribute specifies the destination of the link — here, the file about.html — so clicking the link navigates the browser to that page. The target="_blank" attribute instructs the browser to open the destination page in a new tab or window, leaving the original page still open, rather than the default behaviour of replacing the current page.

[1] for correctly identifying this creates a hyperlink with visible text 'About Us'; [1] for correctly explaining href (destination of the link); [1] for correctly explaining target="_blank" (opens in a new tab/window); [1] for a clear, complete overall explanation.

Organising files by type into folders (e.g. images, scripts) keeps related files grouped together, which makes them much easier to locate, update or replace as the website grows to contain many files. It also reduces the risk of accidental filename clashes (e.g. two unrelated images both being named 'photo1.png'), and makes the relative file paths referenced in the HTML and CSS clearer and more logically structured, which improves the long-term maintainability of the site.

[1] for a valid benefit of folder organisation (easier to locate/manage files, avoids naming conflicts); [1] for a second, distinct valid benefit; [1] for linking the benefit(s) clearly to maintainability or scalability of the website.

The tag defines a table structure. Each (table row) tag defines one row within it. Within the first , the (table header) tags define header cells, which browsers typically display in bold and centred, labelling the columns 'Item' and 'Price'. Within the second , the (table data) tags define ordinary data cells holding the actual values, 'Pen' and '£1'.

[1] for correctly explaining and (defines the table and its rows); [1] for correctly distinguishing (header cell) from (data cell); [1] for correctly describing the resulting visible table content (a header row of Item/Price above a data row of Pen/£1).

Normal test data is a value that is clearly expected and valid for everyday use, such as 30. Extreme (boundary) test data is a value right at the very limit of what should be accepted, such as 0 or 120, to check the field correctly includes the boundary itself. Erroneous test data is a value that should be rejected by validation, such as -5 (out of range) or "abc" (not numeric), to check the field correctly refuses invalid input.

[1] valid normal test data value; [1] valid extreme/boundary test data value (0 or 120); [1] valid erroneous test data value; [1] for correctly explaining what each type of test data checks for.

To test the Send button, valid data would first be entered into every required field of the contact form, and the button clicked; the tester would then check that the expected result occurs, such as a confirmation message being displayed to the user and the message data actually being received/stored correctly. The button should also be tested with required fields left empty or containing invalid data, to check that validation correctly prevents the form being submitted and that an appropriate error message is shown instead.

[1] for testing with valid data and checking the expected successful result occurs; [1] for testing with invalid/missing data and checking validation correctly blocks submission; [1] for referencing an appropriate observable outcome (confirmation message, data received, error shown); [1] for a clear, complete overall testing description.

Black-box testing treats the system under test as a 'black box': the tester provides inputs and checks whether the outputs/behaviour are as expected, without any knowledge of or reference to the internal code. White-box testing, by contrast, requires knowledge of the internal code structure, and involves testing specific logic paths, conditions and code statements directly. For testing that a login form correctly accepts a valid username and password, black-box testing is more appropriate, because the tester only needs to enter data and observe whether the expected outcome (successful login) occurs, without needing to inspect how the authentication code is internally written.

[1] for a correct definition of black-box testing; [1] for a correct definition of white-box testing; [1] for correctly identifying black-box as more appropriate for this scenario; [1] for a valid justification of that choice.

Normal test data for a drop-down field is simply one of the valid options already provided, such as selecting 'Email'; this checks the field correctly accepts and records a legitimate choice. Erroneous test data would be attempting to submit the form with no option selected (if a selection is mandatory), to check that the required-field validation correctly prevents submission and displays an appropriate error message.

[1] valid normal test data (a listed option); [1] valid erroneous test data (no selection made, or an attempt to submit an invalid/unlisted value); [1] for correctly explaining what each item of test data is checking for.

Unit testing focuses on testing individual, small components in isolation — for example, checking that a single form-validation function correctly rejects an invalid email address, without concern for the rest of the site. System testing, by contrast, tests the website as a complete, integrated whole, checking that all of its pages, components and features work correctly together as a user would actually experience them, for example that navigating from the homepage through to a completed order works end-to-end.

[1] for a correct definition of unit testing (individual components tested in isolation); [1] for a correct definition of system testing (the whole integrated system tested together); [1] for a clear contrast/example distinguishing the two.

One evaluation criterion is usability: whether parents, who may have a wide range of technical ability, can navigate to and understand their child's timetable quickly and without confusion or the need for help. A second evaluation criterion is fitness for purpose: whether the finished website actually meets the original requirements set by the school, correctly and reliably displaying accurate, up-to-date timetable data for the intended audience (parents) on the range of devices they are likely to use.

[1] first valid evaluation criterion named; [1] developed explanation of that criterion applied to this scenario; [1] second valid, distinct evaluation criterion named; [1] developed explanation of that criterion applied to this scenario.

A 12-second load time is inefficient because research consistently shows that users expect web pages to load within a few seconds, and a significant proportion will abandon a page (leave the site) if it takes noticeably longer than this, directly harming user engagement and, for a commercial site, potential revenue. One improvement would be to optimise the resources being loaded — for example, compressing and correctly sizing images, minifying CSS/JavaScript files, and reducing the number of separate files the browser must request — so that the total amount of data needed before the page can display is significantly reduced.

[1] for correctly identifying that slow load times cause user abandonment/poor usability; [1] for further developing why this matters (engagement, revenue, reputation); [1] for a valid, relevant efficiency improvement (image/resource optimisation, code minification, caching); [1] for a clear explanation of how that improvement reduces load time.

Accessibility matches definition (ii): it concerns designing digital products so that they can be used effectively by people with a wide range of abilities, including visual, hearing, motor or cognitive impairments.

[1] for (ii).

Responsive design matches definition (i): the page layout automatically rearranges and resizes itself to remain usable and well presented across a range of screen sizes and devices.

[1] for (i).

A podcast matches definition (ii): it is a series of episodic audio (or sometimes video) recordings, typically distributed online and available for listeners to download or stream, often by subscribing to receive new episodes automatically.

[1] for (ii).

Augmented reality matches definition (ii): it overlays digital content, such as graphics, animations or information, onto a live view of the user's real-world surroundings, typically viewed through a phone camera or headset, rather than replacing that real-world view entirely (which describes virtual reality).

[1] for (ii).

An e-book matches definition (i): it is a digital publication formatted to be read on an electronic device, such as a dedicated e-reader, tablet, or smartphone, rather than printed on paper.

[1] for (i).

score is set to 42. The condition score > 50 is tested: 42 > 50 is FALSE, so the ELSE branch executes.

OUTPUT "FAIL" is executed, so the program outputs FAIL.

[1] B correctly selected (FAIL), based on a correct trace showing score = 42 fails the condition score > 50 so the ELSE branch is taken.

Trace of num:
num = 5
num = num + 3 -> num = 5 + 3 = 8
num = num * 2 -> num = 8 * 2 = 16

OUTPUT num outputs 16.

[1] C correctly selected (16), based on a correct trace: 5, then 8 after the addition, then 16 after the multiplication.

age = 15 and hasTicket = TRUE.

Outer condition: age >= 12 -> 15 >= 12 is TRUE, so the nested IF is evaluated.
Inner condition: hasTicket = TRUE -> TRUE = TRUE is TRUE, so OUTPUT "ENTRY ALLOWED" executes.

[1] A correctly selected (ENTRY ALLOWED), based on a correct trace showing both the outer condition (age >= 12) and the inner condition (hasTicket = TRUE) evaluate to TRUE.

a = 7, b = 4.

(a + b) = 7 + 4 = 11
(a + b) * 2 = 11 * 2 = 22
a MOD b = 7 MOD 4 = 3 (remainder when 7 is divided by 4)
result = 22 - 3 = 19

OUTPUT result outputs 19.

[1] A correctly selected (19), based on a correct trace: (7 + 4) * 2 = 22, 7 MOD 4 = 3, 22 - 3 = 19.

Trace table:
i = 1 -> i * i = 1 -> OUTPUT 1
i = 2 -> i * i = 4 -> OUTPUT 4
i = 3 -> i * i = 9 -> OUTPUT 9
i = 4 -> i * i = 16 -> OUTPUT 16
i = 5 -> i * i = 25 -> OUTPUT 25
The loop ends as i exceeds 5.

Full output, in order: 1, 4, 9, 16, 25.

[1] All five output values (1, 4, 9, 16, 25) correctly traced and given in the correct order. Accept the values listed on separate lines or separated by spaces/commas; reject if any value is incorrect, if the order is wrong, or if the loop bound is misapplied (e.g. a sixth value given).

Trace table:
count = 10 -> condition 10 > 0 is TRUE -> OUTPUT 10 -> count becomes 10 - 3 = 7
count = 7 -> condition 7 > 0 is TRUE -> OUTPUT 7 -> count becomes 7 - 3 = 4
count = 4 -> condition 4 > 0 is TRUE -> OUTPUT 4 -> count becomes 4 - 3 = 1
count = 1 -> condition 1 > 0 is TRUE -> OUTPUT 1 -> count becomes 1 - 3 = -2
count = -2 -> condition -2 > 0 is FALSE -> loop ends

Full output, in order: 10, 7, 4, 1.

[1] All four output values (10, 7, 4, 1) correctly traced and given in the correct order. Accept values listed with spaces, commas or on separate lines; reject a trace that includes an extra iteration (e.g. outputting -2) or omits an iteration, or that contains an incorrect value.

Trace table:
Before loop: total = 0
n = 1 -> total = 0 + 1 = 1
n = 2 -> total = 1 + 2 = 3
n = 3 -> total = 3 + 3 = 6
n = 4 -> total = 6 + 4 = 10
n = 5 -> total = 10 + 5 = 15
n = 6 -> total = 15 + 6 = 21
The loop ends as n exceeds 6.

OUTPUT total outputs 21.

[1] Final accumulated value of total correctly traced as 21, with correct working shown for each iteration. Accept the answer 21 alone as sufficient for the mark; reject a value resulting from an off-by-one loop bound (e.g. 15, from stopping after n = 5, or 28, from an extra iteration to n = 7).

DECLARE age AS INTEGER
DECLARE validInput AS BOOLEAN
validInput = FALSE
WHILE validInput = FALSE DO
OUTPUT "Enter age (0-120): "
INPUT age
IF age >= 0 AND age <= 120 THEN
validInput = TRUE
ELSE
OUTPUT "Invalid age. Please try again."
ENDIF
ENDWHILE
OUTPUT "Age accepted: ", age

[1] variables declared appropriately (e.g. age as INTEGER, a boolean flag such as validInput). [1] correct loop construct (WHILE/REPEAT) that continues until a valid age has been entered. [1] correct INPUT statement placed inside the loop to obtain the age from the user. [1] correct IF condition testing the lower bound (age >= 0). [1] correct IF condition testing the upper bound (age <= 120), combined correctly with the lower-bound test (e.g. using AND, or as nested IFs). [1] appropriate error message output on invalid entry, and the algorithm correctly exits the loop and outputs the accepted age once valid. Accept any equivalent working construct (e.g. REPEAT...UNTIL, or nested IFs instead of a combined AND condition); reject a version with an off-by-one boundary error (e.g. age > 0 instead of age >= 0, or age < 120 instead of age <= 120).

DECLARE score AS INTEGER
DECLARE grade AS STRING
INPUT score
IF score >= 90 THEN
grade = "A*"
ELSE
IF score >= 80 THEN
grade = "A"
ELSE
IF score >= 70 THEN
grade = "B"
ELSE
IF score >= 60 THEN
grade = "C"
ELSE
IF score >= 50 THEN
grade = "D"
ELSE
grade = "U"
ENDIF
ENDIF
ENDIF
ENDIF
ENDIF
OUTPUT grade

[1] correct INPUT statement to obtain the candidate's score. [1] correct outer IF condition (score >= 90) correctly assigning grade A*. [1] correctly nested ELSE...IF structure cascading downward through the remaining grade boundaries (accept an equivalent ELSEIF construct if used consistently). [1] at least three of the remaining grade boundaries (80, 70, 60, 50) correctly tested and assigned (A, B, C, D). [1] correct final ELSE branch assigning grade U for any score below 50. [1] correct OUTPUT statement for the grade, with all IF statements correctly closed (ENDIF) and no gaps or overlaps in the boundary conditions. Accept equivalent syntax, e.g. ELSEIF instead of nested ELSE IF; reject an algorithm where boundary conditions overlap (e.g. using > instead of >= causing a boundary score to be misclassified) or leave a gap.

DECLARE mark AS INTEGER
DECLARE i AS INTEGER
DECLARE meritCount AS INTEGER
meritCount = 0
FOR i = 1 TO 10
OUTPUT "Enter mark for student ", i
INPUT mark
IF mark >= 70 THEN
meritCount = meritCount + 1
ENDIF
ENDFOR
OUTPUT "Number of students achieving Merit: ", meritCount

[1] correct loop construct that repeats exactly 10 times (e.g. FOR i = 1 TO 10, or an equivalent WHILE loop with a counter). [1] correct INPUT statement placed inside the loop to obtain each mark. [1] correct IF condition (mark >= 70) to test for a Merit. [1] correct counter/accumulator increment (meritCount = meritCount + 1) placed inside the IF statement. [1] correct initialisation of meritCount to 0 before the loop begins, and a correct final OUTPUT statement after the loop ends showing the total. Accept any valid loop construct (FOR/WHILE/REPEAT) that correctly processes exactly 10 marks; reject an algorithm where the counter is not initialised to zero before the loop, or where the OUTPUT occurs inside the loop rather than after it completes.

Assign place values to each bit position (from left, most significant bit, to right, least significant bit):

Place value: 128 64 32 16 8 4 2 1
Bit pattern: 1 0 1 1 0 1 0 1

Only the bits set to 1 contribute to the total:
128 + 32 + 16 + 4 + 1 = 181

So \( 10110101_2 = 181_{10} \).

[1] correct place values assigned to each of the 8 bit positions (128, 64, 32, 16, 8, 4, 2, 1). [1] correct identification of the bit positions set to 1 (128, 32, 16, 4, 1). [1] correct summation shown as working (128 + 32 + 16 + 4 + 1). [1] correct final denary answer of 181. Accept alternative valid methods (e.g. doubling method) provided working is shown and the final answer is correct.

Repeatedly divide by 16 and record the remainders:

202 divided by 16 = 12 remainder 10 (10 in hexadecimal is A)
12 divided by 16 = 0 remainder 12 (12 in hexadecimal is C)

Reading the remainders from last to first gives the hexadecimal digits: C then A.

Check: \( C_{16} \times 16 + A_{16} \times 1 = 12 \times 16 + 10 = 192 + 10 = 202 \)

So \( 202_{10} = CA_{16} \).

[1] correct division of 202 by 16 giving quotient 12 remainder 10. [1] correct division of 12 by 16 giving quotient 0 remainder 12. [1] correct conversion of remainders 10 and 12 to hex digits A and C respectively. [1] correct final answer CA (or 0xCA / CA16), with digits given in the correct order. Accept an equivalent method via binary (202 = 11001010 in binary, split into nibbles 1100 1010 = C A); reject if the digit order is reversed (e.g. AC).

Line up the two 8-bit numbers and add column by column from the right (least significant bit), carrying into the next column where necessary:

1 0 1 1 1 0 1 1
+ 0 1 1 0 1 1 1 0

Working through each column from the rightmost bit:
Column 1 (rightmost): 1 + 0 = 1, no carry
Column 2: 1 + 1 = 10 -> write 0, carry 1
Column 3: 0 + 1 + 1 (carry) = 10 -> write 0, carry 1
Column 4: 1 + 1 + 1 (carry) = 11 -> write 1, carry 1
Column 5: 1 + 0 + 1 (carry) = 10 -> write 0, carry 1
Column 6: 1 + 1 + 1 (carry) = 11 -> write 1, carry 1
Column 7: 0 + 1 + 1 (carry) = 10 -> write 0, carry 1
Column 8 (leftmost): 1 + 0 + 1 (carry) = 10 -> write 0, carry 1

8-bit result: 00101001
There is a final carry of 1 out of column 8 (the most significant bit), which cannot be stored in an 8-bit register.

So \( 10111011_2 + 01101110_2 = 00101001_2 \) (in 8 bits), with a carry-out of 1, meaning an overflow occurs. The true sum (297 in denary) is too large to fit in 8 bits, which can hold at most 255 unsigned.

[1] correct addition of at least the lowest 4 bits shown with correct carries. [1] correct addition of the remaining 4 bits shown with correct carries. [1] correct final 8-bit result of 00101001. [1] correct identification that overflow occurs, because a carry is generated out of the most significant bit and cannot be represented in 8 bits. Accept working shown as a carry row above the addition; reject the answer if overflow is not explicitly stated even if the sum bits given are correct.

Convert each hexadecimal digit to its 4-bit (nibble) binary equivalent:

3 = \( 0011_2 \)
F = \( 1111_2 \)

Combine the nibbles in the same order as the original hex digits: 0011 1111

So \( 3F_{16} = 00111111_2 \).

Check: \( 3F_{16} = 63_{10} \), and \( 63_{10} = 00111111_2 \) (32 + 16 + 8 + 4 + 2 + 1 = 63).

[1] correct conversion of digit 3 to the nibble 0011. [1] correct conversion of digit F to the nibble 1111. [1] correct nibbles combined in the correct order to give 00111111. [1] answer expressed as a full 8-bit binary number, including the leading zero. Accept working shown via denary conversion (3F16 = 63, 63 = 00111111 in binary); reject if the nibble order is reversed or the leading zero is omitted, giving fewer than 8 bits.

A | B | C | A AND B | X = (A AND B) OR C
0 | 0 | 0 | 0 | 0
0 | 0 | 1 | 0 | 1
0 | 1 | 0 | 0 | 0
0 | 1 | 1 | 0 | 1
1 | 0 | 0 | 0 | 0
1 | 0 | 1 | 0 | 1
1 | 1 | 0 | 1 | 1
1 | 1 | 1 | 1 | 1

[1] correct A AND B column for all 8 rows. [1] correct final output X for the rows where C = 0 (rows ABC = 000, 010, 100, 110). [1] correct final output X for the rows where C = 1 (rows ABC = 001, 011, 101, 111). [1] all 8 rows completed correctly with no errors. Accept any consistent row ordering as long as all 8 input combinations are present and correctly evaluated; reject a table with fewer than 8 rows.

Procedural programming structures a program as a sequence of procedures/functions that operate on data, often shared as global variables, and is executed largely top-down.

Object-oriented programming structures a program as a set of objects, created from classes, which bundle together data (attributes) and the procedures that act on that data (methods). It uses features such as encapsulation (hiding an object's internal data from the rest of the program), inheritance (creating new classes based on existing ones) and polymorphism.

Applied to this scenario: because the stock-control system is large, long-lived and will be worked on by a team of developers over many years, OOP is generally more suitable. Encapsulation means that a change made to one class's internal implementation is less likely to introduce unintended side effects elsewhere in the system, which is important when many developers are editing different parts of the code. Inheritance allows existing classes (e.g. a general Product class) to be reused and extended (e.g. into PerishableProduct, ElectronicProduct) rather than duplicating code, reducing development time as the system grows.

Procedural programming, by contrast, tends to become harder to manage as a codebase grows, since procedures often rely on shared global data, and it is easy for a change in one procedure to unintentionally affect the behaviour of another, which is a particular risk on a large system maintained by multiple developers over time.

Recommendation: object-oriented programming is the more suitable paradigm for this stock-control system, primarily because of its support for maintainability and extensibility on a large, collaboratively developed, long-lived codebase.

[1] accurate description of procedural programming (sequence of procedures/functions operating on data, often using global/shared data). [1] accurate description of object-oriented programming (objects/classes bundling data and methods; reference to at least one OOP feature such as encapsulation, inheritance or polymorphism). [1] valid point in favour of OOP specific to this scenario (e.g. encapsulation limits unintended side effects across a team; inheritance supports reuse/extension as the system grows). [1] valid point highlighting a limitation of procedural programming for this scenario (e.g. shared global data becomes harder to manage safely as a large codebase is extended by multiple developers). [1] clear, justified recommendation of OOP for this scenario, directly supported by at least one of the above points. Accept a recommendation of procedural programming only if it is fully and validly justified against the scenario; reject generic paradigm descriptions with no link to the stock-control scenario.

A compiler translates the entire source code program into machine code in one go, before the program is run, producing a standalone executable file that can be run directly by the computer without the original source code or translator being present.

An interpreter translates and executes the source code line by line, at the point the program is run, meaning it must re-translate the code every time the program runs and generally requires the source code (or an intermediate form of it) and the interpreter itself to be present.

Applied to this scenario: because the game must run as fast as possible, a compiler is more appropriate, since the compiled machine code can be executed directly by the processor with no translation overhead at run time, whereas an interpreted program is slower because each line must be translated every time it is executed. In addition, because the company wants to distribute a single executable file and keep its source code private, a compiler is again more appropriate, since only the compiled machine-code file needs to be given to customers; an interpreter would typically require the source code itself to be distributed and interpreted on the user's device, exposing it.

Recommendation: a compiler is the more appropriate translator for this scenario, justified by both its faster run-time performance and its ability to keep the source code confidential.

[1] accurate description of a compiler (translates the whole program into machine code before execution, producing a standalone executable). [1] accurate description of an interpreter (translates and executes source code line by line at run time, requiring the source/translator to be present each run). [1] valid point relevant to the scenario regarding execution speed (compiled code runs faster since translation happens once in advance, suiting a game requiring maximum performance). [1] valid point relevant to the scenario regarding source-code privacy/distribution (a compiler allows distribution of a single machine-code executable without exposing source code, unlike an interpreter). [1] clear, justified recommendation of a compiler for this scenario, directly supported by at least one of the above points. Accept valid additional discussion of an assembler (translates assembly language directly to machine code) as supporting context; reject an answer that recommends an interpreter without any valid justification against the stated scenario requirements.

A syntax error occurs when code does not follow the exact rules (grammar) of the programming language, for example a missing ENDIF, a misspelt keyword, or a missing quotation mark around a string. Syntax errors are identified by the compiler or interpreter, which will not translate or run the code and will typically produce an error message indicating the line and nature of the fault. They are corrected by finding the offending line, using the error message as a guide, and rewriting the code so it follows the correct syntax of the language.

A logic error occurs when a program runs without crashing but produces incorrect results, because the algorithm itself is flawed, for example using the wrong comparison operator in a condition, or an incorrect formula. Logic errors are not detected automatically by the translator, so they are identified by testing the program with known test data and comparing the actual output to the expected output, or by using a trace table / dry run to follow the values of variables through the code step by step. They are corrected by locating the faulty line of logic (e.g. the incorrect condition or calculation) and rewriting it so the algorithm produces the correct result.

A runtime error occurs when a program is syntactically correct and starts running, but encounters a problem during execution that causes it to crash or terminate unexpectedly, for example attempting to divide a number by zero, or trying to access an array element outside its declared bounds. Runtime errors are identified because the program stops unexpectedly while running, often displaying an error message describing the operation that failed. They are corrected by identifying the operation that caused the crash and adding validation or exception handling (for example checking a divisor is not zero, or checking an index is within the array's bounds) before that operation is carried out.

This item is marked using a levels-of-response scheme.

Level 0 [0]: Response not worthy of credit / no relevant content.

Level 1 [1-2]: Demonstrates basic knowledge of programming errors. May only address one error type, or lists error types without explaining how each is identified or corrected. Limited use of grammar and spelling; little or no use of specialist terminology (e.g. "syntax", "logic", "runtime", "compiler", "interpreter", "trace table").

Level 2 [3-4]: Demonstrates satisfactory knowledge covering at least two of the three error types, with some description of how each is identified and/or corrected. Grammar and spelling are satisfactory, with a developing but inconsistent use of specialist terms.

Level 3 [5-6]: Comprehensive description covering all three error types (syntax, logic, runtime), with accurate explanation of how a programmer would identify each (e.g. syntax errors flagged by the translator/IDE before the program runs; logic errors found by comparing actual output to expected output using test data or a trace table; runtime errors identified by the program crashing or producing an error message during execution) and how each would be corrected (e.g. correcting invalid syntax/keywords/punctuation; correcting faulty conditions, calculations or loop bounds; adding validation or exception handling to prevent invalid operations such as division by zero). The answer is well structured, uses accurate specialist terminology throughout, and grammar/spelling are of a high standard.

Award marks according to the level that best fits the response as a whole; use the full range of marks within a level to reflect the extent to which the response meets the level descriptor.

DECLARE temperatures AS ARRAY[1:6] OF INTEGER
temperatures[1] = 14
temperatures[2] = 18
temperatures[3] = 21
temperatures[4] = 19
temperatures[5] = 16
temperatures[6] = 12

[1] correct DECLARE statement giving the array an appropriate name (temperatures). [1] correct array size (6 elements) and correct data type (INTEGER) specified in the declaration. [1] temperatures[1] correctly initialised to 14. [1] temperatures[2] correctly initialised to 18 and temperatures[3] correctly initialised to 21. [1] temperatures[4] correctly initialised to 19 and temperatures[5] correctly initialised to 16. [1] temperatures[6] correctly initialised to 12. [1] all six values assigned to the correct index positions, in the exact order given, with no indices omitted or duplicated. Accept equivalent syntax, including an array-literal form such as temperatures = [14, 18, 21, 19, 16, 12], or a 0-indexed array [0:5] provided this is used consistently; reject a declaration that specifies the wrong number of elements or the wrong data type.

DECLARE numbers AS ARRAY[1:5] OF INTEGER
DECLARE i AS INTEGER
DECLARE j AS INTEGER
DECLARE temp AS INTEGER
FOR i = 1 TO 4
FOR j = 1 TO 5 - i
IF numbers[j] > numbers[j + 1] THEN
temp = numbers[j]
numbers[j] = numbers[j + 1]
numbers[j + 1] = temp
ENDIF
ENDFOR
ENDFOR
OUTPUT numbers

Worked example trace, for numbers = [5, 2, 9, 1, 4]:
Pass 1 (i=1, j=1 to 4): compares (5,2) swap -> [2,5,9,1,4]; (5,9) no swap; (9,1) swap -> [2,5,1,9,4]; (9,4) swap -> [2,5,1,4,9]
Pass 2 (i=2, j=1 to 3): (2,5) no swap; (5,1) swap -> [2,1,5,4,9]; (5,4) swap -> [2,1,4,5,9]
Pass 3 (i=3, j=1 to 2): (2,1) swap -> [1,2,4,5,9]; (2,4) no swap
Pass 4 (i=4, j=1 to 1): (1,2) no swap
Final sorted array: [1, 2, 4, 5, 9]

[1] correct outer loop controlling the number of passes through the array (FOR i = 1 TO 4, i.e. n-1 passes for an array of 5 elements). [1] correct inner loop controlling the comparisons made within each pass, with a correctly reducing range (FOR j = 1 TO 5 - i, or equivalent). [1] correct comparison condition to test whether two adjacent elements are out of order (numbers[j] > numbers[j + 1]). [1] correct use of a temporary variable to hold one value during a swap (temp = numbers[j]). [1] correct completion of the swap, in the correct order (numbers[j] = numbers[j + 1] followed by numbers[j + 1] = temp). [1] correctly nested loop structure, with the swap code placed only inside the IF statement and all loops/IF correctly closed (ENDIF/ENDFOR). [1] the algorithm as a whole correctly sorts the array into ascending order for any starting arrangement of the 5 values. Accept any equivalent correct working bubble sort, including a version using a boolean "swapped" flag for early exit, a WHILE-based construction, or 0-indexed arrays used consistently; reject an algorithm that sorts into descending order, risks an index-out-of-range error due to incorrect loop bounds, or does not fully sort the array (e.g. only a single pass).

DECLARE names AS ARRAY[1:8] OF STRING
DECLARE target AS STRING
DECLARE i AS INTEGER
DECLARE found AS BOOLEAN
found = FALSE
INPUT target
FOR i = 1 TO 8
IF names[i] = target THEN
OUTPUT "Found at position ", i
found = TRUE
ENDIF
ENDFOR
IF found = FALSE THEN
OUTPUT "Not found"
ENDIF

[1] correct INPUT statement to obtain the target value being searched for. [1] correct initialisation of a found/flag variable (e.g. found = FALSE) before the loop. [1] correct loop that iterates through every element of the array (FOR i = 1 TO 8, or equivalent). [1] correct comparison condition (names[i] = target). [1] correct OUTPUT of the position when a match is found. [1] correct setting of the found flag to TRUE when a match is found. [1] correct final IF after the loop that outputs a "not found" message when found remains FALSE. Accept an equivalent version that uses an early exit (e.g. EXIT FOR) on finding a match, or a WHILE loop with a boolean condition; reject a version that stops searching after the first comparison regardless of match (failing to check all elements) unless an early exit on match is correctly implemented.

DECLARE scores AS ARRAY[1:10] OF INTEGER
DECLARE target AS INTEGER
DECLARE low AS INTEGER
DECLARE high AS INTEGER
DECLARE mid AS INTEGER
DECLARE found AS BOOLEAN
low = 1
high = 10
found = FALSE
INPUT target
WHILE low <= high AND found = FALSE DO
mid = (low + high) DIV 2
IF scores[mid] = target THEN
OUTPUT "Found at position ", mid
found = TRUE
ELSE
IF scores[mid] < target THEN
low = mid + 1
ELSE
high = mid - 1
ENDIF
ENDIF
ENDWHILE
IF found = FALSE THEN
OUTPUT "Not found"
ENDIF

[1] correct initialisation of low and high pointers to the bounds of the array (low = 1, high = 10). [1] correct loop condition that continues while low <= high (and the search has not yet succeeded). [1] correct calculation of the midpoint (mid = (low + high) DIV 2). [1] correct comparison of scores[mid] to target and correct OUTPUT when a match is found. [1] correct adjustment of low when scores[mid] < target (low = mid + 1). [1] correct adjustment of high when scores[mid] > target (high = mid - 1). [1] correct final "not found" message output when the loop ends without a match. Accept equivalent integer-division notation (e.g. "//" in place of DIV); reject an algorithm that does not correctly adjust both low and high (this would not be a valid binary search), or that does not require the array to be sorted.

DECLARE basketScores AS ARRAY[1:5] OF INTEGER
DECLARE i AS INTEGER
DECLARE total AS INTEGER
DECLARE average AS REAL
basketScores[1] = 23
basketScores[2] = 45
basketScores[3] = 12
basketScores[4] = 38
basketScores[5] = 27
total = 0
FOR i = 1 TO 5
total = total + basketScores[i]
ENDFOR
average = total / 5
OUTPUT "Total: ", total
OUTPUT "Average: ", average

Check: total = 23 + 45 + 12 + 38 + 27 = 145. average = 145 / 5 = 29.

[1] correct DECLARE statement for the array with correct data type. [1] correct initialisation of all 5 elements with the stated values, in the correct order. [1] correct initialisation of total to 0 before the loop. [1] correct loop that iterates through all 5 elements (FOR i = 1 TO 5, or equivalent). [1] correct accumulation statement (total = total + basketScores[i]) inside the loop. [1] correct calculation of the average (average = total / 5). [1] correct OUTPUT of both total and average after the loop has completed. Accept correct working showing total = 145 and average = 29; reject an average calculated using integer division producing an incorrect truncated result without acknowledgement, or an array length that is hard-coded incorrectly.

(a) INTEGER - the number of books borrowed is always a whole number, with no fractional part.
(b) REAL - an average expressed to 2 decimal places requires a data type that can store a fractional/decimal value.
(c) STRING - the ISBN contains hyphens and is not used in any calculation, so it should be stored as text; storing it as a number could also incorrectly drop a leading zero.
(d) BOOLEAN - availability has only two possible states, TRUE (available) or FALSE (on loan/unavailable).
(e) STRING - a book title is alphanumeric text.
(f) REAL - a price such as £6.99 requires a data type that can store decimal values accurately to 2 decimal places.

[1] (a) INTEGER given with valid justification referring to a whole-number count. [1] (b) REAL given with valid justification referring to the need to store a decimal/fractional value. [1] (c) STRING given with valid justification (e.g. contains non-numeric characters such as hyphens, not used arithmetically, or preserves leading zeros). [1] (d) BOOLEAN given with valid justification referring to only two possible states. [1] (e) STRING given with valid justification referring to alphanumeric text. [1] (f) REAL given with valid justification referring to the need for decimal precision in a monetary value. Accept CURRENCY as an equivalent alternative to REAL for part (f) where the exam board's pseudocode allows it; reject any data type given without a valid supporting justification, and reject INTEGER for part (f) since it cannot accurately store a decimal price.

Test No. | Test Data | Type of Test | Expected Result
1 | 55 | Normal | Value accepted; no re-prompt (55 is within the valid range 0-100)
2 | 0 | Boundary | Value accepted (0 is the lowest valid value)
3 | 100 | Boundary | Value accepted (100 is the highest valid value)
4 | -1 | Erroneous | Value rejected; user re-prompted (below the lower bound)
5 | 101 | Erroneous | Value rejected; user re-prompted (above the upper bound)
6 | "abc" | Erroneous | Value rejected / error handled; user re-prompted (not a whole number)

[1] at least one normal test value within the valid range, with a correctly stated expected result. [1] a correct lower-boundary test value (0), with a correctly stated expected result. [1] a correct upper-boundary test value (100), with a correctly stated expected result. [1] a correct erroneous test value below the valid range (e.g. -1 or any negative number), with a correctly stated expected result of rejection/re-prompt. [1] a correct erroneous test value above the valid range (e.g. 101), with a correctly stated expected result of rejection/re-prompt. [1] the test plan is presented in a clear table with correctly labelled columns for test data, type of test, and expected result. Accept an additional valid erroneous example, such as non-numeric input (e.g. "abc"), as an alternative or extra erroneous case; reject a test plan where the "type of test" column is missing, incorrect, or does not distinguish normal/boundary/erroneous data.

Black-box testing is a method of testing a program based only on its inputs and expected outputs, without any reference to, or knowledge of, the program's internal code or logic. Applied to this scenario, a tester could enter a range of shopping totals and loyalty statuses as inputs (e.g. a normal total, a total of £0, a customer with and without loyalty status) and check that the bill and discount produced as output match the expected results, without looking at how the code itself calculates the discount.

White-box testing is a method of testing a program based on knowledge of its internal code structure and logic, designed to ensure that specific statements, branches or paths through the code are executed and behave correctly. Applied to this scenario, a tester with access to the source code could examine the specific IF statement or branch that applies the loyalty discount, and design test data specifically to ensure that both the "discount applied" branch and the "no discount applied" branch are each executed and tested at least once.

A key distinction between the two approaches is that black-box testing does not require the tester to understand or have access to the program's source code, whereas white-box testing requires full access to, and understanding of, the source code in order to design tests that exercise every logical path through it.

[1] accurate definition of black-box testing (based on inputs/outputs only, no knowledge of internal code). [1] a valid application of black-box testing to the billing/discount scenario (e.g. testing a range of totals/loyalty statuses as inputs and checking the output bill against expected results). [1] accurate definition of white-box testing (based on knowledge of the internal code structure/logic, designed to test specific statements/branches/paths). [1] a valid application of white-box testing to the billing/discount scenario (e.g. examining the discount IF statement/branch and designing data to execute every branch, such as discount applied vs not applied). [1] a valid point of distinction/comparison between the two approaches (e.g. black-box requires no knowledge of the source code, white-box requires full access to and understanding of the source code). [1] the answer as a whole is accurate and clearly linked to the billing/discount scenario throughout. Accept any other valid, correctly scenario-linked explanation of either testing method; reject answers that define the terms only in general terms with no application to the given scenario.

Blank 1: robustness - the ability of a system to cope with unexpected or invalid input without crashing.
Blank 2: maintainability - how easily code can be understood and changed by other programmers in the future.
Blank 3: efficiency - how well a system makes use of resources such as processing time and memory.
Blank 4: portability - how easily a system can be transferred to run on a different device/platform.

Completed passage: "Robustness refers to how well the system continues to operate correctly, without crashing, even when unexpected or invalid input is entered. Maintainability refers to how easily the system's code can be understood, updated and extended by another programmer in the future. Efficiency refers to how well the system makes use of resources, such as processing time and memory, in order to complete its tasks. Portability refers to how easily the system, or its code, can be transferred to run on a different device or operating system."

The words "reliability" and "usability" from the word list are not used.

[1] robustness correctly placed in blank 1. [1] maintainability correctly placed in blank 2. [1] efficiency correctly placed in blank 3. [1] portability correctly placed in blank 4. Accept only words taken from the given word list; reject "reliability" or "usability" in any blank, as these are distractor terms not matched by the given descriptions; award no mark for a blank left empty or completed with a word not in the list.

Robustness testing involves entering invalid, unexpected or extreme data that the program is not specifically designed to process correctly, in order to check that the program can cope with it without crashing or producing an unhandled runtime error.

For this rectangle-area program, the programmer could, for example, enter a negative number for the width (e.g. -5) or a non-numeric value such as the letters "abc" for the height. A robust program should detect that this data is invalid, for example by displaying a suitable error message and re-prompting the user for a valid value, rather than crashing or attempting to calculate an area using the invalid data (e.g. producing a nonsensical negative area).

[1] correct identification that robustness testing uses invalid, unexpected or extreme data (e.g. a negative number, a non-numeric value such as letters, a blank entry, or an extremely large number). [1] correct description of the expected outcome: the program should handle this data gracefully (e.g. by displaying an error message, rejecting the input, or re-prompting), rather than crashing or halting with an unhandled runtime error. [1] a valid example test value specific to the rectangle-area scenario (e.g. entering "abc" for the height, or -5 for the width), correctly linked to an expected robust response. Accept any other valid example of invalid/extreme data appropriate to the scenario; reject an answer describing only normal/functional testing rather than robustness testing.