Comp$-4411$ Programming Languages

Assignment Task: Kotlin Programming $-$ Procedural and Object$-$Oriented Programming

Objective:

To evaluate your understanding of procedural and object$-$oriented programming $($OOP$)$ concepts in Kotlin. You will demonstrate your ability to write modular, reusable code using both paradigms, understanding how to solve problems with clear specifications, following guidelines and rules.

Part $1$: Procedural Programming in Kotlin

Task Description:

You are required to write a Kotlin program using procedural programming principles $($i$.$e$.,$ without using any classes or objects$)$ to simulate the management of a library system. The library system should keep track of books and students. Each student can borrow up to $3$ books at a time. The program should do the following:

$1.$

Book Management:

o

Define a structure to represent a book with the following attributes: title, author, and status $($available or borrowed$).$

o

Allow adding new books to the library collection.

$2.$

Student Management:

o

Define a structure to represent a student with attributes: name, student ID$,$ and the list of books they have borrowed.

o

Allow adding new students to the system.

$3.$

Borrowing and Returning Books:

o

Allow a student to borrow a book if it$$s available and if they haven$$t borrowed more than $3$ books.

o

Update the book$$s status when borrowed or returned.

o

Prevent the student from borrowing the same book twice or borrowing more than $3$ books.

$4.$

Display Data:

o

Implement a procedure to display the list of books and their availability.

o

Implement a procedure to display which students have borrowed books and how many.

Comp$-4411$ Programming Languages

Requirements:

$$

Use arrays or lists to store books and students.

$$

You should not use any classes or objects for this part.

$$

Use functions to break down tasks into manageable pieces of code.

Constraints:

$$

Design your program in a modular way to prevent code duplication.

$$

Make sure that students cannot borrow more than $3$ books or borrow a book that$$s already borrowed.

Part $2$: Object$-$Oriented Programming in Kotlin

Task Description:

You are now required to refactor your procedural program from Part $1$ into an object$-$oriented design. Use classes, objects, and OOP principles such as encapsulation, inheritance, and polymorphism where appropriate. You need to add more functionality to the library system, incorporating the following changes:

$1.$

Encapsulation and Inheritance:

o

Create a base class Person with attributes like name and id$.$

o

Derive the Student class from Person and add an attribute for the maximum number of books they can borrow.

o

Add a new type of user, such as Librarian, derived from Person. The Librarian should have the ability to manage $($add$/$remove$)$ books and students.

$2.$

Book Categories:

o

Create a hierarchy of book categories using inheritance. For example:

$$

Book $($base class$)$

$$

Fiction, NonFiction, and Magazine $($derived classes$).$

o

Each type of book should have additional attributes $($e$.$g$.,$ Fiction books have genre, Magazines have issue number$).$

o

Implement a method in the Book class and its derived classes to print detailed information about the book.

$3.$

Polymorphism and Overriding:

Comp$-4411$ Programming Languages

o

Use method overriding to customize the behavior of borrowing or returning books based on the type of book. For example, students can borrow Fiction books for $14$ days and Magazines for only $7$ days.

o

Implement polymorphism when displaying book information, ensuring that calling a method on a Book reference displays the correct details based on whether the book is Fiction, NonFiction, or Magazine.

$4.$

Exception Handling:

o

Handle cases where a student tries to borrow more than $3$ books or when a book is not available by raising custom exceptions and catching them in the program.

Requirements:

$$

Use proper OOP design principles: encapsulation, inheritance, and polymorphism.

$$

Ensure that the program is well$-$structured, with appropriate use of classes and objects.

$$

Implement error handling using Kotlin exceptions.

Constraints:

$$

You must implement at least one abstract class or interface.

$$

You should implement at least one custom exception class.

Part $3$: Comparative Analysis

Task Description:

Write a $500-$word report comparing your implementations in Part $1$ and Part $2.$ Focus on the following points:

$1.$

How did the structure of your code change from procedural to object$-$oriented?

$2.$

What are the advantages and disadvantages of each approach in terms of modularity, readability, and maintainability?

$3.$

Discuss how encapsulation, inheritance, and polymorphism helped organize the OOP version.

$4.$

Reflect on any challenges you faced during the refactoring process.

Submission Guidelines:

$1.$

Code:

o

Part $1$: Procedural Kotlin code $(10$ marks$)$

o

Part $2$: Object$-$oriented Kotlin code $(10$ marks$)$

Comp$-4411$ Programming Languages

$2.$

Report: Submit a $500-$word report