2023 CCEA GCSE Digital Technology 2650 Practice Paper with Answers

A bit (binary digit) is the smallest unit of digital data, having a value of either 0 or 1. Four bits together make up a nibble, and eight bits together make up a byte.
Using the decimal convention adopted for this unit, 1000 bytes make up one kilobyte (1 KB = 1000 bytes).

1 mark: bit = a single binary digit (0 or 1); 1 mark: nibble = 4 bits; 1 mark: byte = 8 bits. 1 mark: 1 KB = 1000 bytes (decimal convention).

System software manages and controls the computer's hardware and resources so that the computer can function, for example an operating system such as Windows. Application software allows the user to carry out a specific task, for example a word processor such as Microsoft Word.
A further example of system software is a device driver (or a utility program, such as anti-virus software), which manages the computer's hardware and resources.

1 mark: system software = manages/controls hardware/resources, with a valid example (e.g. operating system); 1 mark: application software = performs a specific user task, with a valid example (e.g. word processor); 1 mark: the two are correctly and clearly distinguished from one another. 1 mark: valid further example of system software, e.g. device driver, utility software.

A field is a single category of data stored in a database table, represented as a column (for example, Surname). A record is a complete set of related field values for one entry in the table, represented as a row (for example, all the data held about one particular person).
A table is a collection of related records, organised into rows and columns, each column representing a field and each row representing one record.

1 mark: field = a single column/category of data, with a valid example; 1 mark: record = a complete row/set of related fields for one entry; 1 mark: the two are clearly and correctly distinguished. 1 mark: table = a collection of related records, organised into rows (records) and columns (fields).

A primary key is a field (or combination of fields) whose purpose is to uniquely identify every record in a table, with no two records sharing the same value. A surname is unsuitable as a primary key because it is not guaranteed to be unique: more than one person in the table could share exactly the same surname, so it would fail to reliably distinguish one record from another, making it impossible to identify a specific record with certainty.

1 mark: primary key uniquely identifies each record in the table; 1 mark: a surname could be shared by more than one person; 1 mark: this breaks the requirement that a primary key value must be unique; 1 mark: developed correctly, e.g. leading to ambiguity when trying to identify one specific record.

A relative cell reference automatically adjusts to reflect its new position when a formula containing it is copied to a different cell. An absolute cell reference, in contrast, stays fixed and does not change when the formula is copied elsewhere. A cell reference is made absolute by placing a dollar sign ($) before the column letter and/or row number, for example $B$2.

1 mark: relative reference = changes automatically when the formula is copied; 1 mark: absolute reference = stays fixed/does not change when copied; 1 mark: correct symbol, $ (dollar sign); 1 mark: correct example format given, e.g. $B$2.

The MAX function returns the highest (largest) value found within a specified range of cells. To find the highest value in the range C2:C20, the formula =MAX(C2:C20) would be entered.
The MIN function returns the lowest (smallest) value in a range. The formula would be =MIN(C2:C20).

1 mark: MAX function correctly named; 1 mark: correct formula syntax, =MAX(...); 1 mark: correct cell range referenced, C2:C20. 1 mark: correct formula, =MIN(C2:C20).

RAM (Random Access Memory) is volatile, meaning its contents are lost as soon as the power is switched off; it is used to store temporary data and programs that are currently in use. ROM (Read Only Memory) is non-volatile, meaning it retains its contents even when the power is off; it is used to store permanent data that does not need to change, such as the start-up instructions (e.g. the BIOS) needed to boot the computer.

1 mark: RAM is volatile; 1 mark: RAM stores temporary data/programs currently in use; 1 mark: ROM is non-volatile; 1 mark: ROM stores permanent data, e.g. start-up instructions/BIOS.

Arithmetic and logic operations are carried out by the Arithmetic Logic Unit (ALU), a component of the CPU. The CPU's clock speed is measured in Hertz (typically expressed in gigahertz, GHz). A higher clock speed generally means the CPU can carry out more processing cycles (instructions) every second, resulting in generally faster processing performance.
Cache memory is a small amount of very fast memory located close to (or within) the CPU. It stores copies of frequently or recently used data and instructions, so that the CPU can access them much more quickly than if it had to fetch them from the slower main memory (RAM) each time, improving overall processing performance.

1 mark: ALU/CPU correctly named; 1 mark: clock speed unit = Hertz/GHz; 1 mark: higher clock speed correctly linked to more cycles/instructions per second and generally faster processing. 1 mark: cache memory correctly explained as fast memory close to the CPU that stores frequently/recently used data, allowing quicker access than fetching from RAM.

A wireless (Wi-Fi) network has the advantage that devices can connect without physical cables, allowing greater mobility and flexibility, since devices can move around within range of the signal. A disadvantage is that a wireless connection is generally slower and less reliable than a wired connection, and is more vulnerable to signal interference and to unauthorised access/security risks.
A wired connection would be preferable where a very fast, highly reliable, low-interference connection is essential, for example for a server, or for a device carrying out large file transfers or online gaming.

1 mark: valid advantage of wireless over wired (e.g. no cables needed, greater mobility); 1 mark: valid disadvantage of wireless compared with wired (e.g. slower, less reliable, more vulnerable to interference/security risks); 1 mark: advantage and disadvantage both correctly and clearly expressed as a comparison. 1 mark: valid situation where a wired connection is preferable, e.g. where speed/reliability is critical (e.g. servers, gaming, large file transfers).

Phishing is a type of cyber attack in which a fraudulent email or message is sent to a victim, designed to trick them into revealing personal or financial information (such as passwords or bank details), or into clicking a malicious link or attachment. Phishing messages often impersonate a legitimate, trusted organisation (such as a bank) to appear convincing. A user can protect themselves by not clicking links or opening attachments from unknown or suspicious senders, and by carefully checking the sender's actual email address before responding or entering any information.

1 mark: phishing = a fraudulent message designed to trick the user into revealing information or clicking a malicious link; 1 mark: phishing messages often impersonate a legitimate/trusted organisation; 1 mark: valid protection method stated; 1 mark: protection method correctly explained/developed.

Cloud storage allows files to be accessed from any device that has an internet connection, rather than being tied to a single local device, and it protects files from being lost if the local device is lost, stolen, damaged or fails. A disadvantage of cloud storage is that an internet connection is required in order to access the files; without one, the files stored in the cloud cannot be reached.

1 mark: valid advantage 1, e.g. accessible from any device with an internet connection; 1 mark: valid advantage 2, e.g. files protected if the local device is lost/damaged; 1 mark: valid disadvantage, e.g. requires an internet connection to access files.

The collection, storage and use of personal data by organisations in the UK is governed by the Data Protection Act, which incorporates the requirements of UK GDPR. Under this legislation, individuals have several rights, including the right to access (see) the personal data an organisation holds about them.

1 mark: Data Protection Act/UK GDPR correctly named; 1 mark: a valid individual right named (e.g. right to access their data, right to have inaccurate data corrected, right to have data deleted); 1 mark: the right stated is correctly and clearly explained.

Digital technology has enabled many employees to work remotely, from home, rather than travelling to a fixed office every day. It has also led to an increased use of video conferencing software for meetings, reducing the need for business travel, and to a reduced reliance on paper-based processes, with documents now stored and shared digitally.

1 mark each for any two valid, distinct changes to office working practice caused by digital technology (e.g. remote/home working, video conferencing replacing travel, reduced paper-based processes); 1 mark for one of the two points being correctly explained/developed.

A web-based application can be accessed from any device that has a web browser and an internet connection, rather than being tied to one specific installed device. It is also automatically updated by the software provider, meaning users always have access to the latest version of the software without needing to manually install updates.

1 mark each for any two valid, distinct features of a web-based application (e.g. accessible from any device with a browser/internet, automatically updated by the provider, no local installation needed); 1 mark for one of the two points being correctly explained/developed.

RAM, cache memory and CPU registers are all volatile, temporary memory used internally during processing. Secondary storage is non-volatile storage used to hold data and programs permanently; a solid state drive (SSD) is an example of secondary storage.

[1] for C. No partial credit for a multiple-choice item.

An operating system manages hardware, a device driver allows the OS to communicate with a specific piece of hardware, and a utility performs a maintenance task; a word processor is application software, allowing the user to carry out a specific task.

[1] for C.

In a bus topology, all devices share a single central cable; in a ring topology, devices are connected in a closed loop; in a mesh topology, devices are interconnected with many others directly. A star topology connects every device individually to a central hub or switch.

[1] for C.

A primary key uniquely identifies records in its own table, an index speeds up searching, and a query retrieves data matching given criteria. A foreign key is a field that references (links to) the primary key of another table, creating a relationship between the two tables.

[1] for B.

A firewall and antivirus software are protective tools, and encryption scrambles data to keep it secure; spyware is malicious software that covertly monitors and collects information about a user's activity without their consent.

[1] for C.

Cloud storage means storing files on remote servers, owned and maintained by a third-party provider, which are accessed over the internet, rather than storing files only on a local device such as a hard drive, USB drive or optical disc.

[1] for B.

Using place values 128, 64, 32, 16, 8, 4, 2, 1, the bits set to 1 in 00010111 correspond to 16, 4, 2 and 1, giving a total of 16 + 4 + 2 + 1 = 23.

[1] for B (23), based on correctly summing the place values of the set bits (16 + 4 + 2 + 1).

Recycling at an approved facility, reselling a device, and donating a device for reuse are all environmentally responsible options. Dumping a device in general landfill risks releasing toxic materials (e.g. heavy metals) from its components into the environment.

[1] for C.

Teleworking (remote working) describes working from a location away from a traditional office, such as from home, using digital technology (e.g. video conferencing, cloud file access) to communicate and carry out work tasks.

[1] for B.

A locally installed word processor, a built-in phone calculator app, and locally installed antivirus software all run entirely on the local device. An online office suite accessed and used entirely through a web browser is an example of a web-based (cloud) application.

[1] for C.

(a) The total is calculated using =SUM(B2:B6).
(b) =B2/$B$7*100. The reference to B2 must be relative, so that it correctly changes to B3, B4, etc. as the formula is copied down; the reference to B7 (the total) must be absolute ($B$7), so that it stays fixed on the total cell and does not change as the formula is copied down to C3:C6.
(c) A pie chart is most appropriate, because it clearly shows how a whole (the total weekly sales) is divided into parts (each salesperson's share), making it easy to compare each person's proportion of the total at a glance.
(d) If the reference to B7 were left relative (not absolute), it would change as the formula was copied down: in C3 it would refer to B8 instead of B7, in C4 to B9, and so on. Since B8, B9 etc. do not contain the total sales figure (and may be empty or contain unrelated data), the percentages calculated in C3:C6 would be incorrect (e.g. producing an error or a nonsensical value), rather than each salesperson's correct percentage of the true total in B7.

(a) 1 mark: =SUM(B2:B6). [1]
(b) 1 mark: correct relative reference to B2; 1 mark: correct absolute reference to $B$7; 1 mark: correct formula structure (division, multiplied by 100, or equivalent if formatted as a percentage). [3]
(c) 1 mark: pie chart; 1 mark: valid reason relating to showing each part as a proportion of the whole. [2] (d) 1 mark: the reference to B7 would incorrectly change as the formula is copied down (e.g. to B8, B9...); 1 mark: this would produce incorrect (or erroneous) percentage results in C3:C6, since these cells do not contain the total. [2]

(a) =IF(D2>=50,"Pass","Fail"). The IF function tests the condition D2>=50; if true it displays "Pass", and if false it displays "Fail".
(b) =COUNTIF(D2:D30,">=50"). The COUNTIF function counts how many cells in the range D2:D30 meet the given condition (a value of 50 or more).
(c) A range check could be applied, restricting valid entries to values between 0 and 100 (inclusive), since a test score cannot logically fall outside this range.

(a) 1 mark: IF function used, with correct syntax; 1 mark: correct condition, D2>=50; 1 mark: correct "Pass"/"Fail" text outputs, in the correct order. [3]
(b) 1 mark: COUNTIF function used; 1 mark: correct range and condition, (D2:D30,">=50"). [2]
(c) 1 mark: range check, restricting values to 0-100 inclusive. [1]

(a) =(B2*9/5)+32. This multiplies the Celsius value in B2 by 9, divides by 5, and adds 32, correctly following the order of operations for the conversion formula.
(b) Using a spreadsheet formula is much faster than calculating each value by hand, especially for a large number of temperatures, and it removes the risk of human arithmetic error; if a Celsius value is changed, the Fahrenheit value also updates automatically.

(a) 1 mark: correct reference to B2; 1 mark: correct multiplication by 9 and division by 5 (or equivalent, e.g. ×1.8); 1 mark: correct addition of 32, with the correct order of operations/brackets. [3]
(b) 1 mark: valid advantage stated; 1 mark: advantage correctly explained/developed. [2]

(a) =AVERAGE(B2:B13) calculates the mean of the values in the range B2:B13.
(b) =MAX(B2:B13) returns the largest (highest) value in the range B2:B13.
(c) A line chart (or line graph) is most suitable, because it clearly shows how the number of items sold changes over the continuous 12-month period, making any overall upward, downward or seasonal trend easy to see.

(a) 1 mark: AVERAGE function; 1 mark: correct range, B2:B13. [2]
(b) 1 mark: MAX function; 1 mark: correct range, B2:B13. [2]
(c) 1 mark: line chart/graph; 1 mark: valid reason relating to showing a trend over a continuous time period. [2]

(a) In a star topology, a central device (a switch) sits at the centre of the network. Each of the 6 computers is connected to this central switch by its own individual cable, so there are 6 separate cables radiating outward from the switch, one to each computer. No computer is connected directly to any other computer; every connection passes through the central switch.
(b) Advantage: if one cable or computer fails, only that device loses its connection, and the rest of the network continues to function normally, since every device has its own independent cable to the switch (this makes a star topology more reliable/robust than a bus topology, where a single cable fault can bring down the whole network). Disadvantage: a star topology requires significantly more cabling than a bus topology (one cable per device, rather than one shared cable), making it more expensive to install; the whole network also depends on the central switch, which is a single point of failure.
(c) If one computer's individual cable failed, only that one computer would lose its connection to the network. All the other 5 computers would be completely unaffected, since each has its own separate, independent cable to the central switch, and would continue to communicate normally.
(d) One factor to consider is the number of ports the switch provides; the switch must have at least as many ports as there are computers to connect (6 in this case, plus any allowance for future expansion), since each computer requires its own dedicated port on the switch to be connected in a star topology.

(a) 1 mark: central device (switch) correctly identified; 1 mark: each of the 6 computers has its own individual cable; 1 mark: each cable connects directly from a computer to the central switch, with no computer connecting directly to another. [3]
(b) 1 mark: valid advantage (e.g. failure of one cable/device does not affect the rest of the network); 1 mark: valid disadvantage (e.g. more cabling required/more expensive, or the switch is a single point of failure). [2]
(c) 1 mark: only that one computer loses its connection; 1 mark: all other computers are unaffected and continue to function normally, since each has an independent connection. [2] (d) 1 mark: valid factor stated, e.g. number of ports available on the switch (or its data transfer speed); 1 mark: factor correctly explained/justified, e.g. must have enough ports for all 6 computers (plus room for expansion). [2]

(i) Automation and digital technology have reduced the need for certain roles, particularly repetitive or manual jobs, such as production-line assembly workers (increasingly replaced by robots), bank clerks and cashiers (reduced by online banking and self-service checkouts), and some administrative or clerical roles (reduced by automated software).
(ii) At the same time, new jobs and skills have been created, particularly in areas such as software development, IT support and cybersecurity, data analysis, and the design, installation and maintenance of automated systems and robots; many existing roles now also require a level of digital literacy that was not previously needed.
(iii) Digital technology, such as video conferencing software, cloud storage and high-speed internet access, has enabled many employees to work remotely (from home) rather than travelling to a fixed office location every day, and has enabled more flexible working hours. It has also made it possible for global or virtual teams to collaborate closely across different countries and time zones.

Level 0 [0]: No relevant content.
Level 1 [1-2]: Basic, one-sided description (e.g. only job losses mentioned) with little development or specific examples. Little use of specialist terminology.
Level 2 [3-4]: Satisfactory coverage of at least two of the three bullet points, with some development and at least one specific example. Some use of specialist terminology.
Level 3 [5-6]: Comprehensive, balanced discussion of all three bullet points, each with a specific, well-explained example (e.g. automation of production-line/clerical roles; new jobs in IT/cybersecurity/data analysis; remote working enabled by video conferencing and cloud technology); accurate specialist terminology used throughout (e.g. automation, digital literacy, remote/flexible working); well organised, with accurate grammar and spelling.
Award marks according to the level that best fits the response as a whole; use the full range within a level to reflect how fully the response meets the level descriptor.

A flowchart shows the sequence and logic of a process, a data flow diagram shows how data moves between processes, and a truth table shows logic gate outputs; a wireframe is used specifically to plan the visual layout and positioning of elements on a screen or webpage, without any functional code.

[1] for B.

A keyboard and mouse and a command-line interface both require the user to learn specific input methods, and a punch card reader is an early, non-natural input method; a natural user interface allows interaction through intuitive, human actions, such as touchscreen gestures.

[1] for C.

BMP is an uncompressed format, and PNG and TIFF typically use lossless compression; JPEG uses lossy compression, discarding some image data to achieve a much smaller file size, making it a common choice for photographs.

[1] for B.

Authoring software is used to combine multimedia elements — such as text, images, audio and video — into a single interactive product, typically without needing to write low-level program code.

[1] for B.

Validation checks data for correctness on entry, encryption scrambles data for security, and compression reduces file size; normalisation is the process of organising data across related tables to reduce redundancy (unnecessary duplication) and prevent data inconsistency.

[1] for A.

Black box testing checks only inputs against expected outputs, without reference to the internal code; beta testing and acceptance testing involve real users testing the finished product. White box testing is carried out with knowledge of, and access to, the program's internal code/structure.

[1] for B.

Speed relates to efficiency, ease of future modification relates to maintainability, and visual appeal relates to usability/design; robustness specifically describes a system's ability to cope with unexpected or invalid input without crashing.

[1] for C.

A flowchart models the sequence/logic of a process, a truth table models logic gate outputs, and a Gantt chart models a project schedule; a data flow diagram (DFD) is the diagram that specifically models the flow of data between processes, external entities and data stores.

[1] for B.

One important consideration is using large, clear text, icons and high-contrast colours throughout the app; this is important because older users may have reduced visual acuity, and text or icons that are too small or low-contrast could be difficult or impossible for them to read or recognise. A second important consideration is providing simple, consistent navigation, with the minimum number of steps needed to complete a task; this is important because users with limited technology experience may become confused, frustrated or lost if the app's menu structure is complex or inconsistent between screens.
The app should use clear, friendly, jargon-free error messages that explain in plain language what went wrong and what the user should do next, since inexperienced users may otherwise not understand a technical error message or know how to correct their mistake.

1 mark: valid consideration 1 named; 1 mark: consideration 1 correctly explained/justified for this specific target audience; 1 mark: valid consideration 2 named; 1 mark: consideration 2 correctly explained/justified for this specific target audience; 1 mark: overall clear, well-reasoned answer specific to elderly, inexperienced users. 1 mark: valid point about clear, jargon-free error messages/guidance suited to inexperienced users.

If a designer does not consider the target audience's likely hardware and connection speed, a website that includes large, uncompressed images, videos or complex interactive scripts may load extremely slowly, or may fail to load at all, on a slow broadband connection or older device. This would make the website frustrating to use, or effectively unusable, for its intended audience, undermining its purpose. To address this, the designer should use compressed/optimised images, avoid unnecessary large media files and complex scripting, and keep the overall page design simple and efficient, so that the website remains usable even under poor connection conditions.
The website could offer an optional, higher-quality version of the content (e.g. a 'watch in high quality' link), which users on a faster connection can choose to load, while the default page remains lightweight and fast for users on a slower connection.

1 mark: recognises that slow connections/older hardware limit what content can load quickly; 1 mark: consequence explained (site becomes frustrating/unusable if not considered); 1 mark: valid design response, e.g. compressed/optimised images; 1 mark: further valid design response, e.g. minimal unnecessary media/scripting, simple page design; 1 mark: overall well-reasoned explanation, specific to the poor-broadband scenario. 1 mark: valid method, e.g. offering optional/on-demand higher-quality content for users with a faster connection, while keeping the default page lightweight.

One reason is so that the voice-over remains clearly audible and intelligible to the viewer; if the soundtrack is too loud, it can drown out or compete with the spoken narration, making it difficult for the viewer to hear and understand the information being communicated. A second reason is that balancing the audio levels improves the overall professional quality and viewer experience of the video; competing, unbalanced audio can be distracting and can make a video seem amateurish, whereas a soundtrack that is reduced (ducked) under the voice-over lets key spoken information come through clearly while still providing atmosphere.

1 mark: reason 1 stated (voice-over remains audible/clear); 1 mark: reason 1 developed (soundtrack could drown out/compete with narration); 1 mark: reason 2 stated (professional quality/viewer experience); 1 mark: reason 2 developed (unbalanced audio is distracting/hard to follow); 1 mark: overall well-explained, specific to this scenario.

(a) A hyperlink (or hotspot) allows the user to click on an element, such as text, an image or a button, in order to navigate to a different part of the product, jump to a different screen, or open an external resource, giving the product interactivity and non-linear navigation controlled by the user.
(b) The student should consider the file size of the video (larger, uncompressed files take longer to load and take up more storage), and should choose a compression/file format (e.g. a widely supported format such as MP4) that will play back correctly and reliably across the range of devices and software the finished product is intended to run on.
(c) Authoring software provides pre-built tools, such as drag-and-drop options for adding hyperlinks, buttons and media, and ready-made templates for combining multimedia elements and adding interactivity, without the student needing to write low-level program code. This makes development considerably faster and makes building an interactive product accessible to someone without programming skills.
(d) The student could add subtitles/captions to the video; this benefits viewers who are deaf or hard of hearing, and also viewers watching in a sound-sensitive environment without audio.

(a) 1 mark: allows the user to click to navigate/interact; 1 mark: developed, e.g. non-linear navigation, link to another screen/external resource. [2]
(b) 1 mark: file size/compression; 1 mark: compatibility with the intended playback devices/software. [2]
(c) 1 mark: pre-built tools/no need to write program code; 1 mark: developed, e.g. faster development, more accessible to non-programmers. [2] (d) 1 mark: valid accessibility feature (e.g. subtitles/captions) with a correct benefit explained. [1]

(a) A one-to-many relationship means that one record in tblMember (one member) can be linked to many records in tblBooking (that member may have made many bookings), but each individual record in tblBooking is linked to only one record in tblMember (each booking belongs to only one member). This relationship is implemented by including the primary key of tblMember (e.g. MemberID) as a foreign key in tblBooking, linking each booking back to the correct member.
(b) Normalisation is the process of organising the data and tables within a database to reduce data redundancy — unnecessary duplication of the same data in more than one place — and to prevent data inconsistency/update anomalies, where updating a piece of data in one place but not another leads to conflicting, out-of-date values. This is achieved by splitting the data across multiple, related tables, rather than storing all the data together in a single, large table.
(c) If member details were repeated in every booking record, updating a member's details (e.g. a change of name) would require updating every single booking record for that member; if even one record were missed, the database would contain inconsistent, conflicting data for the same member (an update anomaly).

(a) 1 mark: one member can have many bookings; 1 mark: each booking belongs to only one member; 1 mark: correctly implemented via a foreign key (e.g. MemberID) in tblBooking, linking to the primary key in tblMember. [3]
(b) 1 mark: reduces data redundancy/duplicate data; 1 mark: prevents data inconsistency/update anomalies; 1 mark: achieved by splitting data across multiple related tables. [3] (c) 1 mark: valid problem correctly explained, e.g. an update anomaly, where a change must be made in multiple places and could be missed, leading to inconsistent data. [1]

A query retrieves, or selects, specific data from one or more tables in a database, based on criteria specified by the user. A report takes the results of a query (or a table) and presents them in a formatted, organised way, often including headings, grouping and totals, intended to be read directly by end users or management, and often designed to be printed. A business might use a report rather than raw query results because a report presents the data in a clearer, more professional and easy-to-read format, which is more suitable for supporting decision-making or for sharing with people outside the technical team.

1 mark: query = retrieves/selects data based on given criteria; 1 mark: report = presents (query) results in a formatted/organised way; 1 mark: valid distinguishing detail, e.g. reports often include headings/grouping/totals and are intended for direct reading; 1 mark: valid reason for using a report, e.g. clearer/more professional presentation to support decision-making; 1 mark: reason correctly developed.

Valid test data is data that should be accepted by the system, for example a value such as 10, which falls clearly within the accepted range. Invalid test data is data that should be rejected by the system's validation, for example -2 (out of range) or "ten" (not a whole number/non-numeric). Extreme (boundary) test data is data that lies right at the very limit of what should be accepted, for example 4 or 18 for this field; testing with extreme data specifically checks that the boundaries of the accepted range are handled correctly by the system.

1 mark: valid data = should be accepted, with a correct example (e.g. 10); 1 mark: invalid data = should be rejected, with a correct example (e.g. -2 or non-numeric); 1 mark: extreme/boundary data = at the very limit of acceptance, with a correct example (4 or 18); 1 mark: purpose of extreme data correctly explained (checking that boundaries are handled correctly); 1 mark: overall clear, correctly organised answer.

One criterion is whether the solution meets the original design/user requirements — that is, whether it includes all of the functionality and features that the client originally specified, and correctly carries out the tasks it was intended to. A second criterion is whether the solution is robust — that is, whether it can cope with unexpected or invalid user input without crashing or producing errors, since a solution that meets the functional requirements but fails or crashes under unusual conditions would not be considered fully successful.

1 mark: criterion 1 named (meets original requirements/specification); 1 mark: criterion 1 developed; 1 mark: criterion 2 named (e.g. robustness, efficiency, usability); 1 mark: criterion 2 developed; 1 mark: both criteria clearly and correctly linked to evaluating success against the original requirements.

Producing a wireframe allows the overall layout, navigation and content structure of the homepage to be planned and agreed with the client before any time-consuming coding work begins. Because no code has yet been written, it is cheap and easy to make changes at the wireframe stage; making the same change after the page has already been fully coded could require significant, costly rework. An example of feedback a client might give at this stage is asking for the search bar to be moved to the top of the page; this is a purely visual/layout change, which is trivial to make on a wireframe but could be far more time-consuming to implement correctly if the page had already been built.

1 mark: wireframe allows layout/structure to be planned and agreed before coding; 1 mark: changes are cheap/easy to make at this early stage, compared with after coding; 1 mark: valid example of client feedback given (a layout-related change); 1 mark: correctly explains why that feedback would be cheap/easy to act on at the wireframe stage; 1 mark: overall well-reasoned, coherent answer.

(a) The primary key of tblMember is MemberID. The foreign key in tblBooking that links to tblMember is also MemberID.
(b) SELECT Name, Age FROM tblMember WHERE MembershipType = 'Junior';
(c) Checking each row of tblMember against the condition MembershipType = 'Junior': M01 (A. Doyle, Junior) matches, M02 (Adult) does not, M03 (C. Osei, Junior) matches, M04 (Senior) does not. Exactly 2 records match, confirming the query would return 2 records.
(d) SELECT * FROM tblMember ORDER BY Age ASC;

(a) 1 mark: MemberID as the primary key of tblMember; 1 mark: MemberID as the foreign key in tblBooking. [2]
(b) 1 mark: SELECT with the correct field list (Name, Age); 1 mark: FROM tblMember; 1 mark: WHERE clause present; 1 mark: correct condition, MembershipType = 'Junior'. [4]
(c) 1 mark: 2. [1] (d) 1 mark: correct statement, SELECT * FROM tblMember ORDER BY Age ASC (or ORDER BY Age, since ascending is the default). [1]

(a) SELECT Activity, BookingDate FROM tblBooking WHERE MemberID = 'M02';
(b) The Activity and BookingDate fields, and each individual booking record, are stored in tblBooking, not in tblMember. tblMember only stores each member's personal details once, in a single row per member, and does not itself contain any booking information.
(c) SELECT COUNT(*) FROM tblBooking;
(d) The keyword ORDER BY is used to sort the results; DESC is added after the field name to sort in descending order.

(a) 1 mark: SELECT with correct field list (Activity, BookingDate); 1 mark: FROM tblBooking; 1 mark: WHERE clause present; 1 mark: correct condition, MemberID = 'M02'. [4]
(b) 1 mark: Activity/BookingDate and individual booking records are held in tblBooking, not tblMember; 1 mark: tblMember only holds one row of personal details per member, with no booking data. [2]
(c) 1 mark: SELECT COUNT(*) FROM tblBooking (or equivalent, e.g. COUNT(BookingID)). [1] (d) 1 mark: ORDER BY correctly named, together with DESC for descending order. [1]

(a) 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 more than one loan record (breaking the uniqueness requirement of a primary key), whereas LoanID is generated fresh for every individual loan transaction and so is always unique.
(b) SELECT Title, Author FROM tblBook WHERE Available = 'Yes';
(c) SELECT COUNT(*) FROM tblLoan;

(a) 1 mark: LoanID correctly identified as the primary key; 1 mark: BookID can repeat across multiple loan records, since the same book can be borrowed more than once over time; 1 mark: LoanID is always unique, generated fresh for every loan. [3]
(b) 1 mark: SELECT with correct field list (Title, Author); 1 mark: FROM tblBook; 1 mark: WHERE clause present; 1 mark: correct condition, Available = 'Yes'. [4] (c) 1 mark: correct statement, SELECT COUNT(*) FROM tblLoan (or equivalent). [1]

(a) SELECT Title FROM tblBook WHERE Genre = 'Fantasy';
(b) In a case-sensitive database system, the text strings 'fantasy' and 'Fantasy' are treated as different values, since the capitalisation does not match. The query using Genre = 'fantasy' would therefore fail to match the stored value 'Fantasy' in tblBook, and would return no results (an empty result set), even though a genuinely matching record (B001, The Hobbit) does exist in the table.
(c) The designer could enforce a consistent, standardised case convention for all data entered into the Genre field (e.g. always capitalised), or could configure the database/query to perform case-insensitive comparisons, so that 'fantasy' and 'Fantasy' are always correctly matched regardless of how a user types the search term.

(a) 1 mark: SELECT with correct field list (Title); 1 mark: FROM tblBook; 1 mark: WHERE clause present; 1 mark: correct condition, Genre = 'Fantasy'. [4]
(b) 1 mark: 'fantasy' and 'Fantasy' would be treated as different strings in a case-sensitive system; 1 mark: the query would return no matching results/an empty result set; 1 mark: despite a genuinely matching record existing in the table. [3] (c) 1 mark: valid method, e.g. enforcing a consistent data entry convention/case standardisation, or using case-insensitive comparison; 1 mark: method correctly explained/developed. [2]

(a) Normal test data: 30 (a value clearly within the accepted range). Extreme (boundary) test data: 16 or 65 (values at the very limit of the accepted range). Erroneous test data: 10 (below the minimum) or "abc" (non-numeric).
(b) Normal data (30): expected to be accepted. Extreme data (16 or 65): expected to be accepted, since the field must accept values from 16 to 65 inclusive. Erroneous data (10 or "abc"): expected to be rejected, with an appropriate error message.
(c) Testing with extreme (boundary) data specifically checks that the limits of the acceptable range are handled correctly by the validation code — for example, that 16 and 65 are correctly included and not accidentally excluded by an off-by-one error (e.g. using > instead of >=). This is a type of error that testing only with normal, mid-range data would not reveal.
(d) A further category is 'extreme erroneous' (or 'boundary erroneous') data, just outside the accepted range, e.g. 15 or 66, used to check that the boundary is correctly excluded from acceptance, not just that clearly invalid values are rejected.

(a) 1 mark: valid normal value; 1 mark: valid extreme/boundary value (16 or 65); 1 mark: valid erroneous value. [3]
(b) 1 mark: correct expected result for normal data (accepted); 1 mark: correct expected result for extreme data (accepted, since within the inclusive range); 1 mark: correct expected result for erroneous data (rejected, with an error message). [3]
(c) 1 mark: extreme data specifically tests that boundary values are correctly handled, which normal data alone would not reveal (e.g. an off-by-one validation error). [1] (d) 1 mark: valid further category identified (e.g. extreme/boundary erroneous data just outside the range, such as 15 or 66) with a correct example. [1]

(a) White box testing is carried out with knowledge of, and direct access to, the program's internal code and structure, allowing the tester to check that every line of code and every possible logical path through the program has actually been tested. Black box testing, in contrast, is carried out without any knowledge of the program's internal code; it tests the program purely by providing inputs and checking whether the resulting outputs match those expected, based only on the program's specification.
(b) White box testing is particularly effective at finding dead code (code that can never be executed/reached under any input), because the tester can inspect the source code directly and identify a section that no logical path ever reaches. Black box testing, which only ever observes inputs and outputs and has no visibility of the code itself, would not reveal the presence of such unreachable code, since it never has any effect on the program's observable behaviour.

(a) 1 mark: white box = tester has knowledge of/access to the internal code/structure; 1 mark: white box tests every line of code/logical path; 1 mark: black box = tester has no knowledge of the internal code; 1 mark: black box tests only inputs against expected outputs, based on the specification. [4]
(b) 1 mark: valid example, e.g. dead/unreachable code; 1 mark: correct explanation of why white box testing finds it (direct code inspection); 1 mark: correct explanation of why black box testing would miss it (only observes inputs/outputs, which are unaffected by unreachable code). [3]

Unit testing checks each individual module or component of the program in isolation, to ensure it works correctly on its own before being combined with anything else. Integration testing checks that different modules/components work correctly together once they have been combined. System testing checks the complete, fully integrated system as a whole, to ensure it meets the overall requirements/specification. These are normally carried out in the order: unit testing first, then integration testing, then system testing, since each stage builds on the one before it, progressively testing larger and more complete parts of the system. Carrying out unit testing before integration testing makes it much easier to locate the source of a fault: if a unit has already been separately tested and shown to work correctly in isolation, then a fault found later during integration testing can be more confidently attributed to the way the units interact, rather than to an error within an individual unit, saving time when debugging.

1 mark: unit testing = tests each individual module/component in isolation; 1 mark: integration testing = tests that modules/components work correctly together when combined; 1 mark: system testing = tests the complete/whole system against its overall requirements; 1 mark: correct order stated (unit, then integration, then system); 1 mark: reasoning that each stage builds on/follows the previous, testing progressively larger parts of the system; 1 mark: overall answer clear and complete. 1 mark: valid advantage, e.g. makes it easier to locate the source of a fault, since individually-tested units are already known to work correctly in isolation, saving debugging time.

(i) Navigation and usability: the website should have a clear, consistent navigation menu present on every page, with a logical structure so that any page can be reached in only a few clicks, and clearly labelled links/buttons, so that visitors can easily find important information such as how to donate or how to contact the charity.
(ii) Accessibility: the website should include features such as alt text for images (so that screen readers can describe them to visually impaired users), sufficient colour contrast between text and background, resizable text, and should avoid relying on colour alone to convey important information, so that the site can be used by people with a range of visual or other disabilities.
(iii) Multimedia: images and video should be used purposefully — for example, photographs illustrating the charity's work, or a short video explaining its mission — rather than purely for decoration, and should be appropriately compressed/optimised so they do not slow down page loading. Audio, such as background music, should generally be avoided or used only sparingly, since it can be distracting for some visitors and inaccessible/inappropriate for others (e.g. users relying on screen readers).

Level 0 [0]: No relevant content.
Level 1 [1-2]: Basic mention of one aspect (navigation, accessibility, or multimedia) with little development or specific example.
Level 2 [3-4]: Satisfactory coverage of at least two of the three aspects, with some development and at least one specific, correct example.
Level 3 [5-6]: Comprehensive, well-developed coverage of all three aspects, each with specific, correct examples (e.g. alt text and colour contrast for accessibility; clear, consistent menus for navigation; purposeful, compressed multimedia); accurate specialist terminology used throughout (e.g. accessibility, alt text, navigation, compression); well organised, with accurate grammar and spelling.
Award marks according to the level that best fits the response as a whole; use the full range within a level to reflect how fully the response meets the level descriptor.

Using place values 128, 64, 32, 16, 8, 4, 2, 1: 91 - 64 = 27 (so the 64 bit is set); 27 - 16 = 11 (so the 16 bit is set); 11 - 8 = 3 (so the 8 bit is set); 3 - 2 = 1 (so the 2 bit is set); 1 - 1 = 0 (so the 1 bit is set). This gives bits set at 64, 16, 8, 2 and 1, and bits clear at 128, 32 and 4, so 91 = 01011011 in 8-bit binary. Check by converting back: 64 + 16 + 8 + 2 + 1 = 91, confirming the answer.
Splitting 01011011 into nibbles: 0101 = 5, 1011 = 11 = B, giving hexadecimal 5B. Converting 5B back to denary as a check: (5 x 16) + 11 = 80 + 11 = 91, which matches the original denary value, confirming the binary conversion is correct.

1 mark: correct method shown (e.g. repeated subtraction of place values, or repeated division by 2); 1 mark: correct place values identified as set (64, 16, 8, 2, 1); 1 mark: answer correctly formatted as 8 bits, including any necessary leading zeros; 1 mark: correct final answer, 01011011. 1 mark: correct hexadecimal conversion (5B) used as an independent check, with the check shown to confirm 91.

Split the 8-bit number into two 4-bit nibbles: 1011 and 0110. The first nibble, 1011, equals 8 + 2 + 1 = 11 in denary, which is B in hexadecimal. The second nibble, 0110, equals 4 + 2 = 6 in denary, which is 6 in hexadecimal. Combining the two gives the hexadecimal value B6. Check: B6 in denary is (11 x 16) + 6 = 176 + 6 = 182, and 10110110 in denary is 128 + 32 + 16 + 4 + 2 = 182, which matches, confirming the conversion.

1 mark: 8-bit number correctly split into two 4-bit nibbles; 1 mark: first nibble correctly converted, 1011 = B; 1 mark: second nibble correctly converted, 0110 = 6; 1 mark: correct final answer, B6.

(a) Adding column by column from the least significant bit, with each column's place value: bit 1 (value 1): 0+0=0; bit 2 (value 2): 1+0=1; bit 4 (value 4): 0+1=1; bit 8 (value 8): 1+1=0 carry 1; bit 16 (value 16): 0+0+carry 1=1; bit 32 (value 32): 0+1=1; bit 64 (value 64): 1+1=0 carry 1; bit 128 (value 128): 1+0+carry 1=0 carry 1 (overflow). Reading the result bits from the 128 place down to the 1 place gives 00110110, with a final carry (overflow) of 1 out of the top. Check by converting to denary: 11001010 = 128+64+8+2 = 202, and 01101100 = 64+32+8+4 = 108; 202+108 = 310. Since 310 exceeds 255 (the maximum 8-bit value), 310-256 = 54, and 00110110 = 32+16+4+2 = 54, confirming the 8-bit result and the overflow.
(b) Overflow occurs when the true result of a calculation requires more bits than are available in the register being used to store it (here, more than 8 bits). Since the true sum, 310, exceeds 255 (the largest value that can be stored in 8 bits), overflow does occur in this addition; the 9th bit (worth 256) is lost, leaving the truncated, incorrect 8-bit result of 54 unless the overflow is detected and accounted for.
(c) The largest denary value representable in 8 bits is 255 (11111111). The true sum of 202 + 108 = 310 is indeed greater than 255, confirming why overflow occurs.

(a) 1 mark: correct method shown (column-by-column binary addition with carries); 1 mark: carries correctly handled through the addition; 1 mark: correct final 8-bit result, 00110110. [3]
(b) 1 mark: overflow = when a result requires more bits than are available/exceeds the maximum value that can be stored; 1 mark: correctly states overflow does occur here, since the true sum (310) exceeds 255, the maximum 8-bit value. [2] (c) 1 mark: correctly states 255 as the largest 8-bit value, confirming 310 > 255. [1]

(7-bit) ASCII uses a fixed, small number of bits (7 bits) to represent each character, allowing only a limited character set of 128 characters, covering English letters, digits and basic symbols. Unicode uses a greater number of bits per character (commonly 16 bits or more, depending on the encoding used), allowing it to represent a vastly larger range of characters. One advantage of Unicode over 7-bit ASCII is that it can represent characters from many different languages and writing systems, such as Chinese, Arabic or Cyrillic characters, and symbols such as emoji, which 7-bit ASCII cannot represent at all.

1 mark: (7-bit) ASCII uses a fixed, small number of bits, representing a limited character set (128 characters); 1 mark: Unicode uses more bits, representing a much larger range of characters; 1 mark: valid advantage of Unicode stated (can represent characters from many different languages/writing systems that ASCII cannot); 1 mark: advantage correctly developed/exemplified.

(a) Since 1 MB = 1000 KB, 6 MB = 6 x 1000 = 6000 KB.
(b) 3 GB of free space = 3 x 1000 = 3000 MB. Number of photographs that fit = 3000 MB / 6 MB per photograph = 500 photographs. Check: 500 x 6 = 3000, confirming the answer.
(c) In practice, the memory card also needs to store its file system/directory structure (formatting overhead), which uses up some of the available space, so slightly less than the full 3 GB is actually available for storing photographs, reducing the true maximum number that can be stored.

(a) 1 mark: correct method, 6 x 1000; 1 mark: correct answer, 6000 KB. [2]
(b) 1 mark: correct method, 3000 / 6 (having correctly converted 3 GB to 3000 MB); 1 mark: correct answer, 500 photographs. [2] (c) 1 mark: valid reason, e.g. file system/formatting overhead reduces the space actually available for storing files. [1]

Trace of total: total starts at 0. i=1: total = 0 + (1*2) = 2. i=2: total = 2 + (2*2) = 6. i=3: total = 6 + (3*2) = 12. i=4: total = 12 + (4*2) = 20. i=5: total = 20 + (5*2) = 30. OUTPUT total outputs 30. Check by a second route: total = 2 x (1+2+3+4+5) = 2 x 15 = 30, confirming the answer.

1 mark: correct value of total after i=1 (2); 1 mark: correct values of total after i=2 and i=3 (6, then 12); 1 mark: correct values of total after i=4 and i=5 (20, then 30); 1 mark: correct final output stated, 30; 1 mark: trace clearly and correctly shows the value of total (and i) at every pass of the loop.

x = 12, y = 5. x MOD y is the remainder when x is divided by y: 12 divided by 5 is 2 remainder 2, so x MOD y = 2. The condition x MOD y = 0 tests whether 2 = 0, which is FALSE, so the ELSE branch executes. OUTPUT x MOD y therefore outputs 2.

1 mark: correct calculation of x MOD y = 2; 1 mark: correct evaluation that the IF condition (x MOD y = 0) is FALSE; 1 mark: correctly identifies that the ELSE branch executes; 1 mark: correct final output, 2.

DECLARE hours AS INTEGER
DECLARE validInput AS BOOLEAN
DECLARE pay AS REAL
DECLARE rate AS REAL
rate = 11.50
validInput = FALSE
WHILE validInput = FALSE DO
OUTPUT "Enter hours worked (0-60): "
INPUT hours
IF hours >= 0 AND hours <= 60 THEN
validInput = TRUE
ELSE
OUTPUT "Invalid input. Please try again."
ENDIF
ENDWHILE
OUTPUT "Hours accepted: ", hours
IF hours <= 40 THEN
pay = hours * rate
ELSE
pay = (40 * rate) + ((hours - 40) * rate * 1.5)
ENDIF
OUTPUT "Pay due: £", pay

Check with hours = 45: pay = (40 x 11.50) + (5 x 11.50 x 1.5) = 460 + 86.25 = 546.25, correctly combining 40 hours at the normal rate with 5 hours of overtime at time-and-a-half.

1 mark: validated input loop (WHILE/REPEAT) that continues until a valid value is entered; 1 mark: correct INPUT statement placed inside the loop; 1 mark: correct range check condition (hours >= 0 AND hours <= 60); 1 mark: appropriate error message shown and the loop correctly exits once a valid value is entered; 1 mark: correct condition distinguishing hours <= 40 from hours > 40; 1 mark: correct calculation of standard pay for hours up to 40 (or the first 40 hours when hours exceed 40); 1 mark: correct calculation of overtime pay at 1.5x the rate for hours above 40; 1 mark: correct final OUTPUT of the pay due. Accept any equivalent working construct (e.g. REPEAT...UNTIL); reject a version with an off-by-one boundary error or that fails to apply the overtime rate correctly. 1 mark: a confirmation message is correctly output once validInput becomes TRUE, before the pay is calculated.

DECLARE prices AS ARRAY[1:6] OF REAL
DECLARE i AS INTEGER
DECLARE total AS REAL
DECLARE countOver10 AS INTEGER
total = 0
countOver10 = 0
FOR i = 1 TO 6
total = total + prices[i]
IF prices[i] > 10 THEN
countOver10 = countOver10 + 1
ENDIF
ENDFOR
OUTPUT "Total price: £", total
OUTPUT "Average price: £", total / 6
OUTPUT "Items over £10: ", countOver10

1 mark: correct array declaration (6 elements, type REAL); 1 mark: correct loop iterating through all 6 elements; 1 mark: correct initialisation of total and countOver10 to 0 before the loop; 1 mark: correct accumulation statement (total = total + prices[i]); 1 mark: correct IF condition testing prices[i] > 10; 1 mark: correct increment of countOver10 placed inside the IF; 1 mark: correct OUTPUT of both total and countOver10 after the loop has completed. 1 mark: correct calculation and output of the average price (total / 6).

DECLARE temperatures AS ARRAY[1:7] 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 = 7
found = FALSE
INPUT target
WHILE low <= high AND found = FALSE DO
mid = (low + high) DIV 2
IF temperatures[mid] = target THEN
OUTPUT "Found at position ", mid
found = TRUE
ELSE
IF temperatures[mid] < target THEN
low = mid + 1
ELSE
high = mid - 1
ENDIF
ENDIF
ENDWHILE
IF found = FALSE THEN
OUTPUT "Not found"
ENDIF

1 mark: correct initialisation of low and high to the bounds of the array (low = 1, high = 7); 1 mark: correct loop condition, continuing while low <= high and the search has not yet succeeded; 1 mark: correct calculation of the midpoint (mid = (low + high) DIV 2); 1 mark: correct comparison of temperatures[mid] to target and correct OUTPUT when a match is found; 1 mark: correct adjustment of low when temperatures[mid] < target; 1 mark: correct adjustment of high when temperatures[mid] > target; 1 mark: correct final 'not found' message output when the loop ends without a match.

DECLARE scores AS ARRAY[1:4] OF INTEGER
DECLARE i AS INTEGER
scores[1] = 18
scores[2] = 25
scores[3] = 9
scores[4] = 30
FOR i = 1 TO 4
IF scores[i] MOD 2 = 0 THEN
OUTPUT scores[i]
ENDIF
ENDFOR

Check: 18 MOD 2 = 0 (even, output); 25 MOD 2 = 1 (odd, not output); 9 MOD 2 = 1 (odd, not output); 30 MOD 2 = 0 (even, output). So the algorithm correctly outputs 18 and 30.

1 mark: correct array declaration with all 4 values correctly initialised, in the given order; 1 mark: correct loop iterating through all 4 elements; 1 mark: correct condition testing for an even number (scores[i] MOD 2 = 0); 1 mark: correct OUTPUT statement placed inside the IF; 1 mark: algorithm correctly identifies and outputs exactly the two even values (18 and 30) for the given data.

(a) Z = (A AND B) AND (NOT C).
(b) Three gates are needed: an AND gate with inputs A and B, producing the intermediate output (A AND B); a NOT gate with input C, producing NOT C; and a second AND gate, which takes the intermediate output (A AND B) and NOT C as its two inputs, producing the final output Z.
(c) Truth table for Z = (A AND B) AND (NOT C):

A B C | Z
0 0 0 | 0
0 0 1 | 0
0 1 0 | 0
0 1 1 | 0
1 0 0 | 0
1 0 1 | 0
1 1 0 | 1
1 1 1 | 0

Z is 1 only in the row where A=1, B=1 and C=0 (door open, system armed, and no override), matching the intended behaviour of the security system; in every other combination, Z = 0.
(d) When C is fixed at 0, NOT C is always 1, so Z = (A AND B) AND 1 = A AND B; Z is therefore equivalent to a single AND gate with inputs A and B when C = 0.

(a) 1 mark: correct AND combination of A and B; 1 mark: correct incorporation of NOT C, combined with AND, to override the alarm. [2]
(b) 1 mark: correct gates identified (two AND gates and one NOT gate); 1 mark: correct description of the connections (AND(A,B) feeding into a second AND gate together with NOT(C)). [2]
(c) 1 mark: correct Z values for the first 4 rows (C=0 and C=1 combinations where A=0, all giving Z=0); 1 mark: correct Z values for the rows where A=1, B=0 (both give Z=0), and A=1,B=1,C=1 (Z=0); 1 mark: correct Z=1 for the row A=1, B=1, C=0, with an overall complete, correctly structured 8-row table. [3] (d) 1 mark: correctly identifies Z simplifies to a single AND gate (Z = A AND B) when C = 0. [1]

(i) Editing features such as syntax highlighting (colour-coding different parts of the code, e.g. keywords, strings, comments) help a programmer quickly identify the structure of their code and more easily spot syntax errors, such as a missing quotation mark. Auto-complete suggests keywords, variable names or function names as the programmer types, speeding up coding and reducing the chance of typing errors.
(ii) Debugging tools, such as breakpoints and variable watches, allow a programmer to pause the execution of a program at a specific line and examine the current values of variables at that point. This makes it much easier to trace through the program's logic step by step and locate the exact point at which a logic error occurs, compared with simply reading through the code.
(iii) An SDE/IDE provides high-level code translation and execution, using a built-in compiler or interpreter, allowing the programmer to translate and run their high-level code directly within the same environment, and to see the resulting output or any error messages immediately, without needing separate external tools.

Level 0 [0]: No relevant content.
Level 1 [1-2]: Basic mention of one feature (editing, debugging, or translation/execution) with little explanation of its benefit.
Level 2 [3-4]: Satisfactory coverage of at least two of the three features, with some explanation of how each benefits the programmer.
Level 3 [5-6]: Comprehensive, accurate coverage of all three features, each correctly linked to a specific benefit for the programmer (e.g. syntax highlighting/auto-complete speeding up coding and reducing errors; breakpoints/variable watches making logic errors easier to trace; built-in translation letting code be run and tested immediately); accurate specialist terminology used throughout (e.g. syntax highlighting, breakpoint, compiler/interpreter); well organised, with accurate grammar and spelling.
Award marks according to the level that best fits the response as a whole; use the full range within a level to reflect how fully the response meets the level descriptor.

(a) INTEGER, since a score is always expressed as a whole number, with no fractional part.
(b) REAL, since an average expressed to 2 decimal places requires a data type that can store a fractional/decimal value.
(c) STRING, since the candidate number contains a leading zero that must be preserved, and is never used in any calculation, so it should not be stored as a number.
(d) BOOLEAN, since it has only two possible states, TRUE (distinction awarded) or FALSE (not awarded).
(e) If stored as an INTEGER, the leading zero in "0123456" would automatically be dropped (since 0123456 and 123456 represent the same numeric value), permanently losing part of the correct candidate number; storing it as a STRING preserves every character, including the leading zero, exactly as entered.

1 mark: (a) INTEGER, with valid justification referring to a whole-number value; 1 mark: (b) REAL, with valid justification referring to the need to store a decimal value; 1 mark: (c) STRING, with valid justification (e.g. preserves the leading zero, or is not used arithmetically); 1 mark: (d) BOOLEAN, with valid justification referring to only two possible states. Reject any data type given without a valid supporting justification. (e) 1 mark: correctly explains that storing as an INTEGER would drop the leading zero, whereas STRING preserves it exactly. [1]

(a) This is a runtime error.
(b) A syntax error is detected by the compiler/interpreter before the program is even run, since the code does not follow the exact grammatical rules of the programming language. A runtime error, in contrast, occurs in code that is syntactically valid and does start running, but is only detected while the program is actually executing, when it encounters an operation — such as dividing by zero — that it cannot actually carry out.
(c) The programmer could add a validation check before the division takes place, testing whether the divisor is equal to zero, and if so, avoiding the division (for example, by outputting an error message to the user instead of attempting to divide).

(a) 1 mark: runtime error. [1]
(b) 1 mark: a syntax error is detected by the translator/compiler/interpreter before the program runs; 1 mark: a runtime error is only detected while the program is actually running/executing. [2]
(c) 1 mark: valid prevention method, e.g. validate/check that the divisor is not zero before performing the division. [1]

(a) A suitable test plan table has columns headed Test Data, Test Type and Expected Result, with one row for each type: e.g. width = 4, height = 5 (Normal) with expected result = 20 (the correctly calculated area); width = 1, height = 1 (Extreme, the smallest valid positive whole-number dimensions) with expected result = 1; width = -3, height = 5 (Erroneous, since a negative width is invalid) with expected result that the input is rejected/an error is produced.
(b) A test plan should be written before testing begins so that testing is planned and systematic, ensuring every necessary type of test data (normal, extreme and erroneous) is deliberately covered, rather than testing being carried out in an ad hoc way. It also allows the expected result for each test to be decided independently, in advance, before the actual output is seen, avoiding any bias when judging whether a test has passed or failed.
(c) A full test plan should also include an 'Actual Result' column, to be filled in once the test has actually been run, so that the actual result can be compared directly against the expected result to determine whether the test has passed or failed.

(a) 1 mark: table includes appropriate column headings (test data, test type, expected result); 1 mark: valid normal test data row with correct expected result (area = width x height); 1 mark: valid extreme/boundary test data row with correct expected result; 1 mark: valid erroneous test data row with correct expected result (rejected/error). [4]
(b) 1 mark: valid reason, e.g. ensures systematic/planned coverage of all test types, and/or avoids bias by deciding expected results in advance. [1] (c) 1 mark: valid further column/information, e.g. an 'Actual Result' column, to be compared against the expected result. [1]

(a) Efficiency refers to how well a system makes use of resources, such as processing time and memory, in order to complete its tasks; an efficient program completes its tasks quickly, without wastefully using more processing time or memory than necessary.
(b) Maintainability refers to how easily the system's code can be understood, updated and extended by another programmer in future; a maintainable program typically uses clear, meaningful variable names, includes helpful comments, and has a logically organised structure, making future changes easier and less error-prone.
(c) Portability refers to how easily the system (or its code) can be transferred to run correctly on a different device, operating system or platform from the one it was originally developed on.

(a) 1 mark: efficiency = how well a system makes use of resources such as processing time/memory; 1 mark: developed, e.g. completing tasks quickly without wasting resources. [2]
(b) 1 mark: maintainability = how easily code can be understood/updated/extended by another programmer; 1 mark: developed, e.g. through clear variable naming, comments, or a logically organised structure. [2] (c) 1 mark: portability = how easily the system/code can be transferred to run on a different device/platform. [1]