Loading…

Worked solutions

IB Computer Science HL · Paper 2

Computer Science, Higher Level

Session: May 2016
Marks: 260
Duration: 1 hour 20 min
Calculator: Not allowed
Questions: 17

Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 Q9 Q10 Q11 Q12 Q13 Q14 Q15 Q16 Q17

Keep your copy of the paper open alongside. We don't reproduce the questions: each part below is labelled to match the May 2016 Global paper, which your school or the IB can provide.

Practice mode

Hide our working until you've had a go.

Option A: Databases · Option

Questions 1–4 · 65 marks

Question 1

15 marks

CrossCountryXL transport company relational schema, queries, and data recovery

Databases

(a)

3 marks

Identify the three core entities in the logistics domain: `CrossCountryXL` (or Transport Company), `Retailer`, and `Supplier`.
Determine the relationship cardinalities: `CrossCountryXL` delivers items from multiple `Retailer` entities ( $1 : N$ ), and each `Retailer` deals with multiple `Supplier` entities ( $1 : N$ or $M : N$ as suppliers may supply multiple retailers).
Construct the Entity-Relationship Diagram (ERD) with descriptive action verbs:
`CrossCountryXL` (1) ----< [delivers for] >---- (N) `Retailer` (1/M) ----< [sourced from / supplies] >---- (N) `Supplier`

Mentor tip

Always label both the entity boxes and the relationship diamonds/lines with clear verbs and explicit cardinality notations (1:N or M:N).

(b)

2 marks

In the `SUPPLY` relation, `Supplier_ID` serves as the underlined primary key, which uniquely identifies each tuple in the table.
Because primary key values must be strictly unique and cannot contain duplicates, changing `34567890` to `54959299` (which already exists in row 3 of `SUPPLY`) creates a duplicate key violation and breaks entity/referential integrity.

Mentor tip

Focus on the uniqueness requirement of a primary key: no two records in the same relation can share an identical primary key value.

(c)(i)

1 mark

Filter the `ITEM` table for rows where `Quantity > 150` and project the `Item_Name` column:
`Oranges`, `Bags`, `Wallets`, `Tomatoes` (corresponding to quantities 190, 180, 201, and 167).

Mentor tip

Check every row carefully against the strict inequality (> 150) and output only the requested column (`Item_Name`).

(c)(ii)

1 mark

Filter the `SUPPLY` table for rows where `Nature_Of_Goods = 'P'` and project the `Supplier_ID` column:
`34567890`, `54959299`, `45908919`.

Mentor tip

Ensure all three matching identifier strings are listed accurately.

(d)

4 marks

Step 1 (Table selection): Select both the `SUPPLIER` and `SUPPLY` tables.
Step 2 (Join condition): Link the two relations on their common key: `SUPPLIER.Supplier_ID = SUPPLY.Supplier_ID`.
Step 3 (Filter condition): Apply the selection criterion `SUPPLY.Nature_Of_Goods = 'P'` to isolate perishable goods.
Step 4 (Projection): Project and output the `SUPPLIER.Name` field from the joined, filtered records.

Mentor tip

You can express query steps either as structured algorithmic bullet points or as an equivalent SQL `SELECT ... FROM ... JOIN ... WHERE` statement.

(e)

4 marks

Measure 1 — Write-Ahead Transaction Logging: Record all database modifications and transaction details in a sequential log file on fail-safe external storage before committing changes to disk, allowing the system to replay or undo actions after a crash.
Measure 2 — Regular Off-site Backups: Schedule automated periodic full and incremental backups of the database to redundant remote or cloud storage so the supplier tables can be reconstituted to a known consistent state if hardware fails.

Mentor tip

For each recovery measure, state both the mechanism (e.g., transaction logs, regular backups) and how it restores lost data.

Question 2

14 marks

School Management System schema, concurrency, ACID properties, and transaction rollback

Databases

(a)(i)

1 mark

A database schema is the formal logical blueprint or structural definition of a database, specifying its tables, attributes, data types, keys, and relationships.

Mentor tip

Keep the definition focused on the logical organization and structural blueprint of the database.

(a)(ii)

2 marks

Data consists of raw, unorganized facts or symbols without context—for example, the standalone number `50` or string `'B+'` stored in a table cell.
Information is data that has been processed, structured, and given semantic context for a user—for example, `'Student attendance = 50 days'` or `'Term 1 Mathematics Grade = B+'` displayed on a parent's portal.

Mentor tip

Use concrete examples from the School Management System (attendance figures or subject grades) to contrast raw values with contextualized output.

(b)(i)

2 marks

Lost Update Problem: Two teachers simultaneously open the same student's record to update different subject grades or attendance counts; when both save their changes without locking, the second write overwrites the first teacher's update, causing data loss.
Alternative — Dirty Read / Uncommitted Dependency: One teacher updates a student's grade, and a second teacher (or parent) reads that modified grade before the transaction fails and rolls back, leaving the reader with invalid data.

Mentor tip

Name a specific concurrency anomaly (lost update, dirty read, or incorrect summary) and contextualize it with teachers updating student records.

(b)(ii)

4 marks

Isolation: Ensures that concurrent transactions execute independently as if they were running serially; locking mechanisms prevent two teachers from modifying the exact same student record simultaneously (preventing lost updates).
Consistency (and Atomicity): Guarantees that every transaction brings the database from one valid state to another according to defined integrity rules, resolving temporary update anomalies by ensuring incomplete or conflicting intermediate states are never visible to other users.

Mentor tip

Clearly name the relevant ACID properties (Isolation and Consistency/Atomicity) and explain how each prevents interleaved read/write conflicts.

(c)

3 marks

A `ROLLBACK` operation signals that an active transaction has encountered an error or failed before completion, requiring the DBMS to abort it.
For example, if a teacher is executing a batch update of end-of-term grades and a network or power failure occurs mid-calculation, the transaction is left incomplete.
The DBMS uses the transaction log to undo all partial grade modifications made during that transaction, restoring the student records to their exact pre-transaction state.

Mentor tip

Connect three points: transaction failure detection, a concrete school example (updating grades/attendance), and undoing partial changes to restore the prior state.

(d)

2 marks

Durability guarantees that once a transaction has been successfully committed (such as saving final course grades), its changes are permanently recorded in non-volatile storage.
Even if a system crash or power outage occurs immediately after the commit, the recovery subsystem ensures the updated records are never lost.

Mentor tip

Emphasize permanence after `COMMIT` and survival across system crashes via non-volatile storage.

Question 3

16 marks

Science research firm database administration, privacy, data mining, and 3NF normalization

Databases

(a)

2 marks

Implement role-based access control (RBAC) and granular password/clearance levels so personnel can only view or modify tables relevant to their specific job role.
Configure sensitive research tables as read-only for general staff and revoke access privileges immediately for employees who violate security policies or leave a project.

Mentor tip

Provide two distinct administrative controls focused on internal personnel (e.g., role-based permissions, read-only views, audit logs).

(b)

1 mark

Storing all data in a single centralized database creates a single point of failure/compromise: a single security breach or server outage could leak all proprietary research to competitors or halt the entire firm's operations.

Mentor tip

State a clear operational or security consequence of centralization on the firm's research.

(c)

4 marks

Method 1 — Data Masking / Anonymization: When generating analytical reports from `EMP_DEPT`, mask sensitive digits of `SSN` (e.g. `XXX-XX-9955`) and `DOB` so individual employees cannot be personally identified.
Method 2 — Projection Views / Field Suppression: Create restricted database views that omit personally identifiable attributes such as `EmpName`, `Address`, and `Salary` when sharing departmental statistics (`DeptNo`, `DeptName`) with external auditors or researchers.

Mentor tip

Make explicit reference to the attributes in `EMP_DEPT` (such as `SSN`, `Salary`, `Address`, `EmpName`) when describing privacy measures.

(d)

4 marks

Data Mining is the automated discovery of hidden patterns, correlations, and future trends across massive datasets using statistical or machine learning algorithms (e.g., discovering salary progression trends across departments).
Data Matching compares and links records across two or more distinct datasets (using common identifiers like `SSN` or `EmpName` + `DOB`) to identify duplicate entities, verify identities, or detect discrepancies/fraud.

Mentor tip

Contrast pattern/trend discovery in large datasets (data mining) with cross-dataset record linkage and error/fraud detection (data matching).

(e)(i)

2 marks

Eliminates transitive dependencies between non-key attributes, significantly reducing data duplication (redundancy) across rows.
Prevents update, insertion, and deletion anomalies (for instance, updating a department manager's `DM_SSN` in one place rather than across every employee row in that department, or deleting the last employee in a department without losing the department's details).

Mentor tip

Mention reduced redundancy and elimination of modification anomalies (insertion, update, deletion) or transitive dependencies.

(e)(ii)

3 marks

Identify functional and transitive dependencies in `EMP_DEPT`: `SSN` uniquely determines employee details (`EmpName`, `DOB`, `Salary`, `Address`, `DeptNo`), while `DeptNo` determines department details (`DeptName`, `DM_SSN`).
Decompose into 3NF relations by separating the transitive dependency on department:
`EMPLOYEE` (`SSN`*, `EmpName`, `DOB`, `Salary`, `Address`, *`DeptNo`*)
`DEPARTMENT` (`DeptNo`*, `DeptName`, `DM_SSN`)
(where `*` denotes the Primary Key and `*DeptNo*` in `EMPLOYEE` is the Foreign Key referencing `DEPARTMENT`).

Mentor tip

Always clearly mark the Primary Key (and Foreign Key) in each decomposed 3NF relation and ensure all non-key attributes depend solely on the key.

Question 4

20 marks

QuickCook restaurant chain data warehouse, ETL data cleansing, views, and OODBMS

Databases

(a)

3 marks

Classification by Temporal / Peak Sales Period: Categorizing transactions by day of the week, hour of day, or season to identify peak dining times.
Classification by Product / Menu Category: Grouping sales by food type or meal combos (e.g., burgers, vegetarian, beverages) to see which items sell best.
Classification by Customer Demographics or Spend Bracket: Segmenting orders by price range or customer age group/loyalty tier to analyze spending habits.

Mentor tip

Give three concrete classification categories relevant to restaurant sales analysis.

(b)

2 marks

Every record loaded into a data warehouse is tagged with an explicit timestamp or historical time horizon indicating when the transaction occurred.
This allows analysts to query, sort, and aggregate historical data chronologically across the 20-year span to track long-term longitudinal trends and seasonal comparisons.

Mentor tip

Link the presence of timestamps on warehouse records to the ability to perform historical trend and time-series queries.

(c)

3 marks

Standardize formatting and naming conventions across branches (e.g., converting dates to `YYYY-MM-DD`, standardizing phone numbers, or unifying `'St.'` and `'Street'` in addresses).
Handle missing or `NULL` values by replacing them with standardized default codes (such as `'Not Provided'`) or imputing valid values.
Deduplicate records and enforce unique primary identifiers so merged restaurant logs do not contain repeated or conflicting entries.

Mentor tip

Focus on practical ETL data scrubbing steps: format standardization, null handling, and deduplication/validation.

(d)

4 marks

Storage Persistence: A data warehouse physically stores massive volumes of integrated data persistently on disk, whereas a database view is a virtual table generated dynamically on demand from underlying base tables.
Temporal Scope: A data warehouse maintains historical, time-variant data accumulated over many years (20 years of sales), whereas a view reflects only the current real-time state of an operational transactional database.
Structure and Optimization: Data warehouses use denormalized multidimensional schemas (star/snowflake) indexed for complex OLAP analytics, whereas views are relational extracts that cannot be indexed independently of their underlying base tables.
Data Integration: A data warehouse consolidates heterogeneous data from multiple local restaurant databases via ETL, whereas a view typically queries tables within a single database system.

Mentor tip

Contrast views and data warehouses across four clear axes: physical vs virtual storage, historical vs current data, OLAP indexing vs relational extract, and multi-source vs single-DB scope.

(e)

2 marks

Before loading: Temporarily disable indexes and referential integrity constraints on the target warehouse tables (and perform a backup) so bulk insertion runs rapidly without per-row index overhead.
After loading: Rebuild/re-enable all indexes and run automated integrity and row-count verification checks to confirm that all transformed records loaded completely and accurately.

Mentor tip

Mention disabling indexes/constraints (or backing up) prior to bulk load, and re-enabling indexes / verifying data integrity afterward.

(f)(i)

2 marks

Encapsulation (bundling complex data structures and the methods that operate on them into self-contained objects).
Inheritance (allowing new data subtypes to inherit attributes and behaviors from existing superclass definitions) and Polymorphism.

Mentor tip

State any two core OOP pillars: Encapsulation, Inheritance, or Polymorphism.

(f)(ii)

4 marks

Advantage — Complex Data Types & No Impedance Mismatch: An OODBMS natively stores rich, complex composite objects (images, multimedia, nested recipes) and uses the same object model as the host OOP language, eliminating the need to translate objects into flat relational tables and improving code reusability.
Disadvantage — Lack of Universal Standards and Views: Unlike SQL in relational databases, OODBMSs lack a universally agreed-upon query standard and mathematical data model, and they typically lack simple virtual view mechanisms or granular table-level security controls, making ad-hoc reporting and migration harder.

Mentor tip

State one clear advantage with explanation (e.g., handling complex media types / avoiding relational-object impedance mismatch) and one clear disadvantage with explanation (e.g., lack of universal SQL standard or view mechanisms).

Option B: Modelling and simulation · Option

Questions 5–8 · 65 marks

Question 5

17 marks

Town estate agent property price mathematical model and spreadsheet rules

Modelling and simulation

(a)

4 marks

`Size`: Stored as a numeric integer or floating-point value representing square metres (e.g., `120` for $120 m^{2}$ ).
`Property_Type`: Stored as a single character code or integer flag (e.g., `'H'` for house and `'A'` for apartment, or `1` and `2`).
`District`: Stored as an integer code from `1` to `4` corresponding to the town's four districts.
`Condition`: Stored as an ordinal integer scale from `1` to `5` or short text code (e.g., `5` = very good, `4` = good, `3` = medium, `2` = poor, `1` = very poor).

Mentor tip

Give a clear data type/representation and a concrete example value for all four property attributes.

(b)

6 marks

Set up spreadsheet columns for a property row (e.g., Row 2): Column A = `Size` (`100`), Column B = `Type` (`'A'`), Column C = `District` (`1`), Column D = `Condition` (`4` for good).
Determine Base Price per $m^{2}$ in Column E using a conditional formula: `=IF(B2="A", 2000, 2300)`.
Determine the District Multiplier in Column F using nested `IF` or `VLOOKUP`: `=IF(C2=1, 1.25, IF(C2=2, 1.00, IF(C2=3, 0.95, 0.90)))`.
Determine the Condition Multiplier in Column G using a lookup table or nested `IF` (e.g., `=VLOOKUP(D2, CondTable, 2, FALSE)` where `4` maps to `1.00`).
Calculate the Estimated Selling Price in Column H by multiplying Size, Base Price, District Multiplier, and Condition Multiplier: `=ColA2 * E2 * F2 * G2`.

Estimated Price = Size \times BaseRate \times DistrictMultiplier \times ConditionMultiplier

Mentor tip

Clearly show the column layout, how each multiplier/base value is selected (via `IF` or `VLOOKUP`), and the final multiplication formula.

(c)

3 marks

For a large sample of sold properties, calculate the residual difference between the model's `Estimated_Price` and the actual `Final_Selling_Price`.
Also calculate the time on market (`Date_Sold - Date_First_For_Sale`) to see if certain price brackets or districts take abnormally long to sell.
If properties in a specific district or condition consistently sell above or below the estimate (or stagnate on the market), adjust the corresponding district or condition multipliers in the model to minimize estimation error.

Mentor tip

Mention comparing estimated vs actual selling prices across many sales, analyzing time on the market using the two dates, and tuning the multipliers accordingly.

(d)

4 marks

Method 1 — Unsold Inventory vs Sold Comparison: Filter and group properties that remain unsold (or have a very large `Date_Sold - Date_First_For_Sale` duration) and compare their attributes (e.g., District 4 apartments in poor condition) against properties that sold quickly.
Method 2 — Pivot Table / Category Aggregation: Sort or group historical records by each variable (`District`, `Type`, `Condition`, `Size` bracket) and compute the average days on market and percentage of unsold listings for each combination to pinpoint which traits deter buyers.

Mentor tip

Explain two ways to group and compare property attributes against time-on-market or sold/unsold status.

Question 6

16 marks

Railway station ticket machines and manned ticket offices queue simulation

Modelling and simulation

(a)

4 marks

A model is the static mathematical and logical representation of the station's ticketing system, defining variables and rules such as service rates for Type 1/Type 2 machines, staffed counter hours, and passenger arrival distributions.
A simulation is the dynamic execution of that model over time using varied inputs—for example, running virtual rush-hour passenger arrivals through different combinations of Type 1/Type 2 machines to observe resulting queue lengths and wait times.

Mentor tip

Define both terms and explicitly anchor each to the railway station ticketing scenario.

(b)(i)

2 marks

Passenger arrival rates and transaction types across different times of day and days of the week (e.g., peak morning commute vs off-peak).
Average service time required per transaction at Type 1 machines, Type 2 machines, and manned ticket offices (plus capital/operating costs of machines and staff).

Mentor tip

Identify both demand data (passenger volume by time/ticket type) and service capacity data (transaction durations and costs).

(b)(ii)

2 marks

Extract automated historical transaction logs from the central railway database, which record exact timestamps and durations for every ticket printed at Type 1/Type 2 machines and manned counters.
Supplement automated logs with CCTV queue analysis or timed observational sampling during peak and off-peak periods to measure actual passenger waiting times.

Mentor tip

Automated electronic log extraction from existing ticket machines and central servers is the most efficient primary collection method.

(c)

2 marks

Feed the recorded historical passenger arrival streams into the simulation while systematically varying parameters: the count of Type 1 machines, count of Type 2 machines, and opening hours/staffing of ticket offices.
Observe and record the resulting passenger flow, maximum queue lengths, and average waiting times across each time period for every configuration.

Mentor tip

Explain how the collected arrival data is held constant while machine counts and counter hours are varied to measure queue performance.

(d)

2 marks

Criterion — Maximum / Average Passenger Waiting Time during Rush Hour: Compare whether each configuration keeps ticket collection waits below a target threshold (e.g., under 3 minutes so online bookers do not miss trains).
Alternative Criterion — Total Implementation and Operating Cost: Compare the capital expense of installing additional Type 1/2 machines against the ongoing wage cost of extending manned ticket office hours.

Mentor tip

State a clear metric (e.g., rush-hour wait time or total cost) and explain how it distinguishes better configurations.

(e)

4 marks

Reasons why it is valid / transferable: The underlying queuing logic, machine transaction speeds, and software structure of the simulation model remain valid because all stations use the same Type 1/Type 2 hardware and ticket rules.
Reasons why results are not directly transferable: Different stations have vastly different passenger volumes, commuter demographics (e.g., tourist hubs needing complex advice vs commuter stations needing season renewals), physical layouts, and train frequencies.
Conclusion: While the simulation software framework can be reused across the network, local passenger arrival data must be collected and input separately for each individual station before deciding on equipment numbers.

Mentor tip

Balance the discussion: the simulation *framework/rules* are reusable, but the specific *output recommendations* are not transferable without local station data.

Question 7

12 marks

Emergency helicopter pilot training simulator and 3D visualization

Modelling and simulation

(a)

4 marks

Advantage — Safe Exposure to Rare/Extreme Hazards: Pilots can repeatedly practice life-threatening emergencies (engine failure, severe mountain storms, night rescues) in a simulator with zero risk to life or expensive aircraft, whereas live training flights only encounter weather and conditions that happen to occur that day.
Disadvantage — Lack of Real Psychological Stress & Mentor Nuance: A simulator cannot fully replicate the physical G-forces, adrenaline, or unpredictable human factors of a real rescue, and trainees miss out on the tacit, real-time situational coaching of an experienced co-pilot.

Mentor tip

Provide a fully explained advantage (safety / rare emergency repeatability) and a fully explained disadvantage (fidelity limits / high setup cost / lack of human mentor).

(b)

2 marks

Hardware: High-performance multi-core CPU with dedicated GPUs for real-time 3D rendering, wraparound cockpit displays/VR headset, physical flight controls (cyclic, collective, pedals), and hydraulic motion actuators.
Software: Real-time flight physics and aerodynamics engine coupled with 3D terrain rendering and weather/emergency scenario generation software.

Mentor tip

You must explicitly mention both a hardware requirement and a software requirement to earn full marks.

(c)

3 marks

Helicopter rescue operations occur in complex three-dimensional terrain (mountains, valleys, tall buildings) where altitude, depth perception, and obstacle clearance are critical.
The pilot must judge vertical and lateral distances simultaneously while hovering or landing on uneven surfaces.
The visual scene must update dynamically in real time across all three axes (pitch, roll, yaw, elevation) in response to the pilot's control inputs.

Mentor tip

Connect 3D terrain geometry (altitude/depth), spatial judgment required by the pilot, and real-time perspective updates.

(d)

3 marks

The terrain and objects are stored in memory as a mathematical wireframe/polygon mesh defined by 3D vertex coordinates $(x, y, z)$ , edges, and surface properties.
As the helicopter moves, geometric transformations (translation, rotation, scaling, perspective projection) recalculate the 3D coordinates relative to the pilot's viewpoint.
A rendering pipeline applies hidden-surface removal, texture mapping, shading, and lighting (such as ray tracing or rasterization) to convert the mathematical model into a realistic 2D perspective image on the cockpit screens.

Mentor tip

Trace the pipeline from mathematical 3D coordinates in memory -> geometric transformation -> rendering (lighting/shading/textures) for display.

Question 8

20 marks

Volcano conservation genetic algorithms, neural network learning, and robot NLP

Modelling and simulation

(a)

5 marks

Step 1 (Initialization): Generate an initial population of random potential routes (chromosomes) visiting the displaced animal groups.
Step 2 (Fitness Evaluation): Evaluate each path using a fitness function based on total distance, terrain elevation difficulty, and volcanic hazard zones.
Step 3 (Selection): Select the highest-performing (shortest/safest) routes as parents and discard the least fit paths.
Step 4 (Crossover & Mutation): Combine segments of parent routes (crossover) and introduce small random alterations to waypoint order (mutation) to form a new generation of paths.
Step 5 (Termination): Repeat evaluation, selection, and reproduction over many generations until the algorithm converges on an optimal or near-optimal rescue route.

Mentor tip

Include all five canonical stages of a Genetic Algorithm: initial population, fitness function, selection, crossover/mutation, and iterative convergence.

(b)

6 marks

Supervised Learning: The neural network is trained on labeled input-output pairs where the target outcome is already known; the network compares its predictions against the known correct outputs and adjusts its weights to minimize error.
Unsupervised Learning: The neural network is given unlabeled input data with no predetermined target answers and must autonomously discover hidden structures, clusters, or patterns in the data.
Suitability for Volcano Scenario: Unsupervised learning is more suitable here because the post-eruption terrain is altered and the daily movement patterns of displaced animals are previously unknown (there is no labeled historical training set of correct paths for this eruption).

Mentor tip

Define supervised learning (known target outputs), define unsupervised learning (discovering unknown patterns without labels), and justify why unsupervised fits the novel post-eruption animal movements.

(c)

3 marks

Learnable by robots: Formal, rule-governed structures of language including explicit vocabulary (lexicon), grammatical syntax rules, and repetitive/standardized sentence patterns.
Difficult/unlearnable by robots: Deep semantic ambiguity, irony, sarcasm, cultural idioms, emotional tone, and context-dependent pragmatic meaning that do not follow fixed deterministic rules.

Mentor tip

Contrast rule-based linguistic elements (vocabulary, syntax, fixed grammar) with context-heavy human elements (pragmatics, idioms, emotion, ambiguity).

(d)

6 marks

Human Language Learning: Humans acquire language through complex cognitive development, social interaction, sensory experience, and emotional context (reading facial expressions, body language, and real-world situational cues).
Machine Language Learning: Computers process language algorithmically using predefined syntactic rules, statistical probabilities (n-grams, neural language models), and heuristic pattern matching over massive text corpora.
Comparison & Conclusion: While machines can rapidly process vast vocabularies and probabilistic word associations, they lack genuine conscious comprehension or embodied world experience, making it difficult for machines to interpret novel metaphors or nuanced human intent as naturally as humans do.

Mentor tip

Structure your 6-mark discussion into three parts: how humans learn language (cognitive/social/sensory), how machines learn (rules/statistics/heuristics), and the resulting gap in semantic comprehension.

Option C: Web science · Option

Questions 9–13 · 65 marks

Question 9

18 marks

HTTPS protocols, DNS resolution, and server-side PHP database scripting

Web science

(a)(i)

2 marks

Hypertext Transfer Protocol (`HTTP`).
Secure Sockets Layer (`SSL`) or Transport Layer Security (`TLS`).

Mentor tip

State both underlying protocols clearly: `HTTP` and `SSL`/`TLS`.

(a)(ii)

4 marks

`HTTP`: Defines the application-layer rules and message formats for requesting and transferring hypertext documents and web resources between a client browser and a web server.
`SSL` / `TLS`: Establishes an encrypted transport channel using public-key cryptography (PKI) and digital certificates to authenticate the server's identity and encrypt all exchanged session data against eavesdropping or tampering.

Mentor tip

Give two points for HTTP (client-server request/response data transfer) and two for SSL/TLS (server authentication and session key encryption).

(b)

4 marks

1. The user enters a human-readable URL (or clicks a hyperlink) in the web browser.
2. The web browser extracts the domain name from the URL and sends a resolution query to a Domain Name System (DNS) server.
3. The DNS server searches its lookup tables (or queries higher-level DNS servers) to find the numeric IP address mapped to that domain name.
4. The DNS server returns the corresponding IP address to the browser, which then initiates a direct TCP/HTTP connection to the destination web server.

Mentor tip

Trace the exact 4-step sequence: User inputs URL -> Browser queries DNS with domain -> DNS looks up IP -> DNS returns IP to browser.

(c)(i)

4 marks

1. The web server recognizes the `.php` extension and passes the script and incoming HTTP POST request data to the server's PHP interpreter.
2. The script opens a connection to the `library.db` database and extracts the submitted author name from `$_POST['author']`.
3. The SQL `SELECT` query is executed against the `Books` table to retrieve all rows matching that author.
4. The script iterates through the result set (`mysqli_fetch_array`), dynamically constructs an HTML `<table>` containing `FirstName` and `LastName` cells, closes the database connection, and sends the pure HTML output back to the client browser.

Mentor tip

Walk through the PHP code execution chronologically: PHP interpreter invoked -> DB connection & `$_POST` extraction -> SQL query execution -> HTML table generation returned to client.

(c)(ii)

4 marks

Reason 1 — Source Code & Credential Concealment: Server-side scripts execute entirely on the host server and return only standard HTML to the browser; database connection strings, passwords, table schemas, and proprietary logic remain hidden from the client and cannot be viewed or tampered with.
Reason 2 — Controlled Access & Validation Gatekeeping: Preventing direct client connections to the database allows the server script to enforce user authentication, role-based access privileges, and input sanitization before any query touches the confidential database.

Mentor tip

Explain two distinct security benefits: hiding source code/DB credentials from the browser, and preventing direct unauthenticated client access to the database.

Question 10

10 marks

Black hat SEO, keyword stuffing consequences, and authority backlinks

Web science

(a)

2 marks

Black hat search engine optimization refers to aggressive, unethical, or deceptive techniques used to manipulate search engine algorithms and artificially inflate a web page's ranking in violation of search engine guidelines.

Mentor tip

Include both the goal (artificially boosting search ranking) and the nature of the methods (unethical/deceptive/violating search engine rules).

(b)

5 marks

Identification of Technique: The developer is using **keyword stuffing**—unnaturally repeating the phrase `'apple pies'` five times in a short paragraph to manipulate term-frequency rankings.
Consequence 1 — Search Engine Penalty / De-indexing: Modern search engine crawlers detect abnormal keyword density as spam malpractice and will demote the page's ranking or blacklist/remove the site from the search index entirely (though simplistic crawlers might briefly rank it higher initially).
Consequence 2 — Poor User Experience & High Bounce Rate: Human visitors reading the repetitive, unnatural prose will perceive the site as low-quality or spammy and leave immediately, reducing customer trust and conversion.

Mentor tip

First explicitly name 'keyword stuffing' (1 mark), then discuss two distinct consequences (search algorithm penalty/demotion and poor human readability/trust).

(c)

3 marks

Search engine ranking algorithms (such as PageRank and hub/authority models) evaluate both the authority and topical relevance of inbound links (backlinks) pointing to a site.
If a high-quality, authoritative website with relevant content links to the target site, the algorithm passes greater weight/authority, boosting the target site's rank.
Example: A local bakery's webpage receiving an inbound link from a respected culinary magazine or food review portal (e.g., *BBC Good Food*) will gain a much higher ranking boost than a link from an unrelated, low-quality blog.

Mentor tip

Explain how authority/relevance of linking pages transfers ranking weight, and provide a concrete real-world example.

Question 11

17 marks

Internet of Things (IoT), IPv6 addressing, plagiarism checkers, and net neutrality

Web science

(a)(i)

1 mark

Ubiquitous computing (pervasive computing) is the integration of computing power and network connectivity into everyday physical objects and environments so that computing is available everywhere and at any time.

Mentor tip

Emphasize 'everywhere/anytime' computing embedded invisibly into everyday devices.

(a)(ii)

2 marks

The maximum number of uniquely addressable IoT devices is determined by the bit length of the IP address field defined by the protocol version.
While legacy 32-bit `IPv4` ( $2^{32} \approx 4.3 billion$ addresses) is exhausted and cannot support billions of new IoT sensors, transitioning to 128-bit `IPv6` ( $2^{128}$ addresses) provides a virtually inexhaustible address space capable of handling global IoT expansion.

IPv4 : 2^{32} addresses, IPv6 : 2^{128} addresses

Mentor tip

Contrast the address exhaustion of 32-bit IPv4 with the massive capacity of 128-bit IPv6.

(a)(iii)

4 marks

Application Scenario: Automated fleet tracking and predictive maintenance for rental vehicles.
Device Description: Each rental car is equipped with uniquely identifiable embedded IoT telematics sensors, GPS transceivers, and engine diagnostic microprocessors.
Operational Mechanism: These sensors continuously transmit real-time location, mileage, fuel level, and engine health metrics over cellular networks to the rental company's central server.
Business Benefit: The company can automatically bill for mileage/fuel upon return, locate stolen or overdue vehicles instantly, and schedule preventative maintenance before a breakdown occurs.

Mentor tip

Connect four elements: a specific rental business use case, the embedded IoT sensors/microprocessors in each car, how data is transmitted, and the resulting management benefit.

(b)

4 marks

Limitation 1 — False Positives on Quotations and Common Phrases: Text-matching algorithms may flag properly cited direct quotes, standard technical definitions, or bibliographies as plagiarized because they match existing strings verbatim without understanding academic context.
Limitation 2 — False Negatives from Unindexed Sources or Paraphrasing: A checker cannot detect plagiarism if the source material resides in the deep web, behind paywalls, in unindexed print books, or has been heavily paraphrased/translated using synonyms.

Mentor tip

Describe both false positives (flagging legitimate quotes/common phrases) and false negatives (missing unindexed/paywalled or paraphrased sources).

(c)

6 marks

Concept of Net Neutrality: Net neutrality is the principle of an open, democratic web where Internet Service Providers (ISPs) treat all data packets equally, without blocking, throttling, or charging differential fees based on content, website, or sender.
Arguments in Favour of Prioritization Deals (Against Net Neutrality): Commercial prioritization is a standard free-market practice (similar to express shipping or first-class travel); bandwidth-intensive services like 4K video streaming (e.g., Netflix) or telemedicine require guaranteed Quality of Service (QoS), and fees paid by big tech companies can fund ISP fiber-optic infrastructure upgrades.
Arguments Against Prioritization Deals (Supporting Net Neutrality): Creating 'fast lanes' for wealthy corporations stifles innovation and fair competition; a small startup or independent media site cannot afford ISP prioritization fees and will suffer slow loading times compared to entrenched giants, undermining the egalitarian nature of the web.

Mentor tip

Define net neutrality clearly (equal packet treatment), then provide balanced arguments with concrete examples both for and against paid ISP traffic prioritization.

Question 12

10 marks

Bowtie web structure, directed web graphs, and dynamic PageRank

Web science

(a)

4 marks

Sketch the classic Broder bowtie graph topology consisting of a central knot flanked by left and right fan-shaped wings:
```
[ IN ] ------> ( SCC ) ------> [ OUT ]
| ^ ^
+--- (Tube) ----|---------------+
v |
(Tendrils) (Tendrils)
```
Label at least three key regions:
1. **SCC (Strongly Connected Core)**: The central core where every page can reach every other page via directed hyperlinks.
2. **IN**: Pages that can reach the SCC via directed links, but cannot be reached back from the SCC.
3. **OUT**: Pages reachable from the SCC, but which have no path leading back into the SCC.
4. **Tendrils** (dead-end branches attached to IN or OUT that neither reach nor are reached by the SCC) and **Tubes** (direct paths from IN to OUT bypassing the SCC).

Mentor tip

Ensure your diagram shows the bowtie shape with arrows flowing from IN -> SCC -> OUT, and clearly label IN, SCC, OUT, Tendrils, and Tubes.

(b)(i)

3 marks

Each individual web page (or website) is represented as a **node** (vertex) in the graph.
Hyperlinks connecting one page to another are represented as **edges** (arcs) between the nodes.
Arrowheads on the edges indicate the **direction** of the hyperlink (pointing from the source page containing the `<a href>` link to the target destination page; mutual links are shown as two-way arrows).

Mentor tip

Map the three graph components explicitly: web pages = nodes/vertices, hyperlinks = edges, and link direction = directed arrows.

(b)(ii)

3 marks

A page's PageRank is calculated recursively based on both the number of inbound links pointing to it and the individual PageRank scores of those linking pages.
Because the web is dynamic—new pages and hyperlinks are constantly created or deleted—the PageRank of linking pages changes continuously.
Any change in one page's score propagates in a chain reaction to all pages it links to, requiring search engines to repeatedly recompute PageRank across the web graph.

Mentor tip

Explain that PageRank depends on the scores of in-linking pages, creating a recursive chain reaction whenever links are added or removed.

Question 13

10 marks

Semantic web ontologies and ambient vs collective intelligence in healthcare

Web science

(a)

4 marks

The **Semantic Web** (Web 3.0) is an extension of the web in which information is given well-defined, machine-readable meaning (metadata) so software agents can logically query, integrate, and reason over data automatically.
An **ontology** is a formal, shared specification of concepts, categories, properties, and relationships within a specific domain of knowledge.
Relationship: For the Semantic Web to function, web developers and institutions must adopt standardized ontologies (using languages like RDF and OWL) so that automated search algorithms can unambiguously understand that different terms across disparate websites refer to the exact same real-world concept and return complete, logically valid results.

Mentor tip

Define the Semantic Web (machine-understandable data), define an ontology (formal domain vocabulary/relationships), and explain how ontologies provide the shared standard needed for semantic reasoning.

(b)

6 marks

Ambient Intelligence (AmI): Refers to electronic environments that are sensitive, adaptive, and unobtrusively responsive to the presence and physiological state of people.
Collective Intelligence (CI): Refers to shared knowledge and diagnostic insight emerging from the aggregation of data and expertise across large groups of individuals and medical professionals.
Integration of Technologies in Healthcare:
1. **Nanotechnology & Wearable Sensors (AmI)**: Microscopic blood sensors or wearable skin patches continuously and invisibly monitor a patient's vital signs (heart rate, glucose, blood pressure) at home without hospital confinement.
2. **Smartphones (AmI Gateway)**: The patient's smartphone collects sensor readings via Bluetooth, provides immediate localized alerts or medication reminders, and transmits telemetry to the cloud.
3. **Centralized Servers (CI Engine)**: Central hospital servers aggregate real-time sensor streams from thousands of patients alongside specialist doctor input, using collective intelligence pattern analysis to detect early warning signs of complications and automatically dispatch emergency care or adjust treatment plans.

Mentor tip

Define both Ambient Intelligence and Collective Intelligence, then explicitly weave all four listed technologies (sensors, nanotechnology, smartphones, centralized servers) into a cohesive home-healthcare narrative.

Option D: Object-oriented programming · Option

Questions 14–17 · 65 marks

Question 14

21 marks

Hotel room allocation OOP design: Client, Dates, and Room classes

Object-oriented programming

(a)

1 mark

`Client` has a **"has-a"** association (aggregation / dependency) relationship with `Room`, because each `Client` object holds a reference attribute (`private Room bedroom;`) pointing to an allocated `Room` object.

Mentor tip

State 'association', 'aggregation', or 'dependency' (a Client 'has a' Room).

(b)

4 marks

Construct a standard three-compartment UML class diagram for `Room` showing class name, private attributes with types, and public accessor/mutator methods:
```
+------------------------------------+
| Room |
+------------------------------------+
| - roomNumber : int |
| - beds : int |
| - price : double |
| - empty : boolean |
+------------------------------------+
| + Room(int, int, double, boolean) |
| + setRoomNumber(int) : void |
| + setBeds(int) : void |
| + setPrice(double) : void |
| + setEmpty(boolean) : void |
| + getRoomNumber() : int |
| + getBeds() : int |
| + getPrice() : double |
| + getEmpty() : boolean |
+------------------------------------+

Mentor tip

Include the 3-tier box structure, the exact class name `Room`, all four attributes with appropriate types (`int`, `int`, `double`, `boolean`), and the `get`/`set` methods.

(c)

2 marks

Encapsulation and Modularity: Grouping `day`, `month`, and `year` together with date-manipulation methods like `StayDays()` into a single `Dates` class encapsulates date logic into one reusable abstraction.
Code Reuse: The same `Dates` class and its validation/calculation methods can be instantiated multiple times (e.g., for both `arrive` and `leave` attributes) without duplicating variables or date-arithmetic code.

Mentor tip

Highlight encapsulation (bundling day/month/year with `StayDays` logic) and code reuse across multiple date fields.

(d)

6 marks

Declare a method returning an integer array (`int[]`), instantiate a result array to store matching room numbers, iterate through all 100 elements of `allRooms[]`, check if each room has 2 beds and is empty, and return the populated array:
```java
public int[] findRooms() {
int[] available = new int[100];
int count = 0;
for (int i = 0; i < 100; i++) {
if (allRooms[i].getBeds() == 2 && allRooms[i].getEmpty()) {
available[count] = allRooms[i].getRoomNumber();
count++;
}
}
return available;
}
```

Mentor tip

Check both conditions (`getBeds() == 2` and `getEmpty() == true`) inside a loop over `allRooms`, store matching `roomNumber` values in an array, and return it.

(e)

8 marks

Invoke the static method `Dates.StayDays(arrive, leave)` to compute the number of nights stayed.
Retrieve the nightly room rate via `bedroom.getPrice()` (or `getBedroom().getPrice()`) and multiply by the number of nights to calculate total cost.
Output all six required billing items (client name, room number, arrival date, departure date, total nights, and total cost):
```java
public void bill() {
int nights = Dates.StayDays(arrive, leave);
double totalCost = bedroom.getPrice() * nights;
System.out.println("Client Name: " + name);
System.out.println("Room Number: " + bedroom.getRoomNumber());
System.out.println("Arrival Date: " + arrive.getDay() + "/" + arrive.getMonth() + "/" + arrive.getYear());
System.out.println("Departure Date: " + leave.getDay() + "/" + leave.getMonth() + "/" + leave.getYear());
System.out.println("Total Nights: " + nights);
System.out.println("Total Cost: " + totalCost);
}
```

Mentor tip

Make sure you pass `(arrive, leave)` to `Dates.StayDays()`, multiply by `bedroom.getPrice()`, and print every single item listed in the bulleted prompt.

Question 15

18 marks

Hotel group bookings: GClient inheritance, room allocation process, and Group bill()

Object-oriented programming

(a)

7 marks

Define `GClient` using `extends Client` to inherit all attributes and methods from `Client`.
Declare the additional private attribute `private String groupName;`.
Construct the `GClient` constructor that takes all `Client` parameters plus `String g`, invokes `super(id, c, dateIn, dateOut, r)`, and initializes `groupName`, followed by its getter and setter:
```java
public class GClient extends Client {
private String groupName;
public GClient(int id, String c, Dates dateIn, Dates dateOut, Room r, String g) {
super(id, c, dateIn, dateOut, r);
this.groupName = g;
}
public void setGroupName(String groupName) {
this.groupName = groupName;
}
public String getGroupName() {
return groupName;
}
}
```

Mentor tip

Don't forget any of the 7 mark components: `extends Client`, `private String groupName`, full constructor signature, `super(...)` call, `groupName` assignment, `setGroupName`, and `getGroupName`.

(b)

6 marks

1. Instantiate a new `Group` object passing the parameters `"Happy Travellers"` and `15`: `Group trGroup = new Group("Happy Travellers", 15);`.
2. Invoke `findRooms()` to search `allRooms[]` and obtain an array of available `roomNumber` values for empty rooms with 2 beds.
3. Loop 15 times (once for each room required by the group) using the first 15 room numbers from the available array.
4. In each iteration, store the allocated `roomNumber` into the group's `gRooms[]` array and access the corresponding `Room` object in `allRooms[roomNumber - 1]`.
5. Call `setEmpty(false)` on that `Room` object so it is marked as occupied.
6. Instantiate a `GClient` object for the clients in that room, passing their customer ID, name, arrival/departure `Dates`, the `Room` object reference, and the group name `"Happy Travellers"`.

Mentor tip

Mention every key step: instantiating `Group("Happy Travellers", 15)`, calling `findRooms()`, looping 15 times, recording room numbers in `gRooms[]`, setting `empty` to `false` on each `Room`, and instantiating `GClient` objects.

(c)

5 marks

Initialize a running total `double totalCost = 0.0;`, iterate through the `number` of room numbers stored in `gRooms[]`, look up each corresponding `Room` object in `allRooms[]` to retrieve its `getPrice()`, add it to `totalCost`, and output/return the result:
```java
public double bill(int[] gRooms) {
double totalCost = 0.0;
for (int i = 0; i < number; i++) {
for (int j = 0; j < 100; j++) {
if (gRooms[i] == allRooms[j].getRoomNumber()) {
totalCost = totalCost + allRooms[j].getPrice();
}
}
}
System.out.println("Total daily group cost: " + totalCost);
return totalCost;
}
```
(Note: Since `allRooms[]` is sorted in ascending order where room $k$ is at index $k - 1$ , accessing `allRooms[gRooms[i] - 1].getPrice()` directly is also valid).

Mentor tip

Remember to initialize `totalCost = 0.0`, loop through `gRooms`, match each room number to its `Room` object in `allRooms` to call `getPrice()`, accumulate the sum, and output/return it.

Question 16

6 marks

Software maintenance responsibilities and internationalization features

Object-oriented programming

(a)

2 marks

Perform comprehensive regression and unit testing on all modified classes to ensure new features do not introduce bugs into existing booking or billing workflows.
Update technical and user documentation (and properly cite any external libraries or code reused) so future maintainers and hotel staff can understand the updated system.

Mentor tip

Focus on professional developer responsibilities: thorough testing, updating documentation, and citing reused code sources.

(b)

4 marks

Feature 1 — Unicode Character Encoding Support: Modern languages natively support 16-bit/32-bit Unicode strings, enabling the software to store, process, and display client names and user interface messages in any international alphabet or script (e.g., Cyrillic, Arabic, Kanji).
Feature 2 — Platform Portability & Localization Libraries: Languages like Java compile to bytecode that runs on any operating system via a Virtual Machine (JVM) and provide built-in localization (`Locale` / `ResourceBundle`) packages to easily switch currency symbols, date formats (`DD/MM/YYYY` vs `MM/DD/YYYY`), and UI language packs without rewriting core logic.

Mentor tip

Identify two distinct language features (Unicode character sets and platform portability / localization libraries) and explain how each helps sell the software internationally.

Question 17

20 marks

Online bookings LinkedList insertion, arrival array sorting, library ADTs, and BST inorder traversal

Object-oriented programming

(a)

6 marks

Handle the empty list case first (`Bookings.isEmpty()`), otherwise traverse `Bookings` using an index while comparing each node's `getArrive()` date with `aClient.getArrive()`.
Because clients arriving on the exact same date must have the most recently added client placed *first*, insert `aClient` as soon as we reach a node whose arrival date is either equal to (`equalDate`) or later than `aClient.getArrive()`:
```java
public void newClient(Client aClient, LinkedList<Client> Bookings) {
if (Bookings.isEmpty()) {
Bookings.addFirst(aClient);
return;
}
boolean inserted = false;
int index = 0;
while (index < Bookings.size() && !inserted) {
Client current = Bookings.get(index);
Dates cDate = current.getArrive();
Dates aDate = aClient.getArrive();
if (Dates.equalDate(cDate, aDate) ||
Dates.equalDate(Dates.compareDate(cDate, aDate), aDate)) {
Bookings.add(index, aClient);
inserted = true;
} else {
index++;
}
}
if (!inserted) {
Bookings.addLast(aClient);
}
}
```

Mentor tip

Check three insertion cases: empty list (`addFirst`), finding the first existing client with an equal or later arrival date (`Bookings.add(index, aClient)`), and reaching the end of the list (`addLast`).

(b)

6 marks

Since bookings for previous days have already been removed and `Bookings` is sorted by arrival date, all clients arriving `today` are located consecutively at the head of `Bookings`.
Remove each client from the head of `Bookings` while `Dates.equalDate(c.getArrive(), today)` is true, place them into `arrivalsToday[]`, and then sort `arrivalsToday[]` in ascending order of departure date (`getLeave()`) using Bubble Sort:
```java
public Client[] todayClients(Dates today) {
Client[] arrivalsToday = new Client[100];
int count = 0;
while (!Bookings.isEmpty() && Dates.equalDate(Bookings.getFirst().getArrive(), today)) {
arrivalsToday[count] = Bookings.removeFirst();
count++;
}
for (int i = 0; i < count - 1; i++) {
for (int j = 0; j < count - 1 - i; j++) {
Dates d1 = arrivalsToday[j].getLeave();
Dates d2 = arrivalsToday[j + 1].getLeave();
if (!Dates.equalDate(d1, d2) && Dates.equalDate(Dates.compareDate(d1, d2), d2)) {
Client temp = arrivalsToday[j];
arrivalsToday[j] = arrivalsToday[j + 1];
arrivalsToday[j + 1] = temp;
}
}
}
return arrivalsToday;
}
```

Mentor tip

First extract today's arrivals from the front of `Bookings` into `arrivalsToday[]` using `removeFirst()` (or `remove(0)`), then run a nested sorting loop comparing `getLeave()` dates via `Dates.compareDate()`.

(c)

4 marks

Dynamic Memory Sizing: Using a library class such as `ArrayList` or `LinkedList` removes the need to pre-allocate a fixed array size (like `new Client[100]`), as the collection resizes automatically as clients are added or removed.
Built-in Pointer/Index Management & Sorting: Library methods like `add(index, item)`, `removeFirst()`, and `Collections.sort()` automatically handle internal node pointer rewiring or array element shifting, saving the programmer from writing manual shifting loops or bubble sort code.

Mentor tip

Discuss automatic dynamic resizing, built-in insertion/removal shifting (`add`/`remove`), and built-in sorting utilities.

(d)

4 marks

Construct the Binary Search Tree (BST) by inserting the clients in table order (`121` as root `08/05`, then `154` `14/05` right, `132` `06/05` left, `124` `02/06` right of `154`, `117` `15/05` left of `124`, `150` `10/05` left of `154`, `133` `07/05` right of `132`):
```
121 (08/05)
/ \
132 (06/05) 154 (14/05)
\ / \
133 (07/05) 150 (10/05) 124 (02/06)
/
117 (15/05)
```
Recursive Inorder Traversal (`Left -> Root -> Right`):
1. Starting at root `121`, the `inorder(node)` method recursively calls itself on the left subtree (`132`), which has no left child and visits `132 (06/05)`, then recursively traverses its right child `133 (07/05)`.
2. Unwinding back to the root, it visits `121 (08/05)` and then recursively traverses the right subtree rooted at `154`, visiting its left child `150 (10/05)`, then `154 (14/05)`, then going right to `124` where it visits left child `117 (15/05)` before finally visiting `124 (02/06)`.
3. This outputs all `customerID`s in ascending chronological order of `dateOut`: `132, 133, 121, 150, 154, 117, 124`.

Mentor tip

Draw the exact BST ordered by `dateOut` (with `121` at the root) and trace how the recursive `inorder(left) -> visit(node) -> inorder(right)` calls visit nodes in chronological order.

Our analysis

Where the marks are

Each part sorted by the topic it mostly tests. Databases carries the most marks on this paper.

Databases65 marks · 25%
Q1, Q2, Q3, Q4
Modelling and simulation65 marks · 25%
Q5, Q6, Q7, Q8
Web science65 marks · 25%
Q9, Q10, Q11, Q12, Q13
Object-oriented programming65 marks · 25%
Q14, Q15, Q16, Q17

Mentor insights

Traps to watch for

01
Databases: QuickCook restaurant chain data warehouse, ETL data cleansing, vi · Q4
Give three concrete classification categories relevant to restaurant sales analysis.
02
Modelling and simulation: Volcano conservation genetic algorithms, neural network learning, · Q8
Include all five canonical stages of a Genetic Algorithm: initial population, fitness function, selection, crossover/mutation, and iterative convergence.
03
Web science: HTTPS protocols, DNS resolution, and server-side PHP database scr · Q9
State both underlying protocols clearly: `HTTP` and `SSL`/`TLS`.
04
Object-oriented programming: Hotel room allocation OOP design: Client, Dates, and Room classes · Q14
State 'association', 'aggregation', or 'dependency' (a Client 'has a' Room).

Solutions and tips are GeorgeTheTutor's own; the questions are not reproduced here. Not affiliated with or endorsed by the International Baccalaureate Organization.

Want someone to go through your paper with you?

Our maths mentors took these exams recently. One-to-one, they'll find where your marks are going and fix it before May.

Find your maths mentor More past papers

Worked solutions

IB Computer Science HL · Paper 2

Computer Science, Higher Level

Session: May 2016
Marks: 260
Duration: 1 hour 20 min
Calculator: Not allowed
Questions: 17

Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 Q9 Q10 Q11 Q12 Q13 Q14 Q15 Q16 Q17

Keep your copy of the paper open alongside. We don't reproduce the questions: each part below is labelled to match the May 2016 Global paper, which your school or the IB can provide.

Practice mode

Hide our working until you've had a go.

Option A: Databases · Option

Questions 1–4 · 65 marks

Question 1

15 marks

CrossCountryXL transport company relational schema, queries, and data recovery

Databases

(a)

3 marks

Identify the three core entities in the logistics domain: `CrossCountryXL` (or Transport Company), `Retailer`, and `Supplier`.
Determine the relationship cardinalities: `CrossCountryXL` delivers items from multiple `Retailer` entities ( $1 : N$ ), and each `Retailer` deals with multiple `Supplier` entities ( $1 : N$ or $M : N$ as suppliers may supply multiple retailers).
Construct the Entity-Relationship Diagram (ERD) with descriptive action verbs:
`CrossCountryXL` (1) ----< [delivers for] >---- (N) `Retailer` (1/M) ----< [sourced from / supplies] >---- (N) `Supplier`

Mentor tip

Always label both the entity boxes and the relationship diamonds/lines with clear verbs and explicit cardinality notations (1:N or M:N).

(b)

2 marks

In the `SUPPLY` relation, `Supplier_ID` serves as the underlined primary key, which uniquely identifies each tuple in the table.
Because primary key values must be strictly unique and cannot contain duplicates, changing `34567890` to `54959299` (which already exists in row 3 of `SUPPLY`) creates a duplicate key violation and breaks entity/referential integrity.

Mentor tip

Focus on the uniqueness requirement of a primary key: no two records in the same relation can share an identical primary key value.

(c)(i)

1 mark

Filter the `ITEM` table for rows where `Quantity > 150` and project the `Item_Name` column:
`Oranges`, `Bags`, `Wallets`, `Tomatoes` (corresponding to quantities 190, 180, 201, and 167).

Mentor tip

Check every row carefully against the strict inequality (> 150) and output only the requested column (`Item_Name`).

(c)(ii)

1 mark

Filter the `SUPPLY` table for rows where `Nature_Of_Goods = 'P'` and project the `Supplier_ID` column:
`34567890`, `54959299`, `45908919`.

Mentor tip

Ensure all three matching identifier strings are listed accurately.

(d)

4 marks

Step 1 (Table selection): Select both the `SUPPLIER` and `SUPPLY` tables.
Step 2 (Join condition): Link the two relations on their common key: `SUPPLIER.Supplier_ID = SUPPLY.Supplier_ID`.
Step 3 (Filter condition): Apply the selection criterion `SUPPLY.Nature_Of_Goods = 'P'` to isolate perishable goods.
Step 4 (Projection): Project and output the `SUPPLIER.Name` field from the joined, filtered records.

Mentor tip

You can express query steps either as structured algorithmic bullet points or as an equivalent SQL `SELECT ... FROM ... JOIN ... WHERE` statement.

(e)

4 marks

Measure 1 — Write-Ahead Transaction Logging: Record all database modifications and transaction details in a sequential log file on fail-safe external storage before committing changes to disk, allowing the system to replay or undo actions after a crash.
Measure 2 — Regular Off-site Backups: Schedule automated periodic full and incremental backups of the database to redundant remote or cloud storage so the supplier tables can be reconstituted to a known consistent state if hardware fails.

Mentor tip

For each recovery measure, state both the mechanism (e.g., transaction logs, regular backups) and how it restores lost data.

Question 2

14 marks

School Management System schema, concurrency, ACID properties, and transaction rollback

Databases

(a)(i)

1 mark

A database schema is the formal logical blueprint or structural definition of a database, specifying its tables, attributes, data types, keys, and relationships.

Mentor tip

Keep the definition focused on the logical organization and structural blueprint of the database.

(a)(ii)

2 marks

Data consists of raw, unorganized facts or symbols without context—for example, the standalone number `50` or string `'B+'` stored in a table cell.
Information is data that has been processed, structured, and given semantic context for a user—for example, `'Student attendance = 50 days'` or `'Term 1 Mathematics Grade = B+'` displayed on a parent's portal.

Mentor tip

Use concrete examples from the School Management System (attendance figures or subject grades) to contrast raw values with contextualized output.

(b)(i)

2 marks

Lost Update Problem: Two teachers simultaneously open the same student's record to update different subject grades or attendance counts; when both save their changes without locking, the second write overwrites the first teacher's update, causing data loss.
Alternative — Dirty Read / Uncommitted Dependency: One teacher updates a student's grade, and a second teacher (or parent) reads that modified grade before the transaction fails and rolls back, leaving the reader with invalid data.

Mentor tip

Name a specific concurrency anomaly (lost update, dirty read, or incorrect summary) and contextualize it with teachers updating student records.

(b)(ii)

4 marks

Isolation: Ensures that concurrent transactions execute independently as if they were running serially; locking mechanisms prevent two teachers from modifying the exact same student record simultaneously (preventing lost updates).
Consistency (and Atomicity): Guarantees that every transaction brings the database from one valid state to another according to defined integrity rules, resolving temporary update anomalies by ensuring incomplete or conflicting intermediate states are never visible to other users.

Mentor tip

Clearly name the relevant ACID properties (Isolation and Consistency/Atomicity) and explain how each prevents interleaved read/write conflicts.

(c)

3 marks

A `ROLLBACK` operation signals that an active transaction has encountered an error or failed before completion, requiring the DBMS to abort it.
For example, if a teacher is executing a batch update of end-of-term grades and a network or power failure occurs mid-calculation, the transaction is left incomplete.
The DBMS uses the transaction log to undo all partial grade modifications made during that transaction, restoring the student records to their exact pre-transaction state.

Mentor tip

Connect three points: transaction failure detection, a concrete school example (updating grades/attendance), and undoing partial changes to restore the prior state.

(d)

2 marks

Durability guarantees that once a transaction has been successfully committed (such as saving final course grades), its changes are permanently recorded in non-volatile storage.
Even if a system crash or power outage occurs immediately after the commit, the recovery subsystem ensures the updated records are never lost.

Mentor tip

Emphasize permanence after `COMMIT` and survival across system crashes via non-volatile storage.

Question 3

16 marks

Science research firm database administration, privacy, data mining, and 3NF normalization

Databases

(a)

2 marks

Implement role-based access control (RBAC) and granular password/clearance levels so personnel can only view or modify tables relevant to their specific job role.
Configure sensitive research tables as read-only for general staff and revoke access privileges immediately for employees who violate security policies or leave a project.

Mentor tip

Provide two distinct administrative controls focused on internal personnel (e.g., role-based permissions, read-only views, audit logs).

(b)

1 mark

Mentor tip

State a clear operational or security consequence of centralization on the firm's research.

(c)

4 marks

Method 1 — Data Masking / Anonymization: When generating analytical reports from `EMP_DEPT`, mask sensitive digits of `SSN` (e.g. `XXX-XX-9955`) and `DOB` so individual employees cannot be personally identified.
Method 2 — Projection Views / Field Suppression: Create restricted database views that omit personally identifiable attributes such as `EmpName`, `Address`, and `Salary` when sharing departmental statistics (`DeptNo`, `DeptName`) with external auditors or researchers.

Mentor tip

Make explicit reference to the attributes in `EMP_DEPT` (such as `SSN`, `Salary`, `Address`, `EmpName`) when describing privacy measures.

(d)

4 marks

Data Mining is the automated discovery of hidden patterns, correlations, and future trends across massive datasets using statistical or machine learning algorithms (e.g., discovering salary progression trends across departments).
Data Matching compares and links records across two or more distinct datasets (using common identifiers like `SSN` or `EmpName` + `DOB`) to identify duplicate entities, verify identities, or detect discrepancies/fraud.

Mentor tip

Contrast pattern/trend discovery in large datasets (data mining) with cross-dataset record linkage and error/fraud detection (data matching).

(e)(i)

2 marks

Eliminates transitive dependencies between non-key attributes, significantly reducing data duplication (redundancy) across rows.
Prevents update, insertion, and deletion anomalies (for instance, updating a department manager's `DM_SSN` in one place rather than across every employee row in that department, or deleting the last employee in a department without losing the department's details).

Mentor tip

Mention reduced redundancy and elimination of modification anomalies (insertion, update, deletion) or transitive dependencies.

(e)(ii)

3 marks

Identify functional and transitive dependencies in `EMP_DEPT`: `SSN` uniquely determines employee details (`EmpName`, `DOB`, `Salary`, `Address`, `DeptNo`), while `DeptNo` determines department details (`DeptName`, `DM_SSN`).
Decompose into 3NF relations by separating the transitive dependency on department:
`EMPLOYEE` (`SSN`*, `EmpName`, `DOB`, `Salary`, `Address`, *`DeptNo`*)
`DEPARTMENT` (`DeptNo`*, `DeptName`, `DM_SSN`)
(where `*` denotes the Primary Key and `*DeptNo*` in `EMPLOYEE` is the Foreign Key referencing `DEPARTMENT`).

Mentor tip

Always clearly mark the Primary Key (and Foreign Key) in each decomposed 3NF relation and ensure all non-key attributes depend solely on the key.

Question 4

20 marks

QuickCook restaurant chain data warehouse, ETL data cleansing, views, and OODBMS

Databases

(a)

3 marks

Classification by Temporal / Peak Sales Period: Categorizing transactions by day of the week, hour of day, or season to identify peak dining times.
Classification by Product / Menu Category: Grouping sales by food type or meal combos (e.g., burgers, vegetarian, beverages) to see which items sell best.
Classification by Customer Demographics or Spend Bracket: Segmenting orders by price range or customer age group/loyalty tier to analyze spending habits.

Mentor tip

Give three concrete classification categories relevant to restaurant sales analysis.

(b)

2 marks

Every record loaded into a data warehouse is tagged with an explicit timestamp or historical time horizon indicating when the transaction occurred.
This allows analysts to query, sort, and aggregate historical data chronologically across the 20-year span to track long-term longitudinal trends and seasonal comparisons.

Mentor tip

Link the presence of timestamps on warehouse records to the ability to perform historical trend and time-series queries.

(c)

3 marks

Standardize formatting and naming conventions across branches (e.g., converting dates to `YYYY-MM-DD`, standardizing phone numbers, or unifying `'St.'` and `'Street'` in addresses).
Handle missing or `NULL` values by replacing them with standardized default codes (such as `'Not Provided'`) or imputing valid values.
Deduplicate records and enforce unique primary identifiers so merged restaurant logs do not contain repeated or conflicting entries.

Mentor tip

Focus on practical ETL data scrubbing steps: format standardization, null handling, and deduplication/validation.

(d)

4 marks

Storage Persistence: A data warehouse physically stores massive volumes of integrated data persistently on disk, whereas a database view is a virtual table generated dynamically on demand from underlying base tables.
Temporal Scope: A data warehouse maintains historical, time-variant data accumulated over many years (20 years of sales), whereas a view reflects only the current real-time state of an operational transactional database.
Structure and Optimization: Data warehouses use denormalized multidimensional schemas (star/snowflake) indexed for complex OLAP analytics, whereas views are relational extracts that cannot be indexed independently of their underlying base tables.
Data Integration: A data warehouse consolidates heterogeneous data from multiple local restaurant databases via ETL, whereas a view typically queries tables within a single database system.

Mentor tip

Contrast views and data warehouses across four clear axes: physical vs virtual storage, historical vs current data, OLAP indexing vs relational extract, and multi-source vs single-DB scope.

(e)

2 marks

Before loading: Temporarily disable indexes and referential integrity constraints on the target warehouse tables (and perform a backup) so bulk insertion runs rapidly without per-row index overhead.
After loading: Rebuild/re-enable all indexes and run automated integrity and row-count verification checks to confirm that all transformed records loaded completely and accurately.

Mentor tip

Mention disabling indexes/constraints (or backing up) prior to bulk load, and re-enabling indexes / verifying data integrity afterward.

(f)(i)

2 marks

Encapsulation (bundling complex data structures and the methods that operate on them into self-contained objects).
Inheritance (allowing new data subtypes to inherit attributes and behaviors from existing superclass definitions) and Polymorphism.

Mentor tip

State any two core OOP pillars: Encapsulation, Inheritance, or Polymorphism.

(f)(ii)

4 marks

Advantage — Complex Data Types & No Impedance Mismatch: An OODBMS natively stores rich, complex composite objects (images, multimedia, nested recipes) and uses the same object model as the host OOP language, eliminating the need to translate objects into flat relational tables and improving code reusability.
Disadvantage — Lack of Universal Standards and Views: Unlike SQL in relational databases, OODBMSs lack a universally agreed-upon query standard and mathematical data model, and they typically lack simple virtual view mechanisms or granular table-level security controls, making ad-hoc reporting and migration harder.

Mentor tip

Option B: Modelling and simulation · Option

Questions 5–8 · 65 marks

Question 5

17 marks

Town estate agent property price mathematical model and spreadsheet rules

Modelling and simulation

(a)

4 marks

`Size`: Stored as a numeric integer or floating-point value representing square metres (e.g., `120` for $120 m^{2}$ ).
`Property_Type`: Stored as a single character code or integer flag (e.g., `'H'` for house and `'A'` for apartment, or `1` and `2`).
`District`: Stored as an integer code from `1` to `4` corresponding to the town's four districts.
`Condition`: Stored as an ordinal integer scale from `1` to `5` or short text code (e.g., `5` = very good, `4` = good, `3` = medium, `2` = poor, `1` = very poor).

Mentor tip

Give a clear data type/representation and a concrete example value for all four property attributes.

(b)

6 marks

Set up spreadsheet columns for a property row (e.g., Row 2): Column A = `Size` (`100`), Column B = `Type` (`'A'`), Column C = `District` (`1`), Column D = `Condition` (`4` for good).
Determine Base Price per $m^{2}$ in Column E using a conditional formula: `=IF(B2="A", 2000, 2300)`.
Determine the District Multiplier in Column F using nested `IF` or `VLOOKUP`: `=IF(C2=1, 1.25, IF(C2=2, 1.00, IF(C2=3, 0.95, 0.90)))`.
Determine the Condition Multiplier in Column G using a lookup table or nested `IF` (e.g., `=VLOOKUP(D2, CondTable, 2, FALSE)` where `4` maps to `1.00`).
Calculate the Estimated Selling Price in Column H by multiplying Size, Base Price, District Multiplier, and Condition Multiplier: `=ColA2 * E2 * F2 * G2`.

Estimated Price = Size \times BaseRate \times DistrictMultiplier \times ConditionMultiplier

Mentor tip

Clearly show the column layout, how each multiplier/base value is selected (via `IF` or `VLOOKUP`), and the final multiplication formula.

(c)

3 marks

For a large sample of sold properties, calculate the residual difference between the model's `Estimated_Price` and the actual `Final_Selling_Price`.
Also calculate the time on market (`Date_Sold - Date_First_For_Sale`) to see if certain price brackets or districts take abnormally long to sell.
If properties in a specific district or condition consistently sell above or below the estimate (or stagnate on the market), adjust the corresponding district or condition multipliers in the model to minimize estimation error.

Mentor tip

Mention comparing estimated vs actual selling prices across many sales, analyzing time on the market using the two dates, and tuning the multipliers accordingly.

(d)

4 marks

Method 1 — Unsold Inventory vs Sold Comparison: Filter and group properties that remain unsold (or have a very large `Date_Sold - Date_First_For_Sale` duration) and compare their attributes (e.g., District 4 apartments in poor condition) against properties that sold quickly.
Method 2 — Pivot Table / Category Aggregation: Sort or group historical records by each variable (`District`, `Type`, `Condition`, `Size` bracket) and compute the average days on market and percentage of unsold listings for each combination to pinpoint which traits deter buyers.

Mentor tip

Explain two ways to group and compare property attributes against time-on-market or sold/unsold status.

Question 6

16 marks

Railway station ticket machines and manned ticket offices queue simulation

Modelling and simulation

(a)

4 marks

A model is the static mathematical and logical representation of the station's ticketing system, defining variables and rules such as service rates for Type 1/Type 2 machines, staffed counter hours, and passenger arrival distributions.
A simulation is the dynamic execution of that model over time using varied inputs—for example, running virtual rush-hour passenger arrivals through different combinations of Type 1/Type 2 machines to observe resulting queue lengths and wait times.

Mentor tip

Define both terms and explicitly anchor each to the railway station ticketing scenario.

(b)(i)

2 marks

Passenger arrival rates and transaction types across different times of day and days of the week (e.g., peak morning commute vs off-peak).
Average service time required per transaction at Type 1 machines, Type 2 machines, and manned ticket offices (plus capital/operating costs of machines and staff).

Mentor tip

Identify both demand data (passenger volume by time/ticket type) and service capacity data (transaction durations and costs).

(b)(ii)

2 marks

Extract automated historical transaction logs from the central railway database, which record exact timestamps and durations for every ticket printed at Type 1/Type 2 machines and manned counters.
Supplement automated logs with CCTV queue analysis or timed observational sampling during peak and off-peak periods to measure actual passenger waiting times.

Mentor tip

Automated electronic log extraction from existing ticket machines and central servers is the most efficient primary collection method.

(c)

2 marks

Feed the recorded historical passenger arrival streams into the simulation while systematically varying parameters: the count of Type 1 machines, count of Type 2 machines, and opening hours/staffing of ticket offices.
Observe and record the resulting passenger flow, maximum queue lengths, and average waiting times across each time period for every configuration.

Mentor tip

Explain how the collected arrival data is held constant while machine counts and counter hours are varied to measure queue performance.

(d)

2 marks

Criterion — Maximum / Average Passenger Waiting Time during Rush Hour: Compare whether each configuration keeps ticket collection waits below a target threshold (e.g., under 3 minutes so online bookers do not miss trains).
Alternative Criterion — Total Implementation and Operating Cost: Compare the capital expense of installing additional Type 1/2 machines against the ongoing wage cost of extending manned ticket office hours.

Mentor tip

State a clear metric (e.g., rush-hour wait time or total cost) and explain how it distinguishes better configurations.

(e)

4 marks

Reasons why it is valid / transferable: The underlying queuing logic, machine transaction speeds, and software structure of the simulation model remain valid because all stations use the same Type 1/Type 2 hardware and ticket rules.
Reasons why results are not directly transferable: Different stations have vastly different passenger volumes, commuter demographics (e.g., tourist hubs needing complex advice vs commuter stations needing season renewals), physical layouts, and train frequencies.
Conclusion: While the simulation software framework can be reused across the network, local passenger arrival data must be collected and input separately for each individual station before deciding on equipment numbers.

Mentor tip

Balance the discussion: the simulation *framework/rules* are reusable, but the specific *output recommendations* are not transferable without local station data.

Question 7

12 marks

Emergency helicopter pilot training simulator and 3D visualization

Modelling and simulation

(a)

4 marks

Advantage — Safe Exposure to Rare/Extreme Hazards: Pilots can repeatedly practice life-threatening emergencies (engine failure, severe mountain storms, night rescues) in a simulator with zero risk to life or expensive aircraft, whereas live training flights only encounter weather and conditions that happen to occur that day.
Disadvantage — Lack of Real Psychological Stress & Mentor Nuance: A simulator cannot fully replicate the physical G-forces, adrenaline, or unpredictable human factors of a real rescue, and trainees miss out on the tacit, real-time situational coaching of an experienced co-pilot.

Mentor tip

Provide a fully explained advantage (safety / rare emergency repeatability) and a fully explained disadvantage (fidelity limits / high setup cost / lack of human mentor).

(b)

2 marks

Hardware: High-performance multi-core CPU with dedicated GPUs for real-time 3D rendering, wraparound cockpit displays/VR headset, physical flight controls (cyclic, collective, pedals), and hydraulic motion actuators.
Software: Real-time flight physics and aerodynamics engine coupled with 3D terrain rendering and weather/emergency scenario generation software.

Mentor tip

You must explicitly mention both a hardware requirement and a software requirement to earn full marks.

(c)

3 marks

Helicopter rescue operations occur in complex three-dimensional terrain (mountains, valleys, tall buildings) where altitude, depth perception, and obstacle clearance are critical.
The pilot must judge vertical and lateral distances simultaneously while hovering or landing on uneven surfaces.
The visual scene must update dynamically in real time across all three axes (pitch, roll, yaw, elevation) in response to the pilot's control inputs.

Mentor tip

Connect 3D terrain geometry (altitude/depth), spatial judgment required by the pilot, and real-time perspective updates.

(d)

3 marks

The terrain and objects are stored in memory as a mathematical wireframe/polygon mesh defined by 3D vertex coordinates $(x, y, z)$ , edges, and surface properties.
As the helicopter moves, geometric transformations (translation, rotation, scaling, perspective projection) recalculate the 3D coordinates relative to the pilot's viewpoint.
A rendering pipeline applies hidden-surface removal, texture mapping, shading, and lighting (such as ray tracing or rasterization) to convert the mathematical model into a realistic 2D perspective image on the cockpit screens.

Mentor tip

Trace the pipeline from mathematical 3D coordinates in memory -> geometric transformation -> rendering (lighting/shading/textures) for display.

Question 8

20 marks

Volcano conservation genetic algorithms, neural network learning, and robot NLP

Modelling and simulation

(a)

5 marks

Step 1 (Initialization): Generate an initial population of random potential routes (chromosomes) visiting the displaced animal groups.
Step 2 (Fitness Evaluation): Evaluate each path using a fitness function based on total distance, terrain elevation difficulty, and volcanic hazard zones.
Step 3 (Selection): Select the highest-performing (shortest/safest) routes as parents and discard the least fit paths.
Step 4 (Crossover & Mutation): Combine segments of parent routes (crossover) and introduce small random alterations to waypoint order (mutation) to form a new generation of paths.
Step 5 (Termination): Repeat evaluation, selection, and reproduction over many generations until the algorithm converges on an optimal or near-optimal rescue route.

Mentor tip

Include all five canonical stages of a Genetic Algorithm: initial population, fitness function, selection, crossover/mutation, and iterative convergence.

(b)

6 marks

Supervised Learning: The neural network is trained on labeled input-output pairs where the target outcome is already known; the network compares its predictions against the known correct outputs and adjusts its weights to minimize error.
Unsupervised Learning: The neural network is given unlabeled input data with no predetermined target answers and must autonomously discover hidden structures, clusters, or patterns in the data.
Suitability for Volcano Scenario: Unsupervised learning is more suitable here because the post-eruption terrain is altered and the daily movement patterns of displaced animals are previously unknown (there is no labeled historical training set of correct paths for this eruption).

Mentor tip

(c)

3 marks

Learnable by robots: Formal, rule-governed structures of language including explicit vocabulary (lexicon), grammatical syntax rules, and repetitive/standardized sentence patterns.
Difficult/unlearnable by robots: Deep semantic ambiguity, irony, sarcasm, cultural idioms, emotional tone, and context-dependent pragmatic meaning that do not follow fixed deterministic rules.

Mentor tip

Contrast rule-based linguistic elements (vocabulary, syntax, fixed grammar) with context-heavy human elements (pragmatics, idioms, emotion, ambiguity).

(d)

6 marks

Human Language Learning: Humans acquire language through complex cognitive development, social interaction, sensory experience, and emotional context (reading facial expressions, body language, and real-world situational cues).
Machine Language Learning: Computers process language algorithmically using predefined syntactic rules, statistical probabilities (n-grams, neural language models), and heuristic pattern matching over massive text corpora.
Comparison & Conclusion: While machines can rapidly process vast vocabularies and probabilistic word associations, they lack genuine conscious comprehension or embodied world experience, making it difficult for machines to interpret novel metaphors or nuanced human intent as naturally as humans do.

Mentor tip

Option C: Web science · Option

Questions 9–13 · 65 marks

Question 9

18 marks

HTTPS protocols, DNS resolution, and server-side PHP database scripting

Web science

(a)(i)

2 marks

Hypertext Transfer Protocol (`HTTP`).
Secure Sockets Layer (`SSL`) or Transport Layer Security (`TLS`).

Mentor tip

State both underlying protocols clearly: `HTTP` and `SSL`/`TLS`.

(a)(ii)

4 marks

`HTTP`: Defines the application-layer rules and message formats for requesting and transferring hypertext documents and web resources between a client browser and a web server.
`SSL` / `TLS`: Establishes an encrypted transport channel using public-key cryptography (PKI) and digital certificates to authenticate the server's identity and encrypt all exchanged session data against eavesdropping or tampering.

Mentor tip

Give two points for HTTP (client-server request/response data transfer) and two for SSL/TLS (server authentication and session key encryption).

(b)

4 marks

1. The user enters a human-readable URL (or clicks a hyperlink) in the web browser.
2. The web browser extracts the domain name from the URL and sends a resolution query to a Domain Name System (DNS) server.
3. The DNS server searches its lookup tables (or queries higher-level DNS servers) to find the numeric IP address mapped to that domain name.
4. The DNS server returns the corresponding IP address to the browser, which then initiates a direct TCP/HTTP connection to the destination web server.

Mentor tip

Trace the exact 4-step sequence: User inputs URL -> Browser queries DNS with domain -> DNS looks up IP -> DNS returns IP to browser.

(c)(i)

4 marks

1. The web server recognizes the `.php` extension and passes the script and incoming HTTP POST request data to the server's PHP interpreter.
2. The script opens a connection to the `library.db` database and extracts the submitted author name from `$_POST['author']`.
3. The SQL `SELECT` query is executed against the `Books` table to retrieve all rows matching that author.
4. The script iterates through the result set (`mysqli_fetch_array`), dynamically constructs an HTML `<table>` containing `FirstName` and `LastName` cells, closes the database connection, and sends the pure HTML output back to the client browser.

Mentor tip

Walk through the PHP code execution chronologically: PHP interpreter invoked -> DB connection & `$_POST` extraction -> SQL query execution -> HTML table generation returned to client.

(c)(ii)

4 marks

Reason 1 — Source Code & Credential Concealment: Server-side scripts execute entirely on the host server and return only standard HTML to the browser; database connection strings, passwords, table schemas, and proprietary logic remain hidden from the client and cannot be viewed or tampered with.
Reason 2 — Controlled Access & Validation Gatekeeping: Preventing direct client connections to the database allows the server script to enforce user authentication, role-based access privileges, and input sanitization before any query touches the confidential database.

Mentor tip

Explain two distinct security benefits: hiding source code/DB credentials from the browser, and preventing direct unauthenticated client access to the database.

Question 10

10 marks

Black hat SEO, keyword stuffing consequences, and authority backlinks

Web science

(a)

2 marks

Mentor tip

Include both the goal (artificially boosting search ranking) and the nature of the methods (unethical/deceptive/violating search engine rules).

(b)

5 marks

Identification of Technique: The developer is using **keyword stuffing**—unnaturally repeating the phrase `'apple pies'` five times in a short paragraph to manipulate term-frequency rankings.
Consequence 1 — Search Engine Penalty / De-indexing: Modern search engine crawlers detect abnormal keyword density as spam malpractice and will demote the page's ranking or blacklist/remove the site from the search index entirely (though simplistic crawlers might briefly rank it higher initially).
Consequence 2 — Poor User Experience & High Bounce Rate: Human visitors reading the repetitive, unnatural prose will perceive the site as low-quality or spammy and leave immediately, reducing customer trust and conversion.

Mentor tip

First explicitly name 'keyword stuffing' (1 mark), then discuss two distinct consequences (search algorithm penalty/demotion and poor human readability/trust).

(c)

3 marks

Search engine ranking algorithms (such as PageRank and hub/authority models) evaluate both the authority and topical relevance of inbound links (backlinks) pointing to a site.
If a high-quality, authoritative website with relevant content links to the target site, the algorithm passes greater weight/authority, boosting the target site's rank.
Example: A local bakery's webpage receiving an inbound link from a respected culinary magazine or food review portal (e.g., *BBC Good Food*) will gain a much higher ranking boost than a link from an unrelated, low-quality blog.

Mentor tip

Explain how authority/relevance of linking pages transfers ranking weight, and provide a concrete real-world example.

Question 11

17 marks

Internet of Things (IoT), IPv6 addressing, plagiarism checkers, and net neutrality

Web science

(a)(i)

1 mark

Mentor tip

Emphasize 'everywhere/anytime' computing embedded invisibly into everyday devices.

(a)(ii)

2 marks

The maximum number of uniquely addressable IoT devices is determined by the bit length of the IP address field defined by the protocol version.
While legacy 32-bit `IPv4` ( $2^{32} \approx 4.3 billion$ addresses) is exhausted and cannot support billions of new IoT sensors, transitioning to 128-bit `IPv6` ( $2^{128}$ addresses) provides a virtually inexhaustible address space capable of handling global IoT expansion.

IPv4 : 2^{32} addresses, IPv6 : 2^{128} addresses

Mentor tip

Contrast the address exhaustion of 32-bit IPv4 with the massive capacity of 128-bit IPv6.

(a)(iii)

4 marks

Application Scenario: Automated fleet tracking and predictive maintenance for rental vehicles.
Device Description: Each rental car is equipped with uniquely identifiable embedded IoT telematics sensors, GPS transceivers, and engine diagnostic microprocessors.
Operational Mechanism: These sensors continuously transmit real-time location, mileage, fuel level, and engine health metrics over cellular networks to the rental company's central server.
Business Benefit: The company can automatically bill for mileage/fuel upon return, locate stolen or overdue vehicles instantly, and schedule preventative maintenance before a breakdown occurs.

Mentor tip

Connect four elements: a specific rental business use case, the embedded IoT sensors/microprocessors in each car, how data is transmitted, and the resulting management benefit.

(b)

4 marks

Limitation 1 — False Positives on Quotations and Common Phrases: Text-matching algorithms may flag properly cited direct quotes, standard technical definitions, or bibliographies as plagiarized because they match existing strings verbatim without understanding academic context.
Limitation 2 — False Negatives from Unindexed Sources or Paraphrasing: A checker cannot detect plagiarism if the source material resides in the deep web, behind paywalls, in unindexed print books, or has been heavily paraphrased/translated using synonyms.

Mentor tip

Describe both false positives (flagging legitimate quotes/common phrases) and false negatives (missing unindexed/paywalled or paraphrased sources).

(c)

6 marks

Concept of Net Neutrality: Net neutrality is the principle of an open, democratic web where Internet Service Providers (ISPs) treat all data packets equally, without blocking, throttling, or charging differential fees based on content, website, or sender.
Arguments in Favour of Prioritization Deals (Against Net Neutrality): Commercial prioritization is a standard free-market practice (similar to express shipping or first-class travel); bandwidth-intensive services like 4K video streaming (e.g., Netflix) or telemedicine require guaranteed Quality of Service (QoS), and fees paid by big tech companies can fund ISP fiber-optic infrastructure upgrades.
Arguments Against Prioritization Deals (Supporting Net Neutrality): Creating 'fast lanes' for wealthy corporations stifles innovation and fair competition; a small startup or independent media site cannot afford ISP prioritization fees and will suffer slow loading times compared to entrenched giants, undermining the egalitarian nature of the web.

Mentor tip

Define net neutrality clearly (equal packet treatment), then provide balanced arguments with concrete examples both for and against paid ISP traffic prioritization.

Question 12

10 marks

Bowtie web structure, directed web graphs, and dynamic PageRank

Web science

(a)

4 marks

Sketch the classic Broder bowtie graph topology consisting of a central knot flanked by left and right fan-shaped wings:
```
[ IN ] ------> ( SCC ) ------> [ OUT ]
| ^ ^
+--- (Tube) ----|---------------+
v |
(Tendrils) (Tendrils)
```
Label at least three key regions:
1. **SCC (Strongly Connected Core)**: The central core where every page can reach every other page via directed hyperlinks.
2. **IN**: Pages that can reach the SCC via directed links, but cannot be reached back from the SCC.
3. **OUT**: Pages reachable from the SCC, but which have no path leading back into the SCC.
4. **Tendrils** (dead-end branches attached to IN or OUT that neither reach nor are reached by the SCC) and **Tubes** (direct paths from IN to OUT bypassing the SCC).

Mentor tip

Ensure your diagram shows the bowtie shape with arrows flowing from IN -> SCC -> OUT, and clearly label IN, SCC, OUT, Tendrils, and Tubes.

(b)(i)

3 marks

Each individual web page (or website) is represented as a **node** (vertex) in the graph.
Hyperlinks connecting one page to another are represented as **edges** (arcs) between the nodes.
Arrowheads on the edges indicate the **direction** of the hyperlink (pointing from the source page containing the `<a href>` link to the target destination page; mutual links are shown as two-way arrows).

Mentor tip

Map the three graph components explicitly: web pages = nodes/vertices, hyperlinks = edges, and link direction = directed arrows.

(b)(ii)

3 marks

A page's PageRank is calculated recursively based on both the number of inbound links pointing to it and the individual PageRank scores of those linking pages.
Because the web is dynamic—new pages and hyperlinks are constantly created or deleted—the PageRank of linking pages changes continuously.
Any change in one page's score propagates in a chain reaction to all pages it links to, requiring search engines to repeatedly recompute PageRank across the web graph.

Mentor tip

Explain that PageRank depends on the scores of in-linking pages, creating a recursive chain reaction whenever links are added or removed.

Question 13

10 marks

Semantic web ontologies and ambient vs collective intelligence in healthcare

Web science

(a)

4 marks

The **Semantic Web** (Web 3.0) is an extension of the web in which information is given well-defined, machine-readable meaning (metadata) so software agents can logically query, integrate, and reason over data automatically.
An **ontology** is a formal, shared specification of concepts, categories, properties, and relationships within a specific domain of knowledge.
Relationship: For the Semantic Web to function, web developers and institutions must adopt standardized ontologies (using languages like RDF and OWL) so that automated search algorithms can unambiguously understand that different terms across disparate websites refer to the exact same real-world concept and return complete, logically valid results.

Mentor tip

(b)

6 marks

Ambient Intelligence (AmI): Refers to electronic environments that are sensitive, adaptive, and unobtrusively responsive to the presence and physiological state of people.
Collective Intelligence (CI): Refers to shared knowledge and diagnostic insight emerging from the aggregation of data and expertise across large groups of individuals and medical professionals.
Integration of Technologies in Healthcare:
1. **Nanotechnology & Wearable Sensors (AmI)**: Microscopic blood sensors or wearable skin patches continuously and invisibly monitor a patient's vital signs (heart rate, glucose, blood pressure) at home without hospital confinement.
2. **Smartphones (AmI Gateway)**: The patient's smartphone collects sensor readings via Bluetooth, provides immediate localized alerts or medication reminders, and transmits telemetry to the cloud.
3. **Centralized Servers (CI Engine)**: Central hospital servers aggregate real-time sensor streams from thousands of patients alongside specialist doctor input, using collective intelligence pattern analysis to detect early warning signs of complications and automatically dispatch emergency care or adjust treatment plans.

Mentor tip

Option D: Object-oriented programming · Option

Questions 14–17 · 65 marks

Question 14

21 marks

Hotel room allocation OOP design: Client, Dates, and Room classes

Object-oriented programming

(a)

1 mark

Mentor tip

State 'association', 'aggregation', or 'dependency' (a Client 'has a' Room).

(b)

4 marks

Construct a standard three-compartment UML class diagram for `Room` showing class name, private attributes with types, and public accessor/mutator methods:
```
+------------------------------------+
| Room |
+------------------------------------+
| - roomNumber : int |
| - beds : int |
| - price : double |
| - empty : boolean |
+------------------------------------+
| + Room(int, int, double, boolean) |
| + setRoomNumber(int) : void |
| + setBeds(int) : void |
| + setPrice(double) : void |
| + setEmpty(boolean) : void |
| + getRoomNumber() : int |
| + getBeds() : int |
| + getPrice() : double |
| + getEmpty() : boolean |
+------------------------------------+

Mentor tip

Include the 3-tier box structure, the exact class name `Room`, all four attributes with appropriate types (`int`, `int`, `double`, `boolean`), and the `get`/`set` methods.

(c)

2 marks

Encapsulation and Modularity: Grouping `day`, `month`, and `year` together with date-manipulation methods like `StayDays()` into a single `Dates` class encapsulates date logic into one reusable abstraction.
Code Reuse: The same `Dates` class and its validation/calculation methods can be instantiated multiple times (e.g., for both `arrive` and `leave` attributes) without duplicating variables or date-arithmetic code.

Mentor tip

Highlight encapsulation (bundling day/month/year with `StayDays` logic) and code reuse across multiple date fields.

(d)

6 marks

Declare a method returning an integer array (`int[]`), instantiate a result array to store matching room numbers, iterate through all 100 elements of `allRooms[]`, check if each room has 2 beds and is empty, and return the populated array:
```java
public int[] findRooms() {
int[] available = new int[100];
int count = 0;
for (int i = 0; i < 100; i++) {
if (allRooms[i].getBeds() == 2 && allRooms[i].getEmpty()) {
available[count] = allRooms[i].getRoomNumber();
count++;
}
}
return available;
}
```

Mentor tip

Check both conditions (`getBeds() == 2` and `getEmpty() == true`) inside a loop over `allRooms`, store matching `roomNumber` values in an array, and return it.

(e)

8 marks

Invoke the static method `Dates.StayDays(arrive, leave)` to compute the number of nights stayed.
Retrieve the nightly room rate via `bedroom.getPrice()` (or `getBedroom().getPrice()`) and multiply by the number of nights to calculate total cost.
Output all six required billing items (client name, room number, arrival date, departure date, total nights, and total cost):
```java
public void bill() {
int nights = Dates.StayDays(arrive, leave);
double totalCost = bedroom.getPrice() * nights;
System.out.println("Client Name: " + name);
System.out.println("Room Number: " + bedroom.getRoomNumber());
System.out.println("Arrival Date: " + arrive.getDay() + "/" + arrive.getMonth() + "/" + arrive.getYear());
System.out.println("Departure Date: " + leave.getDay() + "/" + leave.getMonth() + "/" + leave.getYear());
System.out.println("Total Nights: " + nights);
System.out.println("Total Cost: " + totalCost);
}
```

Mentor tip

Make sure you pass `(arrive, leave)` to `Dates.StayDays()`, multiply by `bedroom.getPrice()`, and print every single item listed in the bulleted prompt.

Question 15

18 marks

Hotel group bookings: GClient inheritance, room allocation process, and Group bill()

Object-oriented programming

(a)

7 marks

Define `GClient` using `extends Client` to inherit all attributes and methods from `Client`.
Declare the additional private attribute `private String groupName;`.
Construct the `GClient` constructor that takes all `Client` parameters plus `String g`, invokes `super(id, c, dateIn, dateOut, r)`, and initializes `groupName`, followed by its getter and setter:
```java
public class GClient extends Client {
private String groupName;
public GClient(int id, String c, Dates dateIn, Dates dateOut, Room r, String g) {
super(id, c, dateIn, dateOut, r);
this.groupName = g;
}
public void setGroupName(String groupName) {
this.groupName = groupName;
}
public String getGroupName() {
return groupName;
}
}
```

Mentor tip

Don't forget any of the 7 mark components: `extends Client`, `private String groupName`, full constructor signature, `super(...)` call, `groupName` assignment, `setGroupName`, and `getGroupName`.

(b)

6 marks

1. Instantiate a new `Group` object passing the parameters `"Happy Travellers"` and `15`: `Group trGroup = new Group("Happy Travellers", 15);`.
2. Invoke `findRooms()` to search `allRooms[]` and obtain an array of available `roomNumber` values for empty rooms with 2 beds.
3. Loop 15 times (once for each room required by the group) using the first 15 room numbers from the available array.
4. In each iteration, store the allocated `roomNumber` into the group's `gRooms[]` array and access the corresponding `Room` object in `allRooms[roomNumber - 1]`.
5. Call `setEmpty(false)` on that `Room` object so it is marked as occupied.
6. Instantiate a `GClient` object for the clients in that room, passing their customer ID, name, arrival/departure `Dates`, the `Room` object reference, and the group name `"Happy Travellers"`.

Mentor tip

(c)

5 marks

Initialize a running total `double totalCost = 0.0;`, iterate through the `number` of room numbers stored in `gRooms[]`, look up each corresponding `Room` object in `allRooms[]` to retrieve its `getPrice()`, add it to `totalCost`, and output/return the result:
```java
public double bill(int[] gRooms) {
double totalCost = 0.0;
for (int i = 0; i < number; i++) {
for (int j = 0; j < 100; j++) {
if (gRooms[i] == allRooms[j].getRoomNumber()) {
totalCost = totalCost + allRooms[j].getPrice();
}
}
}
System.out.println("Total daily group cost: " + totalCost);
return totalCost;
}
```
(Note: Since `allRooms[]` is sorted in ascending order where room $k$ is at index $k - 1$ , accessing `allRooms[gRooms[i] - 1].getPrice()` directly is also valid).

Mentor tip

Remember to initialize `totalCost = 0.0`, loop through `gRooms`, match each room number to its `Room` object in `allRooms` to call `getPrice()`, accumulate the sum, and output/return it.

Question 16

6 marks

Software maintenance responsibilities and internationalization features

Object-oriented programming

(a)

2 marks

Perform comprehensive regression and unit testing on all modified classes to ensure new features do not introduce bugs into existing booking or billing workflows.
Update technical and user documentation (and properly cite any external libraries or code reused) so future maintainers and hotel staff can understand the updated system.

Mentor tip

Focus on professional developer responsibilities: thorough testing, updating documentation, and citing reused code sources.

(b)

4 marks

Feature 1 — Unicode Character Encoding Support: Modern languages natively support 16-bit/32-bit Unicode strings, enabling the software to store, process, and display client names and user interface messages in any international alphabet or script (e.g., Cyrillic, Arabic, Kanji).
Feature 2 — Platform Portability & Localization Libraries: Languages like Java compile to bytecode that runs on any operating system via a Virtual Machine (JVM) and provide built-in localization (`Locale` / `ResourceBundle`) packages to easily switch currency symbols, date formats (`DD/MM/YYYY` vs `MM/DD/YYYY`), and UI language packs without rewriting core logic.

Mentor tip

Identify two distinct language features (Unicode character sets and platform portability / localization libraries) and explain how each helps sell the software internationally.

Question 17

20 marks

Online bookings LinkedList insertion, arrival array sorting, library ADTs, and BST inorder traversal

Object-oriented programming

(a)

6 marks

Handle the empty list case first (`Bookings.isEmpty()`), otherwise traverse `Bookings` using an index while comparing each node's `getArrive()` date with `aClient.getArrive()`.
Because clients arriving on the exact same date must have the most recently added client placed *first*, insert `aClient` as soon as we reach a node whose arrival date is either equal to (`equalDate`) or later than `aClient.getArrive()`:
```java
public void newClient(Client aClient, LinkedList<Client> Bookings) {
if (Bookings.isEmpty()) {
Bookings.addFirst(aClient);
return;
}
boolean inserted = false;
int index = 0;
while (index < Bookings.size() && !inserted) {
Client current = Bookings.get(index);
Dates cDate = current.getArrive();
Dates aDate = aClient.getArrive();
if (Dates.equalDate(cDate, aDate) ||
Dates.equalDate(Dates.compareDate(cDate, aDate), aDate)) {
Bookings.add(index, aClient);
inserted = true;
} else {
index++;
}
}
if (!inserted) {
Bookings.addLast(aClient);
}
}
```

Mentor tip

(b)

6 marks

Since bookings for previous days have already been removed and `Bookings` is sorted by arrival date, all clients arriving `today` are located consecutively at the head of `Bookings`.
Remove each client from the head of `Bookings` while `Dates.equalDate(c.getArrive(), today)` is true, place them into `arrivalsToday[]`, and then sort `arrivalsToday[]` in ascending order of departure date (`getLeave()`) using Bubble Sort:
```java
public Client[] todayClients(Dates today) {
Client[] arrivalsToday = new Client[100];
int count = 0;
while (!Bookings.isEmpty() && Dates.equalDate(Bookings.getFirst().getArrive(), today)) {
arrivalsToday[count] = Bookings.removeFirst();
count++;
}
for (int i = 0; i < count - 1; i++) {
for (int j = 0; j < count - 1 - i; j++) {
Dates d1 = arrivalsToday[j].getLeave();
Dates d2 = arrivalsToday[j + 1].getLeave();
if (!Dates.equalDate(d1, d2) && Dates.equalDate(Dates.compareDate(d1, d2), d2)) {
Client temp = arrivalsToday[j];
arrivalsToday[j] = arrivalsToday[j + 1];
arrivalsToday[j + 1] = temp;
}
}
}
return arrivalsToday;
}
```

Mentor tip

(c)

4 marks

Dynamic Memory Sizing: Using a library class such as `ArrayList` or `LinkedList` removes the need to pre-allocate a fixed array size (like `new Client[100]`), as the collection resizes automatically as clients are added or removed.
Built-in Pointer/Index Management & Sorting: Library methods like `add(index, item)`, `removeFirst()`, and `Collections.sort()` automatically handle internal node pointer rewiring or array element shifting, saving the programmer from writing manual shifting loops or bubble sort code.

Mentor tip

Discuss automatic dynamic resizing, built-in insertion/removal shifting (`add`/`remove`), and built-in sorting utilities.

(d)

4 marks

Construct the Binary Search Tree (BST) by inserting the clients in table order (`121` as root `08/05`, then `154` `14/05` right, `132` `06/05` left, `124` `02/06` right of `154`, `117` `15/05` left of `124`, `150` `10/05` left of `154`, `133` `07/05` right of `132`):
```
121 (08/05)
/ \
132 (06/05) 154 (14/05)
\ / \
133 (07/05) 150 (10/05) 124 (02/06)
/
117 (15/05)
```
Recursive Inorder Traversal (`Left -> Root -> Right`):
1. Starting at root `121`, the `inorder(node)` method recursively calls itself on the left subtree (`132`), which has no left child and visits `132 (06/05)`, then recursively traverses its right child `133 (07/05)`.
2. Unwinding back to the root, it visits `121 (08/05)` and then recursively traverses the right subtree rooted at `154`, visiting its left child `150 (10/05)`, then `154 (14/05)`, then going right to `124` where it visits left child `117 (15/05)` before finally visiting `124 (02/06)`.
3. This outputs all `customerID`s in ascending chronological order of `dateOut`: `132, 133, 121, 150, 154, 117, 124`.

Mentor tip

Draw the exact BST ordered by `dateOut` (with `121` at the root) and trace how the recursive `inorder(left) -> visit(node) -> inorder(right)` calls visit nodes in chronological order.

Our analysis

Where the marks are

Each part sorted by the topic it mostly tests. Databases carries the most marks on this paper.

Databases65 marks · 25%
Q1, Q2, Q3, Q4
Modelling and simulation65 marks · 25%
Q5, Q6, Q7, Q8
Web science65 marks · 25%
Q9, Q10, Q11, Q12, Q13
Object-oriented programming65 marks · 25%
Q14, Q15, Q16, Q17

Mentor insights

Traps to watch for

01
Databases: QuickCook restaurant chain data warehouse, ETL data cleansing, vi · Q4
Give three concrete classification categories relevant to restaurant sales analysis.
02
Modelling and simulation: Volcano conservation genetic algorithms, neural network learning, · Q8
Include all five canonical stages of a Genetic Algorithm: initial population, fitness function, selection, crossover/mutation, and iterative convergence.
03
Web science: HTTPS protocols, DNS resolution, and server-side PHP database scr · Q9
State both underlying protocols clearly: `HTTP` and `SSL`/`TLS`.
04
Object-oriented programming: Hotel room allocation OOP design: Client, Dates, and Room classes · Q14
State 'association', 'aggregation', or 'dependency' (a Client 'has a' Room).

Solutions and tips are GeorgeTheTutor's own; the questions are not reproduced here. Not affiliated with or endorsed by the International Baccalaureate Organization.

Want someone to go through your paper with you?

Our maths mentors took these exams recently. One-to-one, they'll find where your marks are going and fix it before May.

Find your maths mentor More past papers