Loading…

Worked solutions

IB Computer Science SL · Paper 2

Computer Science, Standard Level

Session: November 2015
Marks: 180
Duration: 1 hour
Calculator: Not allowed
Questions: 13

Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 Q9 Q10 Q11 Q12 Q13

Keep your copy of the paper open alongside. We don't reproduce the questions: each part below is labelled to match the November 2015 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–3 · 45 marks

Question 1

15 marks

Small shop customer database benefits, costs, primary/secondary keys, SQL queries, and query optimization

Databases

(a)(i)

1 mark

Identify one business benefit of implementing a customer database:
Enables structured sales trend analysis, improved financial tracking, or faster retrieval of customer order histories.

Mentor tip

State any clear operational advantage such as improved financial control, sales analysis, or better customer service.

(a)(ii)

1 mark

Identify one implementation cost:
Staff training expenses, DBMS software licensing/maintenance costs, or hardware acquisition/upgrade expenses.

Mentor tip

Mention software, hardware, or personnel training costs.

(b)(i)

1 mark

Count the columns (`Name`, `Date`, `ItemOrdered`, `QuantityOrdered`, `InvoiceAmount`) in `CustomerTable`:
There are `5` fields in each record.

Mentor tip

Fields correspond to columns in a relational table.

(b)(ii)

2 marks

Explain why `Name` is unsuitable as a primary key:
1. A primary key must uniquely identify every individual record in a table (no duplicate values).
2. Different customers can share the same name, or the same customer can place multiple orders—for instance, `Ann Low` appears twice in `CustomerTable` (on `18/04/2015` and `19/04/2015`).

Mentor tip

Cite the exact duplicate value from the table (`Ann Low`) to support why `Name` violates uniqueness.

(b)(iii)

1 mark

Define a secondary key:
An attribute (or set of attributes) that is not selected as the primary key, used as an index to speed up searching and sorting records (or a non-selected alternate key).

Mentor tip

Define a secondary key as a field indexed for faster searching/sorting or an alternate key not chosen as the primary key.

(c)

4 marks

Construct the query steps or SQL statement to retrieve the target items:
1. Select the output column `ItemOrdered` from `CustomerTable`.
2. Filter rows where `Date` equals `'19/04/2015'`.
3. Filter rows where `QuantityOrdered` is strictly greater than `5` (`QuantityOrdered > 5`).
4. Combine both conditions using the logical `AND` operator:
```sql SELECT ItemOrdered FROM CustomerTable WHERE Date = '19/04/2015' AND QuantityOrdered > 5; ```

Mentor tip

Make sure all four elements are explicit: `SELECT ItemOrdered`, `Date = '19/04/2015'`, `QuantityOrdered > 5`, and the `AND` logical operator.

(d)

5 marks

Explain software and structural optimizations to speed up query response time without changing hardware:
1. Normalize into a Relational Schema: Split the flat file into normalized relational tables (`Customers`, `Orders`, `Items`) to eliminate redundant data.
2. Faster Scanning: Smaller, non-redundant tables require fewer disk reads and less memory during query execution.
3. Create Indexes on Frequently Queried Fields: Add secondary key indexes on `Date` and `ItemOrdered` so the DBMS uses fast tree lookups rather than full-table linear scans.
4. Disk Defragmentation / Compaction: Defragment the storage drive and compact the database file so related table blocks are stored contiguously, minimizing disk head seek times.
5. Archive Historical Records: Move old completed orders out of the active operational table to keep the working dataset small.

Mentor tip

Link each software action (normalizing tables, adding indexes, defragmenting storage) to why it speeds up queries (reduced redundancy, fewer disk seeks, smaller search space).

Question 2

15 marks

Tourist bike hire DBMS functions and step-by-step normalization from 1NF to 3NF

Databases

(a)

3 marks

Identify three core functions provided by a Database Management System (DBMS):
1. Data Manipulation & Storage Interface: Provides an abstraction layer allowing users to insert, update, delete, and query bike hire records without knowing physical storage details.
2. Security & Access Control: Enforces user authentication and permissions to protect customer data from unauthorized access or theft.
3. Integrity, Concurrency & Recovery: Prevents data corruption via validation constraints and provides backup/recovery utilities in the event of a system crash.

Mentor tip

List three distinct DBMS capabilities: CRUD/query interface, access security, and backup/integrity management.

(b)

2 marks

Outline the purpose of database normalization:
1. To decompose a single unorganized table into separate, logically related entity tables.
2. To minimize data redundancy (saving storage space) and eliminate update, insertion, and deletion anomalies.

Mentor tip

Mention separating distinct entities into related tables and eliminating redundancy/anomalies.

(c)(i)

1 mark

State the characteristic of First Normal Form (1NF):
Every attribute contains only atomic (indivisible) values, there are no repeating groups or duplicate columns, and a primary key uniquely identifies each row.

Mentor tip

Focus on atomic values, no repeating columns/groups, and a primary key.

(c)(ii)

1 mark

State the characteristic of Second Normal Form (2NF):
The relation is in 1NF and every non-key attribute is fully functionally dependent on the entire primary key (no partial dependencies on part of a composite key).

Mentor tip

State: in 1NF + no partial dependencies on a subset of a composite primary key.

(c)(iii)

1 mark

State the characteristic of Third Normal Form (3NF):
The relation is in 2NF and contains no transitive dependencies (no non-key attribute depends on another non-key attribute; every non-key attribute depends solely on the primary key).

Mentor tip

State: in 2NF + no transitive dependencies between non-key attributes.

(d)

7 marks

Construct the database schema in 1NF, 2NF, and 3NF using shorthand notation:
1. First Normal Form (1NF) — Introduce a unique primary key `RentalNo` (or a composite primary key such as `(HirerID, BikeID, TimeOut)`) to uniquely identify each rental transaction:
`BIKEHIRE_1NF(RentalNo [PK], HirerID, HName, HPhone, TimeOut, TimeIn, BikeID, BikeMake, BikeModel)`
2. Second Normal Form (2NF) — When using the single-attribute surrogate primary key `RentalNo`, there is no composite key, so the 2NF relation is identical to 1NF (or if using composite key `(HirerID, BikeID, TimeOut)`, separate partial dependencies into `HIRER`, `BIKE`, and `RENTAL`):
`BIKEHIRE_2NF(RentalNo [PK], HirerID, HName, HPhone, TimeOut, TimeIn, BikeID, BikeMake, BikeModel)`
3. Third Normal Form (3NF) — Remove transitive dependencies (`HName` and `HPhone` depend on `HirerID`; `BikeMake` and `BikeModel` depend on `BikeID`) by splitting into three relations with primary keys (`[PK]`) and foreign keys (`*` / `[FK]`):
`HIRERTABLE(HirerID [PK], HName, HPhone)`
`BIKETABLE(BikeID [PK], BikeMake, BikeModel)`
`RENTALTABLE(RentalNo [PK], TimeOut, TimeIn, BikeID* [FK], HirerID* [FK])`

Mentor tip

Clearly underline or label primary keys (`[PK]`) and mark foreign keys (`*` or `[FK]`) in `RENTALTABLE`.

Question 3

15 marks

Logical vs physical database design, data dictionary contents, DBA duties, and online job database pros/cons

Databases

(a)

4 marks

Distinguish between logical and physical database design:
1. Conceptual/Structural Focus vs Storage Implementation: Logical design defines *what* data is stored—specifying entities, attributes, tables, and relationships (ERDs and normalized schemas) independent of hardware.
2. Physical Implementation: Physical design specifies *how* the database is actually implemented on storage media—defining exact DBMS data types, index structures, file partitions, and disk allocation.
3. Perspective & Performance: Logical design models the system from the business/user information perspective, whereas physical design optimizes low-level disk I/O speed and storage efficiency.
4. Chronological Order: Logical design is completed first during systems analysis, and physical design follows during implementation.

Mentor tip

Contrast 'what relationships/tables exist' (logical, user-oriented, done first) with 'how data is physically stored and indexed on disk' (physical, performance-oriented, done second).

(b)

3 marks

Identify three items of metadata stored in a data dictionary:
1. Field/attribute names and their data types/lengths (e.g., `VARCHAR(50)`, `INT`).
2. Validation rules, default values, and primary/foreign key constraints.
3. Table relationships, ownership/access permissions, and physical storage locations.

Mentor tip

List three distinct metadata properties: field definitions/types, constraints/keys, and access rights/table relationships.

(c)

4 marks

Explain two responsibilities of a Database Administrator (DBA):
1. Backup and Disaster Recovery (2 marks): The DBA schedules periodic automated backups and tests recovery protocols so the organization can restore data swiftly after hardware failures or corruption.
2. Security and Access Control (2 marks): The DBA configures user accounts, passwords, role-based views, and permissions to ensure only authorized personnel can read or modify sensitive records.

Mentor tip

Name two distinct DBA responsibilities and explain the purpose/actions involved in each for 2 marks apiece.

(d)

4 marks

Discuss one advantage and one disadvantage of the online job database:
1. Advantage (Centralized 24/7 Accessibility): Job seekers can search, filter, and apply to up-to-date vacancies from any location at any time, while employers immediately reach a large pool of applicants.
2. Disadvantage (Privacy & Security Vulnerability): Storing applicants' personal CVs, contact details, and employment histories online exposes them to data breaches or identity theft.
3. Elaboration / Implication: Furthermore, an applicant's current employer might search the database, discover their employee's profile, and learn they are seeking to leave the company.

Mentor tip

State one clear usability/access benefit for applicants, one clear privacy/security risk, and elaborate on the real-world impact.

Option B: Modelling and simulation · Option

Questions 4–6 · 45 marks

Question 4

17 marks

Urban PM10 air pollution spreadsheet modelling, daily/annual reporting, temporal patterns, and policy simulation

Modelling and simulation

(a)

3 marks

Outline a clear spreadsheet organization for hourly PM10 readings over a year:
1. Yearly / Monthly Worksheet Structure: Dedicate one workbook per year (or 12 monthly worksheets within an annual workbook).
2. Daily Rows: Assign each calendar day of the year (365 rows) to a separate row labelled with the date.
3. Hourly Columns: Assign the 24 hourly PM10 measurements (`00:00` to `23:00`) to 24 adjacent columns (`B` through `Y`), with summary columns at the end of each row for the day's average and limit check.

Mentor tip

Explicitly account for all three time scales: 24 hourly readings (columns), 365 days (rows), and yearly/monthly sheets.

(b)

5 marks

Describe how hourly readings are processed for daily press releases and the end-of-year report:
1. Initialize Counter: At the start of the year (1 January), initialize an exceedance counter `daysOver50 = 0`.
2. Daily Mean Calculation: At the end of each 24-hour cycle, calculate the daily average PM10 by summing the 24 hourly cells and dividing by 24 (`=AVERAGE(B2:Y2)`).
3. Daily Threshold Check & Press Output: If the daily average exceeds `50`, increment `daysOver50` by 1 (or use `=COUNTIF(Z2:Z366, ">50")`), and output both yesterday's average and the cumulative `daysOver50` count to the local press.
4. Annual Mean Calculation: At the end of 31 December, compute the overall annual mean by averaging all 365 daily averages (`=AVERAGE(Z2:Z366)`).
5. End-of-Year Report Generation: Generate a line/bar chart from the 365 daily average cells and compile the chart, final `daysOver50` count, and annual mean into the regulatory compliance report.

Mentor tip

Cover all 5 steps: daily average calculation, checking `> 50` to increment the counter, sending daily stats to the press, calculating the yearly mean, and plotting the annual chart.

(c)(i)

2 marks

Identify two temporal pollution patterns discoverable from the model:
1. Diurnal (time-of-day) cycles, such as morning and evening rush-hour traffic spikes versus overnight lows.
2. Seasonal cycles (e.g., higher PM10 in winter due to domestic heating and temperature inversions compared to summer) or weekday-versus-weekend differences.

Mentor tip

Name two distinct time-based patterns: time-of-day (rush hour), day-of-week (weekday vs weekend), or seasonal (winter vs summer).

(c)(ii)

2 marks

Explain how one identified pattern helps urban planning:
1. If the model reveals severe morning/evening rush-hour peaks (or winter heating spikes),
2. the town council can stagger school and factory start times, expand public transit during peak hours, or regulate industrial/heating emissions during high-risk periods.

Mentor tip

Directly connect the pattern chosen in (c)(i) to a concrete municipal policy intervention.

(d)

5 marks

Explain how the simulation model estimates the minimum required 'no car' weekends:
1. Quantify Single-Event Impact: Measure the exact drop in PM10 recorded during the initial 'no car' weekend compared to normal weekends.
2. Baseline Projection: Use historical seasonal trends and the current year-to-date average (`45 µg m^-3`) to project expected daily PM10 values for the remaining days of the year without intervention.
3. Iterative What-If Simulation: Run the simulation by progressively substituting 1, 2, 3, ..., $k$ 'no car' weekends into the remaining calendar and recalculating the resulting annual mean.
4. Identify Minimum Threshold: Find the smallest integer $k$ for which the projected full-year average drops to `<= 40 µg m^-3` (minimizing commercial disruption).
5. Continuous Recalibration: Re-run and update the model after each 'no car' weekend using actual weather and pollution readings, since meteorological conditions vary.

Mentor tip

Show how the measured reduction from one 'no car' weekend is iteratively applied to projected remaining days until the annual mean reaches `<= 40`, and mention recalibrating as real data arrives.

Question 5

16 marks

4x4 board game simulation, move analysis, memory representation, game tree search, and board scaling

Modelling and simulation

(a)

1 mark

Identify all legal moves for Player A from square 1 (with Player B on square 6):
Player A can move right to `2`, down to `5`, or jump diagonally over Player B (on `6`) to land on `11`. Legal squares: `2, 5, or 11`.

Mentor tip

Don't forget the diagonal jump rule: since diagonal square 6 is occupied by B, A jumps over 6 into 11.

(b)

3 marks

Analyse each possible move for Player A (at square 2) and justify Player B's optimal response (from square 10):
1. Case 1 — Player A moves right to `3`: Player B (at `10`) can move right to `11`, down to `14`, or diagonally to `15`. Moving to `11` or `15` places B one step away from `HOME` (`16`) for an immediate win on B's next turn.
2. Case 2 — Player A moves down to `6`: Player B (at `10`) can move diagonally to `15` (or right to `11`), which guarantees reaching `HOME` (`16`) on B's next turn before A can reach `HOME`.
3. Case 3 — Player A moves diagonally to `7`: Player B (at `10`) should move to `11` or `15`, positioning B directly adjacent to `HOME` to win on the following turn.

Mentor tip

List all three of Player A's legal moves from square 2 (`3`, `6`, and `7`) and state B's winning counter-move (`11` or `15`) for each.

(c)(i)

2 marks

Outline a memory representation for the board and player positions:
1. Use a 2D array `board[4][4]` (with row index `r` and column index `c` from `1..4` or `0..3`), or store two coordinate pairs `(rowA, colA)` and `(rowB, colB)`.
2. Store an integer/character code in the array cells (`0` = empty, `1` = Player A, `2` = Player B) or maintain separate variables distinguishing Player A's coordinates from Player B's coordinates.

Mentor tip

Clearly specify the data structure (e.g., a 4x4 2D array or `(row, col)` coordinate variables) and how Player A and Player B are distinguished.

(c)(ii)

1 mark

State the positions of Player A (square 2) and Player B (square 10) using 1-based `(row, col)` coordinates:
Player A is at `(1, 2)` and Player B is at `(3, 2)` (or `(0, 1)` and `(2, 1)` in 0-based indexing).

Mentor tip

Ensure your coordinates match the exact indexing convention defined in part (c)(i).

(c)(iii)

2 marks

Outline how the program identifies all legal moves from `(r, c)`:
1. Compute the three target adjacent coordinates: right `(r, c + 1)`, down `(r + 1, c)`, and diagonal `(r + 1, c + 1)`, checking that each stays within the board boundaries (`<= 4`).
2. If a target square contains the opponent's position, check whether the jump landing square (`(r, c + 2)`, `(r + 2, c)`, or `(r + 2, c + 2)`) is within the `1..4` board limits.

Mentor tip

Include both boundary checking (staying on the 4x4 grid) and the occupancy check that triggers a jump coordinate calculation.

(c)(iv)

3 marks

Suggest an algorithm to select the optimal move from the legal options:
1. Lookahead Tree Generation: For each legal move of the current player, generate all legal counter-moves available to the opponent.
2. Recursive Path Evaluation: Continue expanding subsequent turns recursively until `HOME` `(4, 4)` is reached along each branch.
3. Shortest/Minimax Selection: Select the move that leads to the shortest guaranteed path to `HOME` (or blocks the opponent from reaching `HOME` first).

Mentor tip

Describe a game-tree lookahead: simulate current moves -> simulate opponent responses -> trace to `HOME` -> pick the shortest winning path.

(d)

4 marks

Outline the computational impact of increasing the board to a much larger grid (e.g., $N \times N$ ):
1. Combinatorial Explosion of Paths: Every additional row and column exponentially increases the branching factor and depth of the game tree (number of possible move sequences to `HOME`).
2. Increased CPU Processing & Memory Usage: Evaluating all lookahead paths requires vastly more CPU cycles and call-stack memory.
3. Degraded Gameplay Responsiveness: Turn calculation time increases significantly, introducing noticeable lag and slowing down the game unless search depth is pruned.

Mentor tip

Explain both why the math scales rapidly (combinatorial explosion of paths as rows/columns grow) and the practical effect on the program (more CPU/memory processing, slower response time).

Question 6

12 marks

Autonomous self-driving car HD maps, 3D motion analysis, real-time memory/compute requirements, and social implications

Modelling and simulation

(a)

2 marks

Outline why high-definition (HD) maps must be held in memory alongside camera/laser sensors:
1. Onboard cameras and LiDAR lasers only detect immediate line-of-sight surroundings, whereas HD maps provide static road geometry, lane rules, speed limits, and route topology beyond sensor range.
2. Combining live sensor inputs with pre-loaded HD maps allows the car to localize its exact position and plan a safe trajectory toward its destination.

Mentor tip

Contrast immediate local perception (cameras/lasers) with global route/road-rule knowledge (HD maps) and explain how combining them guides navigation.

(b)

3 marks

Outline how analysing successive 3D images in memory supports safe driving:
1. Instantaneous Spatial Snapshot: Each 3D frame captures the exact positions and distances of surrounding obstacles, pedestrians, and vehicles at a specific instant.
2. Velocity & Trajectory Estimation: By comparing changes in object coordinates across consecutive 3D frames over time ( $Δ t$ ), the system calculates the speed and direction of moving hazards.
3. Collision Avoidance: The car projects future paths of moving objects and adjusts its steering or braking proactively to maintain safe following distances and avoid collisions.

Mentor tip

Highlight the progression: single 3D snapshot (position) -> comparison across consecutive frames (speed & direction of movement) -> path prediction & obstacle avoidance.

(c)

3 marks

Outline the time and memory demands of 3D visualization in an autonomous vehicle:
1. Strict Real-Time Processing: Because the car is moving at highway speeds, 3D sensor fusion and rendering must execute in real time (milliseconds) with zero lag to react to sudden hazards.
2. High RAM Capacity: Massive high-speed memory is required to buffer and manipulate continuous streams of high-resolution 3D point clouds, multi-angle colour video frames, and detailed HD map tiles simultaneously.
3. Parallel Compute Throughput: Dedicated high-bandwidth processors/GPUs are needed to continuously update the 3D environmental model.

Mentor tip

Address both Time (strict real-time processing because the vehicle is moving) and Memory (large RAM needed to hold high-res 3D point clouds, colour images, and HD maps).

(d)

4 marks

Discuss the social, legal, and safety implications of self-driving cars:
1. Reduced Human Error & Efficiency: Autonomous cars do not suffer from fatigue, distraction, or intoxication, potentially reducing traffic accidents, optimizing fuel consumption, and granting mobility to elderly or disabled passengers.
2. Unpredictable Edge Cases & Malfunctions: Software may fail to interpret novel, unprogrammed road scenarios or sensor failures in severe weather, requiring robust fail-safe mechanisms.
3. Legal & Ethical Liability: If an autonomous vehicle causes a fatal collision, determining legal liability (between the vehicle owner, software developer, or car manufacturer) raises complex legal and ethical dilemmas.
4. Employment Impact: Widespread adoption threatens the livelihoods of professional taxi, bus, and haulage drivers.

Mentor tip

Balance safety/efficiency advantages against edge-case risks, legal liability questions, and employment impacts.

Option C: Web science · Option

Questions 7–9 · 45 marks

Question 7

18 marks

XML syntax validation, extensibility, CSS benefits, TCP/IP packet transmission, client-side validation, and AJAX partial updates

Web science

(a)

1 mark

Identify the syntax error in the XML snippet:
The first `<dvd>` element is missing its closing `</dvd>` tag (after `<genre>Fantasy</genre>`).

Mentor tip

Every opening tag in well-formed XML must have a matching closing tag before the next sibling record begins.

(b)

2 marks

Outline the meaning of 'extensibility' in XML:
1. Unlike HTML, XML does not restrict developers to a fixed, predefined set of markup tags.
2. Users can invent and define their own custom, domain-specific tag names (such as `<collection>`, `<dvd>`, `<genre>`) to structure any type of data.

Mentor tip

Emphasize that developers can extend the tag set by defining their own custom tags.

(c)

2 marks

Describe one benefit of storing styling rules in an external CSS file:
1. A single external CSS stylesheet can be linked across hundreds of HTML pages, ensuring visual consistency across the website.
2. Updating a style rule once in the CSS file automatically updates the appearance of every linked HTML page, saving development and maintenance time.

Mentor tip

Explain that one CSS file styles multiple HTML documents, so a single edit updates the entire site.

(d)

4 marks

Describe how TCP and IP collaborate to transmit the XML document over the internet:
1. TCP Segmentation: The Transmission Control Protocol (TCP) breaks the XML document from the application layer into small, numbered data packets (segments) and adds sequence numbers and checksums.
2. IP Addressing & Routing: The Internet Protocol (IP) encapsulates each TCP segment by adding an IP header containing the source and destination IP addresses, and routes the packets across intermediate network routers.
3. TCP Acknowledgement & Reassembly: At the destination web server, TCP verifies packet integrity, requests retransmission of any lost packets, and reassembles them in the correct sequence order.

Mentor tip

Clearly separate TCP's job (breaking data into numbered packets + reliable reassembly) from IP's job (adding source/destination IP headers + routing across the network).

(e)(i)

3 marks

Explain how client-side scripting validates the login form before submission:
1. Software / Language: A script written in `JavaScript` runs locally inside the user's web browser.
2. Pre-submission Trigger: When the user clicks submit, the JavaScript function inspects the form inputs before any HTTP request is sent.
3. Validation Checks: It verifies that `Name` and `Country` are not blank and checks that the `Email` field conforms to a valid format (e.g., contains an `@` symbol and domain extension), alerting the user immediately if invalid.

Mentor tip

Explicitly name `JavaScript`, state that it validates form fields locally in the browser, and give a concrete check (such as verifying the `@` symbol in the email field).

(e)(ii)

2 marks

Outline the benefit of client-side validation for the shopping site:
1. Filters out invalid or incomplete form submissions on the client device, reducing unnecessary network traffic and processing load on the shopping site's web server.
2. Frees up server resources so the server can handle more concurrent customer requests (and gives instant feedback to the user).

Mentor tip

Focus on reduced server-side processing load and reduced network bandwidth usage.

(f)

4 marks

Explain how scripts update a user's profile photograph without reloading the entire page:
1. Asynchronous Client Request: A client-side script (such as JavaScript / AJAX `XMLHttpRequest` or `fetch`) captures the user's photo selection and sends an asynchronous background request to the web server.
2. Server-Side Database Query: A server-side script (e.g., PHP/Node.js) executes an SQL query against the backend database to retrieve or update the selected photograph's file path.
3. Targeted Response: The server returns only the new image data or URL rather than a complete HTML document.
4. DOM Manipulation: The client-side JavaScript dynamically updates the `src` attribute of the specific `<img>` element in the Document Object Model (DOM), refreshing just the profile photo region.

Mentor tip

Trace the full cycle: client-side script sends async request -> server queries database via SQL -> server returns new photo -> client script updates only that specific DOM element.

Question 8

17 marks

Lossy compression user experience, search engine crawling/indexing/searching, PageRank bias against new sites, and index freshness

Web science

(a)

5 marks

Discuss how lossy compression affects the end-user experience:
1. Mechanism: Lossy compression permanently discards redundant or perceptually less noticeable data from a file to achieve a much smaller file size.
2. Positive Impact (Speed & Bandwidth): Smaller file sizes dramatically reduce download/streaming times, prevent buffering on slow connections, and consume less mobile data.
3. Tolerable Perceptual Trade-off: For multimedia (such as a JPEG web photo or MP3 audio stream), minor high-frequency detail removal is often imperceptible to human eyes or ears.
4. Negative Impact (Quality Degradation): If the compression ratio is too aggressive—or if the user requires high-resolution fidelity (e.g., medical imaging or archival photography)—visible compression artifacts (pixelation, blurring, audio distortion) degrade the experience.
5. Appraisal: For general web browsing, faster page loading outweighs minor quality loss, provided compression levels are sensibly balanced.

Mentor tip

Weigh the positive effects (smaller file size -> faster download -> unnoticeable detail loss in casual media) against the negative effects (permanent data loss -> visible artifacts if over-compressed).

(b)

6 marks

Outline the functions of the three core search engine processes:
1. Crawling (2 marks): Automated bots (spiders/crawlers) systematically traverse the web by following hyperlinks from page to page and fetching copies of the HTML documents they discover.
2. Indexing (2 marks): The parser analyses each fetched page to extract significant keywords, headings, meta-tags, and inbound/outbound links, storing mappings from keywords to URLs in a massive inverted index database.
3. Searching (2 marks): When a user submits a query, the search processor parses the search terms, looks up matching URLs in the index, ranks them by relevance/authority (e.g., PageRank), and returns the ordered results list.

Mentor tip

Provide two clear points for each of the three stages: Crawling (traverse links + fetch page copies), Indexing (extract keywords + store in index database), and Searching (match query against index + return ranked results).

(c)

3 marks

Explain why PageRank can disadvantage newly launched websites:
1. Backlink Dependency: PageRank calculates a page's authority score primarily from the quantity and PageRank quality of external inbound links (backlinks) pointing to it.
2. Cold-Start Problem: A newly created website initially has very few or zero external websites linking to it.
3. Low Visibility Cycle: Consequently, the new site receives a very low PageRank score and appears buried far down in search results, making it harder for users to discover and link to it.

Mentor tip

Connect PageRank's reliance on backlinks -> new sites having few/no backlinks -> resulting low rank and poor search visibility.

(d)

3 marks

Explain how a search engine keeps its index up to date as the web grows:
1. Continuous Scheduled Crawling: Distributed web crawlers run continuously in the background, revisiting frequently updated hubs (like news sites) at short intervals.
2. Link Discovery: Whenever an existing indexed page adds a hyperlink to a newly created page, the crawler follows that link and adds the new page to the index.
3. Direct Webmaster Submission / Sitemaps: Website administrators can proactively notify the search engine of new or updated URLs by submitting XML sitemaps or URL indexing requests.

Mentor tip

Mention both continuous automated re-crawling of links and direct sitemap/URL notifications from webmasters.

Question 9

10 marks

Public cloud architectural features and hybrid cloud strategy for seasonal online retail

Web science

(a)

4 marks

Describe two essential architectural features of a sustainable public cloud model:
1. Resource Virtualization & Multi-Tenancy (2 marks): Physical servers and storage arrays are abstracted into virtual machines and pooled so hardware capacity can be dynamically shared and reassigned across multiple customers.
2. Rapid Elasticity / On-Demand Scalability & Distributed Grid Architecture (2 marks): A distributed network of data centres paired with an automated self-service portal allows clients to provision or release compute and bandwidth capacity on demand as traffic fluctuates.

Mentor tip

Name two distinct architectural pillars (e.g., virtualization, distributed grid systems, on-demand scalability, or self-service provisioning) and explain how each works.

(b)

6 marks

Explain how the online retailer can apply a hybrid cloud strategy across all four operational factors:
1. Private Cloud for Sensitive Financial Data: Host customer credit card records, accounting ledgers, and core day-to-day ERP operations on a dedicated, tightly secured private cloud behind corporate firewalls.
2. Public Cloud Bursting for Christmas Peak Demand: During the Christmas shopping surge, dynamically rent elastic public cloud web servers and bandwidth to absorb traffic spikes without buying permanent hardware that would sit idle the rest of the year.
3. Public Cloud for Promotional Email Campaigns: Offload bulk promotional mailing operations to specialized public cloud email/SaaS services designed for high-volume delivery.
4. Public Cloud Sandboxes for Upcoming Development Projects: Provision temporary public cloud virtual environments and storage for software developers to build and test new projects, tearing them down once deployed.

Mentor tip

Explicitly map all four bullet points from the prompt (financial data -> private cloud; Christmas surge, promotional emails, and temporary dev projects -> public cloud) with clear justifications.

Option D: Object-oriented programming · Option

Questions 10–13 · 45 marks

Question 10

15 marks

Village health clinic OOP design: constructors, Patient/WaitingRoom aggregation, priority search, and array shifting

Object-oriented programming

(a)

2 marks

Define a constructor with an example from the clinic code:
1. A constructor is a special method sharing the exact same name as its class (and no return type) that is invoked to instantiate and initialize a new object of that class.
2. Example from code: `public Patient(int i, String n, int p)` (or the default constructor `new WaitingRoom()`).

Mentor tip

Include both the definition (method with the class name that initializes a new instance) and the exact signature `public Patient(int i, String n, int p)`.

(b)

2 marks

Describe one additional field appropriate for the `Patient` class:
1. Field & Data Type: `private String phoneNumber;` (or `private String dateOfBirth;` / `private String address;`).
2. Sample Data & Purpose: `"0734599881"` — used by the clinic to contact the patient regarding appointments or test results.

Mentor tip

Ensure you include all three requested elements: field purpose/name, Java data type (`String`, `int`, `boolean`), and realistic sample data.

(c)

2 marks

Describe the object relationship between `WaitingRoom` and `Patient`:
1. Aggregation ('has-a' relationship): A `WaitingRoom` object contains/aggregates `Patient` objects.
2. Multiplicity: Specifically, `WaitingRoom` holds an array capable of storing up to 10 `Patient` instances (`private Patient[] patients = new Patient[10];`).

Mentor tip

Identify the relationship as aggregation ('has-a') and state the 1-to-10 multiplicity.

(d)

3 marks

Construct the missing code inside `findNextPatientIndex()` to find the first patient with highest priority:
1. Loop through occupied slots in `patients` starting from index `1` (`while (i < 10 && patients[i] != null)`).
2. Compare `patients[i].getPriority() > patients[max].getPriority()` (using `>` rather than `>=` ensures the *first* patient with highest priority is kept).
3. Update `max = i` when a strictly higher priority is found:
```java int i = 1; while (i < 10 && patients[i] != null) { if (patients[i].getPriority() > patients[max].getPriority()) { max = i; } i = i + 1; } ```

Mentor tip

Check both `i < 10` and `patients[i] != null` in your loop condition, and use strict `>` so ties favour the patient who arrived earlier.

(e)

6 marks

Construct the `remove(int n)` method to output the patient at index `n` and shift remaining patients forward:
1. Use the method signature `private void remove(int n)`.
2. Output the removed patient's details using `System.out.println(patients[n].toString());`.
3. Loop index `i` from `n` up to `8` (`i < 9`).
4. Shift each subsequent element one slot left: `patients[i] = patients[i + 1];`.
5. Set the final array slot to `null` (`patients[9] = null;`) to clear the duplicate trailing reference:
```java private void remove(int n) { System.out.println(patients[n].toString()); for (int i = n; i < 9; i++) { patients[i] = patients[i + 1]; } patients[9] = null; } ```

Mentor tip

Stop the shift loop at `i < 9` (so `patients[i + 1]` does not go out of bounds at index 10) and set `patients[9] = null` afterward.

Question 11

12 marks

Patient encapsulation, medical data ethics, Doctor UML class design, and Unicode extended character sets

Object-oriented programming

(a)

2 marks

Outline one advantage of encapsulation in the `Patient` class:
1. By declaring `id`, `name`, `priority`, and `doctor` as `private` inside `Patient`,
2. external classes cannot directly access or accidentally overwrite sensitive patient attributes, enforcing controlled access via getter and setter methods.

Mentor tip

Define encapsulation (`private` attributes bundled with methods) and relate it to protecting `Patient` data from accidental corruption.

(b)

4 marks

Discuss one ethical consideration in designing the `Treatment` class:
1. Ethical Issue — Patient Medical Confidentiality & Privacy: Medical diagnoses and prescribed medications are highly sensitive personal data.
2. Consequence of Breach: Unauthorized disclosure could cause embarrassment, discrimination by employers/insurers, or legal violations.
3. Design Mitigation in `Treatment`: Notice that `Treatment` stores only `Integer patientId` rather than the patient's `String name`.
4. Benefit of Anonymization: Separating identity (`Patient`) from clinical records (`Treatment`) ensures that someone viewing treatment logs cannot immediately link a sensitive illness or medication to a named individual.

Mentor tip

Point out how the `Treatment` UML diagram stores `patientId` rather than `name`, separating personal identity from sensitive medical actions/medications.

(c)

3 marks

Design the `Doctor` UML class diagram:
1. Include the three private attributes with data types: `String name`, `String phone` (note: leading `0` in `0734511122` requires `String`), and `Boolean present`.
2. Include mutator (setter) methods: `setName(String name)`, `setPhone(String phone)`, `setPresent(Boolean present)`.
3. Include accessor (getter) methods: `String getName()`, `String getPhone()`, `Boolean getPresent()` (and optional `String toString()`).
``` +----------------------------------+ | Doctor | +----------------------------------+ | - name : String | | - phone : String | | - present : Boolean | +----------------------------------+ | + setName(String name) : void | | + setPhone(String phone) : void | | + setPresent(Boolean p) : void | | + getName() : String | | + getPhone() : String | | + getPresent() : Boolean | +----------------------------------+ ```

Mentor tip

Use `String` (not `int`) for `phone` because telephone numbers begin with a leading zero (`0734511122`).

(d)

3 marks

Outline the need for extended character sets in relation to the `Doctor` object:
1. Limitation of Standard ASCII: Basic 7-bit/8-bit ASCII only encodes 128/256 English characters and lacks diacritics and non-Latin alphabets.
2. Role of Extended Character Sets (Unicode): Modern character encodings like Unicode (UTF-8/UTF-16) use 16 or more bits to represent tens of thousands of international characters.
3. Application to `Doctor`: Without Unicode, the doctor's name `Dr Henriëtte Mănescu-Raţa` (containing accented characters `ë`, `ă`, and `ţ`) could not be stored or displayed accurately.

Mentor tip

Cite the exact diacritic characters in `Dr Henriëtte Mănescu-Raţa` (`ë`, `ă`, `ţ`) to illustrate why 7/8-bit ASCII is insufficient and Unicode is needed.

Question 12

6 marks

Traversing a Treatment collection with hasNext() and getNext()

Object-oriented programming

6 marks

Construct the `showMedicationByDoctor(String name)` method:
1. Define the method header `public void showMedicationByDoctor(String name)`.
2. Declare a `Treatment current;` reference variable.
3. Loop through the collection using `while (treatmentFile.hasNext())`.
4. Fetch the next record inside the loop: `current = treatmentFile.getNext();`.
5. Compare the treatment's doctor name with the parameter using `if (current.getDoctor().equals(name))`.
6. Output the prescribed medication when matched: `System.out.println(current.getMedication());`.
```java public void showMedicationByDoctor(String name) { Treatment current; while (treatmentFile.hasNext()) { current = treatmentFile.getNext(); if (current.getDoctor().equals(name)) { System.out.println(current.getMedication()); } } } ```

Mentor tip

Use `.equals(name)` for `String` comparison in Java, and call `treatmentFile.getNext()` once per iteration inside the `while (treatmentFile.hasNext())` loop.

Question 13

12 marks

Redesigning Treatment using inheritance diagrams and advantages of program modularity

Object-oriented programming

(a)

6 marks

Construct the inheritance hierarchy diagram for `Treatment` and its three subclasses:
1. Define the `Treatment` superclass containing the shared attributes: `private int patientId;`, `private String date;`, `private String doctor;` (or `Doctor doctor`), `private String actions;`.
2. Define three subclasses—`Ambulatory`, `InPatient`, and `Referral`—with hollow inheritance arrows pointing up to `Treatment`.
3. Include `private String medication;` in both `Ambulatory` and `InPatient` (or create an intermediate subclass), while omitting `medication` from `Referral`.
4. Include `private String roomNumber;` (and optional `releaseDate` / `nights`) in `InPatient`.
5. Include `private String hospital;` and `private boolean ambulance;` in `Referral`.
``` +------------------------+ | Treatment | +------------------------+ | - patientId : int | | - date : String | | - doctor : Doctor | +------------------------+ ^ ^ ^ | | | +-----------+ | +------------+ | | | +--------------------+ +--------------------+ +---------------------+ | Ambulatory | | InPatient | | Referral | +--------------------+ +--------------------+ +---------------------+ | - medication:String| | - medication:String| | - hospital : String | +--------------------+ | - roomNumber:String| | - ambulance:Boolean | +--------------------+ +---------------------+ ```

Mentor tip

Ensure inheritance arrows point from the three specialized subclasses (`Ambulatory`, `InPatient`, `Referral`) up to the `Treatment` superclass, and place `medication`, `roomNumber`, `hospital`, and `ambulance` in their exact respective classes.

(b)

6 marks

Describe three advantages of modularity in software development:
1. Faster Parallel Development (2 marks): Complex software can be partitioned into independent modules so separate programmers or teams can code and compile them concurrently.
2. Simpler Debugging and Testing (2 marks): Smaller, self-contained modules isolate logic errors, making unit testing and troubleshooting much easier than debugging a monolithic program.
3. Easier Maintenance and Reusability (2 marks): Updating business rules only requires modifying the relevant module without breaking unrelated code, and tested modules can be stored in libraries for reuse in future projects.

Mentor tip

State three distinct benefits (parallel team development, isolated debugging/testing, and easier maintenance/reuse) with a full explanation for each.

Our analysis

Where the marks are

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

Databases45 marks · 25%
Q1, Q2, Q3
Modelling and simulation45 marks · 25%
Q4, Q5, Q6
Web science45 marks · 25%
Q7, Q8, Q9
Object-oriented programming45 marks · 25%
Q10, Q11, Q12, Q13

Mentor insights

Traps to watch for

01
Databases: Small shop customer database benefits, costs, primary/secondary k · Q1
State any clear operational advantage such as improved financial control, sales analysis, or better customer service.
02
Modelling and simulation: Urban PM10 air pollution spreadsheet modelling, daily/annual repo · Q4
Explicitly account for all three time scales: 24 hourly readings (columns), 365 days (rows), and yearly/monthly sheets.
03
Web science: XML syntax validation, extensibility, CSS benefits, TCP/IP packet · Q7
Every opening tag in well-formed XML must have a matching closing tag before the next sibling record begins.
04
Object-oriented programming: Village health clinic OOP design: constructors, Patient/WaitingRo · Q10
Include both the definition (method with the class name that initializes a new instance) and the exact signature `public Patient(int i, String n, int p)`.

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 SL · Paper 2

Computer Science, Standard Level

Session: November 2015
Marks: 180
Duration: 1 hour
Calculator: Not allowed
Questions: 13

Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 Q9 Q10 Q11 Q12 Q13

Keep your copy of the paper open alongside. We don't reproduce the questions: each part below is labelled to match the November 2015 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–3 · 45 marks

Question 1

15 marks

Small shop customer database benefits, costs, primary/secondary keys, SQL queries, and query optimization

Databases

(a)(i)

1 mark

Identify one business benefit of implementing a customer database:
Enables structured sales trend analysis, improved financial tracking, or faster retrieval of customer order histories.

Mentor tip

State any clear operational advantage such as improved financial control, sales analysis, or better customer service.

(a)(ii)

1 mark

Identify one implementation cost:
Staff training expenses, DBMS software licensing/maintenance costs, or hardware acquisition/upgrade expenses.

Mentor tip

Mention software, hardware, or personnel training costs.

(b)(i)

1 mark

Count the columns (`Name`, `Date`, `ItemOrdered`, `QuantityOrdered`, `InvoiceAmount`) in `CustomerTable`:
There are `5` fields in each record.

Mentor tip

Fields correspond to columns in a relational table.

(b)(ii)

2 marks

Explain why `Name` is unsuitable as a primary key:
1. A primary key must uniquely identify every individual record in a table (no duplicate values).
2. Different customers can share the same name, or the same customer can place multiple orders—for instance, `Ann Low` appears twice in `CustomerTable` (on `18/04/2015` and `19/04/2015`).

Mentor tip

Cite the exact duplicate value from the table (`Ann Low`) to support why `Name` violates uniqueness.

(b)(iii)

1 mark

Define a secondary key:
An attribute (or set of attributes) that is not selected as the primary key, used as an index to speed up searching and sorting records (or a non-selected alternate key).

Mentor tip

Define a secondary key as a field indexed for faster searching/sorting or an alternate key not chosen as the primary key.

(c)

4 marks

Construct the query steps or SQL statement to retrieve the target items:
1. Select the output column `ItemOrdered` from `CustomerTable`.
2. Filter rows where `Date` equals `'19/04/2015'`.
3. Filter rows where `QuantityOrdered` is strictly greater than `5` (`QuantityOrdered > 5`).
4. Combine both conditions using the logical `AND` operator:
```sql SELECT ItemOrdered FROM CustomerTable WHERE Date = '19/04/2015' AND QuantityOrdered > 5; ```

Mentor tip

Make sure all four elements are explicit: `SELECT ItemOrdered`, `Date = '19/04/2015'`, `QuantityOrdered > 5`, and the `AND` logical operator.

(d)

5 marks

Explain software and structural optimizations to speed up query response time without changing hardware:
1. Normalize into a Relational Schema: Split the flat file into normalized relational tables (`Customers`, `Orders`, `Items`) to eliminate redundant data.
2. Faster Scanning: Smaller, non-redundant tables require fewer disk reads and less memory during query execution.
3. Create Indexes on Frequently Queried Fields: Add secondary key indexes on `Date` and `ItemOrdered` so the DBMS uses fast tree lookups rather than full-table linear scans.
4. Disk Defragmentation / Compaction: Defragment the storage drive and compact the database file so related table blocks are stored contiguously, minimizing disk head seek times.
5. Archive Historical Records: Move old completed orders out of the active operational table to keep the working dataset small.

Mentor tip

Link each software action (normalizing tables, adding indexes, defragmenting storage) to why it speeds up queries (reduced redundancy, fewer disk seeks, smaller search space).

Question 2

15 marks

Tourist bike hire DBMS functions and step-by-step normalization from 1NF to 3NF

Databases

(a)

3 marks

Identify three core functions provided by a Database Management System (DBMS):
1. Data Manipulation & Storage Interface: Provides an abstraction layer allowing users to insert, update, delete, and query bike hire records without knowing physical storage details.
2. Security & Access Control: Enforces user authentication and permissions to protect customer data from unauthorized access or theft.
3. Integrity, Concurrency & Recovery: Prevents data corruption via validation constraints and provides backup/recovery utilities in the event of a system crash.

Mentor tip

List three distinct DBMS capabilities: CRUD/query interface, access security, and backup/integrity management.

(b)

2 marks

Outline the purpose of database normalization:
1. To decompose a single unorganized table into separate, logically related entity tables.
2. To minimize data redundancy (saving storage space) and eliminate update, insertion, and deletion anomalies.

Mentor tip

Mention separating distinct entities into related tables and eliminating redundancy/anomalies.

(c)(i)

1 mark

State the characteristic of First Normal Form (1NF):
Every attribute contains only atomic (indivisible) values, there are no repeating groups or duplicate columns, and a primary key uniquely identifies each row.

Mentor tip

Focus on atomic values, no repeating columns/groups, and a primary key.

(c)(ii)

1 mark

State the characteristic of Second Normal Form (2NF):
The relation is in 1NF and every non-key attribute is fully functionally dependent on the entire primary key (no partial dependencies on part of a composite key).

Mentor tip

State: in 1NF + no partial dependencies on a subset of a composite primary key.

(c)(iii)

1 mark

State the characteristic of Third Normal Form (3NF):
The relation is in 2NF and contains no transitive dependencies (no non-key attribute depends on another non-key attribute; every non-key attribute depends solely on the primary key).

Mentor tip

State: in 2NF + no transitive dependencies between non-key attributes.

(d)

7 marks

Construct the database schema in 1NF, 2NF, and 3NF using shorthand notation:
1. First Normal Form (1NF) — Introduce a unique primary key `RentalNo` (or a composite primary key such as `(HirerID, BikeID, TimeOut)`) to uniquely identify each rental transaction:
`BIKEHIRE_1NF(RentalNo [PK], HirerID, HName, HPhone, TimeOut, TimeIn, BikeID, BikeMake, BikeModel)`
2. Second Normal Form (2NF) — When using the single-attribute surrogate primary key `RentalNo`, there is no composite key, so the 2NF relation is identical to 1NF (or if using composite key `(HirerID, BikeID, TimeOut)`, separate partial dependencies into `HIRER`, `BIKE`, and `RENTAL`):
`BIKEHIRE_2NF(RentalNo [PK], HirerID, HName, HPhone, TimeOut, TimeIn, BikeID, BikeMake, BikeModel)`
3. Third Normal Form (3NF) — Remove transitive dependencies (`HName` and `HPhone` depend on `HirerID`; `BikeMake` and `BikeModel` depend on `BikeID`) by splitting into three relations with primary keys (`[PK]`) and foreign keys (`*` / `[FK]`):
`HIRERTABLE(HirerID [PK], HName, HPhone)`
`BIKETABLE(BikeID [PK], BikeMake, BikeModel)`
`RENTALTABLE(RentalNo [PK], TimeOut, TimeIn, BikeID* [FK], HirerID* [FK])`

Mentor tip

Clearly underline or label primary keys (`[PK]`) and mark foreign keys (`*` or `[FK]`) in `RENTALTABLE`.

Question 3

15 marks

Logical vs physical database design, data dictionary contents, DBA duties, and online job database pros/cons

Databases

(a)

4 marks

Distinguish between logical and physical database design:
1. Conceptual/Structural Focus vs Storage Implementation: Logical design defines *what* data is stored—specifying entities, attributes, tables, and relationships (ERDs and normalized schemas) independent of hardware.
2. Physical Implementation: Physical design specifies *how* the database is actually implemented on storage media—defining exact DBMS data types, index structures, file partitions, and disk allocation.
3. Perspective & Performance: Logical design models the system from the business/user information perspective, whereas physical design optimizes low-level disk I/O speed and storage efficiency.
4. Chronological Order: Logical design is completed first during systems analysis, and physical design follows during implementation.

Mentor tip

Contrast 'what relationships/tables exist' (logical, user-oriented, done first) with 'how data is physically stored and indexed on disk' (physical, performance-oriented, done second).

(b)

3 marks

Identify three items of metadata stored in a data dictionary:
1. Field/attribute names and their data types/lengths (e.g., `VARCHAR(50)`, `INT`).
2. Validation rules, default values, and primary/foreign key constraints.
3. Table relationships, ownership/access permissions, and physical storage locations.

Mentor tip

List three distinct metadata properties: field definitions/types, constraints/keys, and access rights/table relationships.

(c)

4 marks

Explain two responsibilities of a Database Administrator (DBA):
1. Backup and Disaster Recovery (2 marks): The DBA schedules periodic automated backups and tests recovery protocols so the organization can restore data swiftly after hardware failures or corruption.
2. Security and Access Control (2 marks): The DBA configures user accounts, passwords, role-based views, and permissions to ensure only authorized personnel can read or modify sensitive records.

Mentor tip

Name two distinct DBA responsibilities and explain the purpose/actions involved in each for 2 marks apiece.

(d)

4 marks

Discuss one advantage and one disadvantage of the online job database:
1. Advantage (Centralized 24/7 Accessibility): Job seekers can search, filter, and apply to up-to-date vacancies from any location at any time, while employers immediately reach a large pool of applicants.
2. Disadvantage (Privacy & Security Vulnerability): Storing applicants' personal CVs, contact details, and employment histories online exposes them to data breaches or identity theft.
3. Elaboration / Implication: Furthermore, an applicant's current employer might search the database, discover their employee's profile, and learn they are seeking to leave the company.

Mentor tip

State one clear usability/access benefit for applicants, one clear privacy/security risk, and elaborate on the real-world impact.

Option B: Modelling and simulation · Option

Questions 4–6 · 45 marks

Question 4

17 marks

Urban PM10 air pollution spreadsheet modelling, daily/annual reporting, temporal patterns, and policy simulation

Modelling and simulation

(a)

3 marks

Outline a clear spreadsheet organization for hourly PM10 readings over a year:
1. Yearly / Monthly Worksheet Structure: Dedicate one workbook per year (or 12 monthly worksheets within an annual workbook).
2. Daily Rows: Assign each calendar day of the year (365 rows) to a separate row labelled with the date.
3. Hourly Columns: Assign the 24 hourly PM10 measurements (`00:00` to `23:00`) to 24 adjacent columns (`B` through `Y`), with summary columns at the end of each row for the day's average and limit check.

Mentor tip

Explicitly account for all three time scales: 24 hourly readings (columns), 365 days (rows), and yearly/monthly sheets.

(b)

5 marks

Describe how hourly readings are processed for daily press releases and the end-of-year report:
1. Initialize Counter: At the start of the year (1 January), initialize an exceedance counter `daysOver50 = 0`.
2. Daily Mean Calculation: At the end of each 24-hour cycle, calculate the daily average PM10 by summing the 24 hourly cells and dividing by 24 (`=AVERAGE(B2:Y2)`).
3. Daily Threshold Check & Press Output: If the daily average exceeds `50`, increment `daysOver50` by 1 (or use `=COUNTIF(Z2:Z366, ">50")`), and output both yesterday's average and the cumulative `daysOver50` count to the local press.
4. Annual Mean Calculation: At the end of 31 December, compute the overall annual mean by averaging all 365 daily averages (`=AVERAGE(Z2:Z366)`).
5. End-of-Year Report Generation: Generate a line/bar chart from the 365 daily average cells and compile the chart, final `daysOver50` count, and annual mean into the regulatory compliance report.

Mentor tip

Cover all 5 steps: daily average calculation, checking `> 50` to increment the counter, sending daily stats to the press, calculating the yearly mean, and plotting the annual chart.

(c)(i)

2 marks

Identify two temporal pollution patterns discoverable from the model:
1. Diurnal (time-of-day) cycles, such as morning and evening rush-hour traffic spikes versus overnight lows.
2. Seasonal cycles (e.g., higher PM10 in winter due to domestic heating and temperature inversions compared to summer) or weekday-versus-weekend differences.

Mentor tip

Name two distinct time-based patterns: time-of-day (rush hour), day-of-week (weekday vs weekend), or seasonal (winter vs summer).

(c)(ii)

2 marks

Explain how one identified pattern helps urban planning:
1. If the model reveals severe morning/evening rush-hour peaks (or winter heating spikes),
2. the town council can stagger school and factory start times, expand public transit during peak hours, or regulate industrial/heating emissions during high-risk periods.

Mentor tip

Directly connect the pattern chosen in (c)(i) to a concrete municipal policy intervention.

(d)

5 marks

Explain how the simulation model estimates the minimum required 'no car' weekends:
1. Quantify Single-Event Impact: Measure the exact drop in PM10 recorded during the initial 'no car' weekend compared to normal weekends.
2. Baseline Projection: Use historical seasonal trends and the current year-to-date average (`45 µg m^-3`) to project expected daily PM10 values for the remaining days of the year without intervention.
3. Iterative What-If Simulation: Run the simulation by progressively substituting 1, 2, 3, ..., $k$ 'no car' weekends into the remaining calendar and recalculating the resulting annual mean.
4. Identify Minimum Threshold: Find the smallest integer $k$ for which the projected full-year average drops to `<= 40 µg m^-3` (minimizing commercial disruption).
5. Continuous Recalibration: Re-run and update the model after each 'no car' weekend using actual weather and pollution readings, since meteorological conditions vary.

Mentor tip

Show how the measured reduction from one 'no car' weekend is iteratively applied to projected remaining days until the annual mean reaches `<= 40`, and mention recalibrating as real data arrives.

Question 5

16 marks

4x4 board game simulation, move analysis, memory representation, game tree search, and board scaling

Modelling and simulation

(a)

1 mark

Identify all legal moves for Player A from square 1 (with Player B on square 6):
Player A can move right to `2`, down to `5`, or jump diagonally over Player B (on `6`) to land on `11`. Legal squares: `2, 5, or 11`.

Mentor tip

Don't forget the diagonal jump rule: since diagonal square 6 is occupied by B, A jumps over 6 into 11.

(b)

3 marks

Analyse each possible move for Player A (at square 2) and justify Player B's optimal response (from square 10):
1. Case 1 — Player A moves right to `3`: Player B (at `10`) can move right to `11`, down to `14`, or diagonally to `15`. Moving to `11` or `15` places B one step away from `HOME` (`16`) for an immediate win on B's next turn.
2. Case 2 — Player A moves down to `6`: Player B (at `10`) can move diagonally to `15` (or right to `11`), which guarantees reaching `HOME` (`16`) on B's next turn before A can reach `HOME`.
3. Case 3 — Player A moves diagonally to `7`: Player B (at `10`) should move to `11` or `15`, positioning B directly adjacent to `HOME` to win on the following turn.

Mentor tip

List all three of Player A's legal moves from square 2 (`3`, `6`, and `7`) and state B's winning counter-move (`11` or `15`) for each.

(c)(i)

2 marks

Outline a memory representation for the board and player positions:
1. Use a 2D array `board[4][4]` (with row index `r` and column index `c` from `1..4` or `0..3`), or store two coordinate pairs `(rowA, colA)` and `(rowB, colB)`.
2. Store an integer/character code in the array cells (`0` = empty, `1` = Player A, `2` = Player B) or maintain separate variables distinguishing Player A's coordinates from Player B's coordinates.

Mentor tip

Clearly specify the data structure (e.g., a 4x4 2D array or `(row, col)` coordinate variables) and how Player A and Player B are distinguished.

(c)(ii)

1 mark

State the positions of Player A (square 2) and Player B (square 10) using 1-based `(row, col)` coordinates:
Player A is at `(1, 2)` and Player B is at `(3, 2)` (or `(0, 1)` and `(2, 1)` in 0-based indexing).

Mentor tip

Ensure your coordinates match the exact indexing convention defined in part (c)(i).

(c)(iii)

2 marks

Outline how the program identifies all legal moves from `(r, c)`:
1. Compute the three target adjacent coordinates: right `(r, c + 1)`, down `(r + 1, c)`, and diagonal `(r + 1, c + 1)`, checking that each stays within the board boundaries (`<= 4`).
2. If a target square contains the opponent's position, check whether the jump landing square (`(r, c + 2)`, `(r + 2, c)`, or `(r + 2, c + 2)`) is within the `1..4` board limits.

Mentor tip

Include both boundary checking (staying on the 4x4 grid) and the occupancy check that triggers a jump coordinate calculation.

(c)(iv)

3 marks

Suggest an algorithm to select the optimal move from the legal options:
1. Lookahead Tree Generation: For each legal move of the current player, generate all legal counter-moves available to the opponent.
2. Recursive Path Evaluation: Continue expanding subsequent turns recursively until `HOME` `(4, 4)` is reached along each branch.
3. Shortest/Minimax Selection: Select the move that leads to the shortest guaranteed path to `HOME` (or blocks the opponent from reaching `HOME` first).

Mentor tip

Describe a game-tree lookahead: simulate current moves -> simulate opponent responses -> trace to `HOME` -> pick the shortest winning path.

(d)

4 marks

Outline the computational impact of increasing the board to a much larger grid (e.g., $N \times N$ ):
1. Combinatorial Explosion of Paths: Every additional row and column exponentially increases the branching factor and depth of the game tree (number of possible move sequences to `HOME`).
2. Increased CPU Processing & Memory Usage: Evaluating all lookahead paths requires vastly more CPU cycles and call-stack memory.
3. Degraded Gameplay Responsiveness: Turn calculation time increases significantly, introducing noticeable lag and slowing down the game unless search depth is pruned.

Mentor tip

Explain both why the math scales rapidly (combinatorial explosion of paths as rows/columns grow) and the practical effect on the program (more CPU/memory processing, slower response time).

Question 6

12 marks

Autonomous self-driving car HD maps, 3D motion analysis, real-time memory/compute requirements, and social implications

Modelling and simulation

(a)

2 marks

Outline why high-definition (HD) maps must be held in memory alongside camera/laser sensors:
1. Onboard cameras and LiDAR lasers only detect immediate line-of-sight surroundings, whereas HD maps provide static road geometry, lane rules, speed limits, and route topology beyond sensor range.
2. Combining live sensor inputs with pre-loaded HD maps allows the car to localize its exact position and plan a safe trajectory toward its destination.

Mentor tip

Contrast immediate local perception (cameras/lasers) with global route/road-rule knowledge (HD maps) and explain how combining them guides navigation.

(b)

3 marks

Outline how analysing successive 3D images in memory supports safe driving:
1. Instantaneous Spatial Snapshot: Each 3D frame captures the exact positions and distances of surrounding obstacles, pedestrians, and vehicles at a specific instant.
2. Velocity & Trajectory Estimation: By comparing changes in object coordinates across consecutive 3D frames over time ( $Δ t$ ), the system calculates the speed and direction of moving hazards.
3. Collision Avoidance: The car projects future paths of moving objects and adjusts its steering or braking proactively to maintain safe following distances and avoid collisions.

Mentor tip

Highlight the progression: single 3D snapshot (position) -> comparison across consecutive frames (speed & direction of movement) -> path prediction & obstacle avoidance.

(c)

3 marks

Outline the time and memory demands of 3D visualization in an autonomous vehicle:
1. Strict Real-Time Processing: Because the car is moving at highway speeds, 3D sensor fusion and rendering must execute in real time (milliseconds) with zero lag to react to sudden hazards.
2. High RAM Capacity: Massive high-speed memory is required to buffer and manipulate continuous streams of high-resolution 3D point clouds, multi-angle colour video frames, and detailed HD map tiles simultaneously.
3. Parallel Compute Throughput: Dedicated high-bandwidth processors/GPUs are needed to continuously update the 3D environmental model.

Mentor tip

Address both Time (strict real-time processing because the vehicle is moving) and Memory (large RAM needed to hold high-res 3D point clouds, colour images, and HD maps).

(d)

4 marks

Discuss the social, legal, and safety implications of self-driving cars:
1. Reduced Human Error & Efficiency: Autonomous cars do not suffer from fatigue, distraction, or intoxication, potentially reducing traffic accidents, optimizing fuel consumption, and granting mobility to elderly or disabled passengers.
2. Unpredictable Edge Cases & Malfunctions: Software may fail to interpret novel, unprogrammed road scenarios or sensor failures in severe weather, requiring robust fail-safe mechanisms.
3. Legal & Ethical Liability: If an autonomous vehicle causes a fatal collision, determining legal liability (between the vehicle owner, software developer, or car manufacturer) raises complex legal and ethical dilemmas.
4. Employment Impact: Widespread adoption threatens the livelihoods of professional taxi, bus, and haulage drivers.

Mentor tip

Balance safety/efficiency advantages against edge-case risks, legal liability questions, and employment impacts.

Option C: Web science · Option

Questions 7–9 · 45 marks

Question 7

18 marks

XML syntax validation, extensibility, CSS benefits, TCP/IP packet transmission, client-side validation, and AJAX partial updates

Web science

(a)

1 mark

Identify the syntax error in the XML snippet:
The first `<dvd>` element is missing its closing `</dvd>` tag (after `<genre>Fantasy</genre>`).

Mentor tip

Every opening tag in well-formed XML must have a matching closing tag before the next sibling record begins.

(b)

2 marks

Outline the meaning of 'extensibility' in XML:
1. Unlike HTML, XML does not restrict developers to a fixed, predefined set of markup tags.
2. Users can invent and define their own custom, domain-specific tag names (such as `<collection>`, `<dvd>`, `<genre>`) to structure any type of data.

Mentor tip

Emphasize that developers can extend the tag set by defining their own custom tags.

(c)

2 marks

Describe one benefit of storing styling rules in an external CSS file:
1. A single external CSS stylesheet can be linked across hundreds of HTML pages, ensuring visual consistency across the website.
2. Updating a style rule once in the CSS file automatically updates the appearance of every linked HTML page, saving development and maintenance time.

Mentor tip

Explain that one CSS file styles multiple HTML documents, so a single edit updates the entire site.

(d)

4 marks

Describe how TCP and IP collaborate to transmit the XML document over the internet:
1. TCP Segmentation: The Transmission Control Protocol (TCP) breaks the XML document from the application layer into small, numbered data packets (segments) and adds sequence numbers and checksums.
2. IP Addressing & Routing: The Internet Protocol (IP) encapsulates each TCP segment by adding an IP header containing the source and destination IP addresses, and routes the packets across intermediate network routers.
3. TCP Acknowledgement & Reassembly: At the destination web server, TCP verifies packet integrity, requests retransmission of any lost packets, and reassembles them in the correct sequence order.

Mentor tip

Clearly separate TCP's job (breaking data into numbered packets + reliable reassembly) from IP's job (adding source/destination IP headers + routing across the network).

(e)(i)

3 marks

Explain how client-side scripting validates the login form before submission:
1. Software / Language: A script written in `JavaScript` runs locally inside the user's web browser.
2. Pre-submission Trigger: When the user clicks submit, the JavaScript function inspects the form inputs before any HTTP request is sent.
3. Validation Checks: It verifies that `Name` and `Country` are not blank and checks that the `Email` field conforms to a valid format (e.g., contains an `@` symbol and domain extension), alerting the user immediately if invalid.

Mentor tip

Explicitly name `JavaScript`, state that it validates form fields locally in the browser, and give a concrete check (such as verifying the `@` symbol in the email field).

(e)(ii)

2 marks

Outline the benefit of client-side validation for the shopping site:
1. Filters out invalid or incomplete form submissions on the client device, reducing unnecessary network traffic and processing load on the shopping site's web server.
2. Frees up server resources so the server can handle more concurrent customer requests (and gives instant feedback to the user).

Mentor tip

Focus on reduced server-side processing load and reduced network bandwidth usage.

(f)

4 marks

Explain how scripts update a user's profile photograph without reloading the entire page:
1. Asynchronous Client Request: A client-side script (such as JavaScript / AJAX `XMLHttpRequest` or `fetch`) captures the user's photo selection and sends an asynchronous background request to the web server.
2. Server-Side Database Query: A server-side script (e.g., PHP/Node.js) executes an SQL query against the backend database to retrieve or update the selected photograph's file path.
3. Targeted Response: The server returns only the new image data or URL rather than a complete HTML document.
4. DOM Manipulation: The client-side JavaScript dynamically updates the `src` attribute of the specific `<img>` element in the Document Object Model (DOM), refreshing just the profile photo region.

Mentor tip

Trace the full cycle: client-side script sends async request -> server queries database via SQL -> server returns new photo -> client script updates only that specific DOM element.

Question 8

17 marks

Lossy compression user experience, search engine crawling/indexing/searching, PageRank bias against new sites, and index freshness

Web science

(a)

5 marks

Discuss how lossy compression affects the end-user experience:
1. Mechanism: Lossy compression permanently discards redundant or perceptually less noticeable data from a file to achieve a much smaller file size.
2. Positive Impact (Speed & Bandwidth): Smaller file sizes dramatically reduce download/streaming times, prevent buffering on slow connections, and consume less mobile data.
3. Tolerable Perceptual Trade-off: For multimedia (such as a JPEG web photo or MP3 audio stream), minor high-frequency detail removal is often imperceptible to human eyes or ears.
4. Negative Impact (Quality Degradation): If the compression ratio is too aggressive—or if the user requires high-resolution fidelity (e.g., medical imaging or archival photography)—visible compression artifacts (pixelation, blurring, audio distortion) degrade the experience.
5. Appraisal: For general web browsing, faster page loading outweighs minor quality loss, provided compression levels are sensibly balanced.

Mentor tip

(b)

6 marks

Outline the functions of the three core search engine processes:
1. Crawling (2 marks): Automated bots (spiders/crawlers) systematically traverse the web by following hyperlinks from page to page and fetching copies of the HTML documents they discover.
2. Indexing (2 marks): The parser analyses each fetched page to extract significant keywords, headings, meta-tags, and inbound/outbound links, storing mappings from keywords to URLs in a massive inverted index database.
3. Searching (2 marks): When a user submits a query, the search processor parses the search terms, looks up matching URLs in the index, ranks them by relevance/authority (e.g., PageRank), and returns the ordered results list.

Mentor tip

(c)

3 marks

Explain why PageRank can disadvantage newly launched websites:
1. Backlink Dependency: PageRank calculates a page's authority score primarily from the quantity and PageRank quality of external inbound links (backlinks) pointing to it.
2. Cold-Start Problem: A newly created website initially has very few or zero external websites linking to it.
3. Low Visibility Cycle: Consequently, the new site receives a very low PageRank score and appears buried far down in search results, making it harder for users to discover and link to it.

Mentor tip

Connect PageRank's reliance on backlinks -> new sites having few/no backlinks -> resulting low rank and poor search visibility.

(d)

3 marks

Explain how a search engine keeps its index up to date as the web grows:
1. Continuous Scheduled Crawling: Distributed web crawlers run continuously in the background, revisiting frequently updated hubs (like news sites) at short intervals.
2. Link Discovery: Whenever an existing indexed page adds a hyperlink to a newly created page, the crawler follows that link and adds the new page to the index.
3. Direct Webmaster Submission / Sitemaps: Website administrators can proactively notify the search engine of new or updated URLs by submitting XML sitemaps or URL indexing requests.

Mentor tip

Mention both continuous automated re-crawling of links and direct sitemap/URL notifications from webmasters.

Question 9

10 marks

Public cloud architectural features and hybrid cloud strategy for seasonal online retail

Web science

(a)

4 marks

Describe two essential architectural features of a sustainable public cloud model:
1. Resource Virtualization & Multi-Tenancy (2 marks): Physical servers and storage arrays are abstracted into virtual machines and pooled so hardware capacity can be dynamically shared and reassigned across multiple customers.
2. Rapid Elasticity / On-Demand Scalability & Distributed Grid Architecture (2 marks): A distributed network of data centres paired with an automated self-service portal allows clients to provision or release compute and bandwidth capacity on demand as traffic fluctuates.

Mentor tip

Name two distinct architectural pillars (e.g., virtualization, distributed grid systems, on-demand scalability, or self-service provisioning) and explain how each works.

(b)

6 marks

Explain how the online retailer can apply a hybrid cloud strategy across all four operational factors:
1. Private Cloud for Sensitive Financial Data: Host customer credit card records, accounting ledgers, and core day-to-day ERP operations on a dedicated, tightly secured private cloud behind corporate firewalls.
2. Public Cloud Bursting for Christmas Peak Demand: During the Christmas shopping surge, dynamically rent elastic public cloud web servers and bandwidth to absorb traffic spikes without buying permanent hardware that would sit idle the rest of the year.
3. Public Cloud for Promotional Email Campaigns: Offload bulk promotional mailing operations to specialized public cloud email/SaaS services designed for high-volume delivery.
4. Public Cloud Sandboxes for Upcoming Development Projects: Provision temporary public cloud virtual environments and storage for software developers to build and test new projects, tearing them down once deployed.

Mentor tip

Explicitly map all four bullet points from the prompt (financial data -> private cloud; Christmas surge, promotional emails, and temporary dev projects -> public cloud) with clear justifications.

Option D: Object-oriented programming · Option

Questions 10–13 · 45 marks

Question 10

15 marks

Village health clinic OOP design: constructors, Patient/WaitingRoom aggregation, priority search, and array shifting

Object-oriented programming

(a)

2 marks

Define a constructor with an example from the clinic code:
1. A constructor is a special method sharing the exact same name as its class (and no return type) that is invoked to instantiate and initialize a new object of that class.
2. Example from code: `public Patient(int i, String n, int p)` (or the default constructor `new WaitingRoom()`).

Mentor tip

Include both the definition (method with the class name that initializes a new instance) and the exact signature `public Patient(int i, String n, int p)`.

(b)

2 marks

Describe one additional field appropriate for the `Patient` class:
1. Field & Data Type: `private String phoneNumber;` (or `private String dateOfBirth;` / `private String address;`).
2. Sample Data & Purpose: `"0734599881"` — used by the clinic to contact the patient regarding appointments or test results.

Mentor tip

Ensure you include all three requested elements: field purpose/name, Java data type (`String`, `int`, `boolean`), and realistic sample data.

(c)

2 marks

Describe the object relationship between `WaitingRoom` and `Patient`:
1. Aggregation ('has-a' relationship): A `WaitingRoom` object contains/aggregates `Patient` objects.
2. Multiplicity: Specifically, `WaitingRoom` holds an array capable of storing up to 10 `Patient` instances (`private Patient[] patients = new Patient[10];`).

Mentor tip

Identify the relationship as aggregation ('has-a') and state the 1-to-10 multiplicity.

(d)

3 marks

Construct the missing code inside `findNextPatientIndex()` to find the first patient with highest priority:
1. Loop through occupied slots in `patients` starting from index `1` (`while (i < 10 && patients[i] != null)`).
2. Compare `patients[i].getPriority() > patients[max].getPriority()` (using `>` rather than `>=` ensures the *first* patient with highest priority is kept).
3. Update `max = i` when a strictly higher priority is found:
```java int i = 1; while (i < 10 && patients[i] != null) { if (patients[i].getPriority() > patients[max].getPriority()) { max = i; } i = i + 1; } ```

Mentor tip

Check both `i < 10` and `patients[i] != null` in your loop condition, and use strict `>` so ties favour the patient who arrived earlier.

(e)

6 marks

Construct the `remove(int n)` method to output the patient at index `n` and shift remaining patients forward:
1. Use the method signature `private void remove(int n)`.
2. Output the removed patient's details using `System.out.println(patients[n].toString());`.
3. Loop index `i` from `n` up to `8` (`i < 9`).
4. Shift each subsequent element one slot left: `patients[i] = patients[i + 1];`.
5. Set the final array slot to `null` (`patients[9] = null;`) to clear the duplicate trailing reference:
```java private void remove(int n) { System.out.println(patients[n].toString()); for (int i = n; i < 9; i++) { patients[i] = patients[i + 1]; } patients[9] = null; } ```

Mentor tip

Stop the shift loop at `i < 9` (so `patients[i + 1]` does not go out of bounds at index 10) and set `patients[9] = null` afterward.

Question 11

12 marks

Patient encapsulation, medical data ethics, Doctor UML class design, and Unicode extended character sets

Object-oriented programming

(a)

2 marks

Outline one advantage of encapsulation in the `Patient` class:
1. By declaring `id`, `name`, `priority`, and `doctor` as `private` inside `Patient`,
2. external classes cannot directly access or accidentally overwrite sensitive patient attributes, enforcing controlled access via getter and setter methods.

Mentor tip

Define encapsulation (`private` attributes bundled with methods) and relate it to protecting `Patient` data from accidental corruption.

(b)

4 marks

Discuss one ethical consideration in designing the `Treatment` class:
1. Ethical Issue — Patient Medical Confidentiality & Privacy: Medical diagnoses and prescribed medications are highly sensitive personal data.
2. Consequence of Breach: Unauthorized disclosure could cause embarrassment, discrimination by employers/insurers, or legal violations.
3. Design Mitigation in `Treatment`: Notice that `Treatment` stores only `Integer patientId` rather than the patient's `String name`.
4. Benefit of Anonymization: Separating identity (`Patient`) from clinical records (`Treatment`) ensures that someone viewing treatment logs cannot immediately link a sensitive illness or medication to a named individual.

Mentor tip

Point out how the `Treatment` UML diagram stores `patientId` rather than `name`, separating personal identity from sensitive medical actions/medications.

(c)

3 marks

Design the `Doctor` UML class diagram:
1. Include the three private attributes with data types: `String name`, `String phone` (note: leading `0` in `0734511122` requires `String`), and `Boolean present`.
2. Include mutator (setter) methods: `setName(String name)`, `setPhone(String phone)`, `setPresent(Boolean present)`.
3. Include accessor (getter) methods: `String getName()`, `String getPhone()`, `Boolean getPresent()` (and optional `String toString()`).
``` +----------------------------------+ | Doctor | +----------------------------------+ | - name : String | | - phone : String | | - present : Boolean | +----------------------------------+ | + setName(String name) : void | | + setPhone(String phone) : void | | + setPresent(Boolean p) : void | | + getName() : String | | + getPhone() : String | | + getPresent() : Boolean | +----------------------------------+ ```

Mentor tip

Use `String` (not `int`) for `phone` because telephone numbers begin with a leading zero (`0734511122`).

(d)

3 marks

Outline the need for extended character sets in relation to the `Doctor` object:
1. Limitation of Standard ASCII: Basic 7-bit/8-bit ASCII only encodes 128/256 English characters and lacks diacritics and non-Latin alphabets.
2. Role of Extended Character Sets (Unicode): Modern character encodings like Unicode (UTF-8/UTF-16) use 16 or more bits to represent tens of thousands of international characters.
3. Application to `Doctor`: Without Unicode, the doctor's name `Dr Henriëtte Mănescu-Raţa` (containing accented characters `ë`, `ă`, and `ţ`) could not be stored or displayed accurately.

Mentor tip

Cite the exact diacritic characters in `Dr Henriëtte Mănescu-Raţa` (`ë`, `ă`, `ţ`) to illustrate why 7/8-bit ASCII is insufficient and Unicode is needed.

Question 12

6 marks

Traversing a Treatment collection with hasNext() and getNext()

Object-oriented programming

6 marks

Construct the `showMedicationByDoctor(String name)` method:
1. Define the method header `public void showMedicationByDoctor(String name)`.
2. Declare a `Treatment current;` reference variable.
3. Loop through the collection using `while (treatmentFile.hasNext())`.
4. Fetch the next record inside the loop: `current = treatmentFile.getNext();`.
5. Compare the treatment's doctor name with the parameter using `if (current.getDoctor().equals(name))`.
6. Output the prescribed medication when matched: `System.out.println(current.getMedication());`.
```java public void showMedicationByDoctor(String name) { Treatment current; while (treatmentFile.hasNext()) { current = treatmentFile.getNext(); if (current.getDoctor().equals(name)) { System.out.println(current.getMedication()); } } } ```

Mentor tip

Use `.equals(name)` for `String` comparison in Java, and call `treatmentFile.getNext()` once per iteration inside the `while (treatmentFile.hasNext())` loop.

Question 13

12 marks

Redesigning Treatment using inheritance diagrams and advantages of program modularity

Object-oriented programming

(a)

6 marks

Construct the inheritance hierarchy diagram for `Treatment` and its three subclasses:
1. Define the `Treatment` superclass containing the shared attributes: `private int patientId;`, `private String date;`, `private String doctor;` (or `Doctor doctor`), `private String actions;`.
2. Define three subclasses—`Ambulatory`, `InPatient`, and `Referral`—with hollow inheritance arrows pointing up to `Treatment`.
3. Include `private String medication;` in both `Ambulatory` and `InPatient` (or create an intermediate subclass), while omitting `medication` from `Referral`.
4. Include `private String roomNumber;` (and optional `releaseDate` / `nights`) in `InPatient`.
5. Include `private String hospital;` and `private boolean ambulance;` in `Referral`.
``` +------------------------+ | Treatment | +------------------------+ | - patientId : int | | - date : String | | - doctor : Doctor | +------------------------+ ^ ^ ^ | | | +-----------+ | +------------+ | | | +--------------------+ +--------------------+ +---------------------+ | Ambulatory | | InPatient | | Referral | +--------------------+ +--------------------+ +---------------------+ | - medication:String| | - medication:String| | - hospital : String | +--------------------+ | - roomNumber:String| | - ambulance:Boolean | +--------------------+ +---------------------+ ```

Mentor tip

(b)

6 marks

Describe three advantages of modularity in software development:
1. Faster Parallel Development (2 marks): Complex software can be partitioned into independent modules so separate programmers or teams can code and compile them concurrently.
2. Simpler Debugging and Testing (2 marks): Smaller, self-contained modules isolate logic errors, making unit testing and troubleshooting much easier than debugging a monolithic program.
3. Easier Maintenance and Reusability (2 marks): Updating business rules only requires modifying the relevant module without breaking unrelated code, and tested modules can be stored in libraries for reuse in future projects.

Mentor tip

State three distinct benefits (parallel team development, isolated debugging/testing, and easier maintenance/reuse) with a full explanation for each.

Our analysis

Where the marks are

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

Databases45 marks · 25%
Q1, Q2, Q3
Modelling and simulation45 marks · 25%
Q4, Q5, Q6
Web science45 marks · 25%
Q7, Q8, Q9
Object-oriented programming45 marks · 25%
Q10, Q11, Q12, Q13

Mentor insights

Traps to watch for

01
Databases: Small shop customer database benefits, costs, primary/secondary k · Q1
State any clear operational advantage such as improved financial control, sales analysis, or better customer service.
02
Modelling and simulation: Urban PM10 air pollution spreadsheet modelling, daily/annual repo · Q4
Explicitly account for all three time scales: 24 hourly readings (columns), 365 days (rows), and yearly/monthly sheets.
03
Web science: XML syntax validation, extensibility, CSS benefits, TCP/IP packet · Q7
Every opening tag in well-formed XML must have a matching closing tag before the next sibling record begins.
04
Object-oriented programming: Village health clinic OOP design: constructors, Patient/WaitingRo · Q10
Include both the definition (method with the class name that initializes a new instance) and the exact signature `public Patient(int i, String n, int p)`.

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