Development process, testing and debugging, OOP and developer obligations: WACE Computer Science Unit 3

(a) Syntax error: breaks the language rules, so the program will not run or compile.

(b) Logic error: the program runs but gives the wrong result.

(c) Runtime error: occurs while the program is running, when an operation cannot be completed.

Marking guide: 1 mark each.

Marking guide: 1 mark for normal data, 2 marks for boundary values on both sides, 1 mark for invalid data with expected results.

Item (parent): private attributes itemID, title, isOnLoan; methods borrow(), returnItem(), getLoanPeriod().

Book (inherits Item): extra attribute author; overrides getLoanPeriod() to return 21 days.

DVD (inherits Item): extra attribute runtime; overrides getLoanPeriod() to return 7 days.

Inheritance

Book and DVD reuse itemID, title, borrow() and returnItem() from Item, avoiding duplicated code.

Encapsulation

isOnLoan is private and changed only through borrow() and returnItem(), preventing invalid states such as an item being loaned twice.

Polymorphism

calling getLoanPeriod() on any Item returns the right period for its actual type, so the loan system can treat all items the same way.

Marking guide: 2 marks for a correct structure, 1 mark each for inheritance, encapsulation and polymorphism explained (3 marks), 1 mark for a clear, justified design.

Encapsulation bundles the data and the methods that act on it inside the class, and restricts direct access to the data. In BankAccount, balance is private, so other code cannot write account.balance = 1000000. It can only change balance through deposit() and withdraw(), which can check the input (for example, reject a negative deposit or a withdrawal larger than the balance). This protects the object from invalid states.

Abstraction means exposing only what users of the class need and hiding how it works. A programmer using BankAccount only needs to know that withdraw(amount) takes money out; they do not need to know how the balance is stored or how the checks are coded, so the inner code can change without affecting them.

In short, encapsulation is about protecting the data, while abstraction is about presenting a simple interface.

Marking guide: 1 mark for defining encapsulation, 1 mark for applying it to balance and the methods, 1 mark for defining abstraction, 1 mark for applying it to the BankAccount example (4 marks).

Legal obligation 1: copyright and licences

The open-source library is still protected by copyright. The developer must comply with its licence conditions, such as keeping the copyright and licence notices, and meeting any conditions on sharing the app's own source code if the licence requires it. Using it outside those conditions would breach copyright.

Legal obligation 2: privacy law

Names, email addresses and schools are personal information. The developer must handle them as privacy law requires, for example collecting only what the app needs, telling users what is collected and why, storing it securely and not using it for unrelated purposes.

Ethical obligation: protecting user data and secure coding

Even beyond the legal minimum, the users are students who trust the app with their details. The developer should write secure code (such as validating input and protecting stored data) and be honest with users about the app's limitations and what happens to their data.

Marking guide: 2 marks for each legal obligation explained and applied to the app (1 mark for identifying it, 1 mark for applying it), 1 mark for an ethical obligation explained (5 marks).

(a) Any four of:

• Analyse: meet the clinic manager and staff to gather requirements, such as booking, cancelling and the 15 to 60 minute rule.
• Design: plan the screens, the data to store (patients, appointments) and the algorithms, such as checking that a time slot is free.
• Develop: write the code using good practice, such as meaningful names, comments and modular functions, with version control.
• Test: test each function and the whole system with normal, boundary and invalid data.
• Implement: install the app for the clinic and train the staff.
• Evaluate and maintain: check the app meets the requirements and fix bugs or add features after release.

(b) Agile. The manager does not yet know all the features she needs and wants to try early versions. Agile builds the app in short iterations, releasing working versions for her feedback so requirements can change between iterations. Waterfall follows the stages in sequence and needs the requirements fixed at the start, so late changes would be costly.

(c)

(d)

• (i) Runtime error: the code is valid, but an operation (opening the file) cannot be completed while the program runs, so it crashes.
• (ii) Syntax error: WHLIE breaks the rules of the language, so the program will not run or compile.
• (iii) Logic error: the program runs but gives the wrong result, so the end time calculation is wrong.

(e) Legal: comply with privacy law when handling patients' personal information, for example collecting only what is needed and storing it securely. Ethical: protect user data through secure coding, or be honest with the clinic about the app's limitations.

Marking guide: (a) 1 mark for each of four stages correctly applied to the app (4 marks). (b) 1 mark for recommending agile, 2 marks for justification linked to changing requirements and early versions (3 marks). (c) 1 mark for normal data, 1 mark for boundary values inside the range, 1 mark for boundary values just outside, 1 mark for invalid data, all with expected results (4 marks). (d) 1 mark for each correct classification with a reason (3 marks). (e) 1 mark for a legal obligation, 1 mark for an ethical obligation (2 marks). Total 16 marks.

(a)

• Equipment (parent): private attributes item_id, name, daily_rate; methods get_name(), get_daily_rate(), set_daily_rate(rate), hire_cost(days).
• Racquet (inherits Equipment): extra private attribute grip_size; overrides hire_cost(days) to add the 2 dollar cleaning fee.
• Ball (inherits Equipment): no extra attributes; uses the inherited hire_cost(days).

(b)

class Equipment:
    def __init__(self, item_id, name, daily_rate):
        self.__item_id = item_id
        self.__name = name
        self.__daily_rate = 0
        self.set_daily_rate(daily_rate)

    def get_name(self):
        return self.__name

    def get_daily_rate(self):
        return self.__daily_rate

    def set_daily_rate(self, rate):
        if rate <= 0 or rate > 50:
            raise ValueError("Daily rate must be more than 0 and at most 50")
        self.__daily_rate = rate

    def hire_cost(self, days):
        return self.__daily_rate * days


class Racquet(Equipment):
    def __init__(self, item_id, name, daily_rate, grip_size):
        super().__init__(item_id, name, daily_rate)
        self.__grip_size = grip_size

    def hire_cost(self, days):
        # add the flat 2 dollar cleaning fee to the normal cost
        return super().hire_cost(days) + 2


class Ball(Equipment):
    pass

The double underscore makes the attributes private, so other code must use the getter and setter, and the setter rejects invalid rates.

(c) Polymorphism means the same method call behaves appropriately for each object's actual type. The loop calls item.hire_cost(3) on every item without checking its type. For the Racquet, Python runs the overriding Racquet version: 4 x 3 + 2 = 14 dollars. For the Ball, it runs the inherited Equipment version: 1.50 x 3 = 4.50 dollars.

(d) Shared code, such as set_daily_rate and its validation, is written once in Equipment. If the rule changes (for example, a new maximum rate), it is changed in one place and every subclass gets the change, avoiding duplicated code and inconsistent fixes. Inheritance suits an "is a" relationship, and a racquet is a piece of equipment.

(e)

Other suitable cases: 51 (rejected) or a negative value such as minus 5 (rejected).

Marking guide: (a) 1 mark for Equipment's attributes, 1 mark for its methods, 1 mark for Racquet's extra attribute and overridden method, 1 mark for Ball shown as a subclass (4 marks). (b) 1 mark for private attributes, 1 mark for the constructor, 1 mark for the getter, 1 mark for the setter with correct validation, 1 mark for hire_cost, 1 mark for Racquet inheriting and overriding hire_cost correctly (6 marks). (c) 1 mark for explaining polymorphism, 1 mark for 14 dollars, 1 mark for 4.50 dollars (3 marks). (d) 1 mark for the maintenance benefit, 1 mark for the "is a" relationship (2 marks). (e) 1 mark for each test case with data and expected result (3 marks). Total 18 marks.