Hello, if you have any need, please feel free to consult us, this is my wechat: wx91due
CPT206 Computer Programming for Financial Mathematics:
Coursework Resit Task Specification
Set: Monday, 22 July, 2024
Due date: Sunday, 4 August, 2024, 23:59
This is the specification task sheet for the Coursework resit assessment of your CPT206 module. The task covers all Learning Outcomes, and has a weighting of 100% towards the final grade for this module. This assignment has two parts: a coding part described in Section 1, and a report described in Section 2. The submission deadline for this assignment is Sunday, 4 August, 2024, 23:59. Detailed submission instructions are provided in Section 3.
1 Program description (70 marks)
The aim of this coursework is to build a company management system. All the work should be coded into a single Java NetBeans project, with the class structure and different functionalities of the program described as follows. All classes should be properly encapsulated, as seen in the Lectures and Labs throughout the semester. Your project should also contain a Controller class for testing.
You may leave some or all of your test code in the Controller class if you wish when submitting, but no marks are allocated for this class’s contents in your submission.
Instead you will be asked to describe your testing in the report (see Section 2.2), and marked on that.
1.1 Task class (14 marks)
The company will consist of a number of employees (see Section 1.2, each of which is assigned a list of tasks. Each task consists of a description, status (not started, in progress, complete), and a due date. The Task class should have the following methods:
- isOverdue() which indicates if a task is overdue (i.e. if the due date for the task has already passed);
- extend(period) which extends the due date of the task by the specified period;
-
updateStatus(newStatus) which updates the task’s status; a task’s status can only be moved forward (from “not started” to “in progress” or “complete”, or from “in progress” to “complete”), not backwards (e.g. from “complete” to “not started”).
1.2 Employee class (18 marks)
This class will model the employees of the company. Each employee has an ID number (unique), a name, a salary (their monthly wage), a performance indicator (see below), and a todo list of tasks currently assigned to them (see Section 1.1). In the todo list, tasks should be ordered according to their due date, with the most urgent tasks placed first. You should choose a suitable data structure in the Java collection framework for storing these. Leave a comment in your code justifying your choice. The Employee class should also have methods to add or remove tasks from their todo list, with the following restrictions. A task cannot be removed if it would leave them with no currently assigned tasks.
The maximum number of tasks an employee can have assigned is 20. Finally, employees should be able to filter their todo list to get their overdue tasks.
The performance indicator takes the following possible values: below expectations, meets expectations, above expectations, and outstanding. These map in order to numbers 0 (for below expectations) to 3 (for outstanding), which determine the employee’s salary increase rate, as a percentage point. At the end of each year, an employee’s salary is updated via an updateSalary() method, which increases their salary accordingly. So if an employee’s current salary is 10, 000 and their performance above expectations, their salary the following year will be 10, 000 * (1 + 0.02) = 10, 200. By default, when a new employee is hired by the company, their performance indicator is set to “meets expectations”, and they do not have any tasks assigned.
1.3 TemporaryEmployee class (6 marks)
The company may at times need to hire temporary employees, for example to meet specific project deadlines. Temporary employees have all the features of the standard employees from Section 1.2, but are on fixed-term contracts. This means that they store a date indicating when their contract will expire. Their contract can be extended if necessary via an extendContract(period) method.
1.4 Company class (22 marks)
Finally, your program will contain a Company class to model the company’s operation. The company should have a (legal) name, a collection of employees, and a remainingSalaryAllowance variable indicating how much additional money the company currently has to spend on monthly salaries. You should choose a suitable data structure in the Java collection framework for storing a company’s employees, leaving a comment in your code justifying your choice. Companies can either be created with a specified collection of employees, or by default with no employees.
The Company class should have the following methods. A number of these operations will effect the company’s remaining salary allowance (for example firing an employee frees up their salary in the allowance).
You should consider all these modifications carefully, and if any causes the remaining salary allowance to become negative, the system should throw some form of critical error.
• A method hire(employee) that hires a new employee, provided the remaining salary allowance is sufficient to do so.
• A method for firing a given employee. An employee can only be fired if their performance indicator is “below expectations” and they have at least five overdue tasks.
• A method evaluate(employee, indicator) for evaluating an employee’s current performance. If they have any overdue tasks, their performance indicator can be at best “meets expectations”.
• A method assign(task, employee) that assigns a currently unassigned task to an employee.
• A method assign(task, oldEmployee, newEmployee) that re-assigns a task previously belonging to oldEmployee to newEmployee.
• Finally, there should be a method updateFinancials() to update the financial situation of the company, as follows.
– The method should take a single parameter representing the company’s intake over the latest period, that can be added to the remaining salary allowance.
– If the company has any temporary employees whose contract has terminated, these should be removed from the company’s employee collection.
– If the method is called on January 1 (of any year), all current employees have their salaries adjusted, as specified in Section 1.2.
1.5 Code quality (10 marks)
The remaining marks (10) will be awarded for the quality of your code, as covered throughout the semester in the Lectures and Labs.
• Keep your code neat and tidy; make sure it is properly indented throughout.
• Choose suitable names for variables and methods, respecting standard Java naming conventions.
• Comment your code as needed.
• Split your code into separate methods as appropriate; methods should not be too long.
2 Report (30 marks)
For this part of the assignment, you will write a report detailing how you designed, implemented, and tested the program described in Section 1.
The report should be typed into e.g. a Word document, and submitted as a PDF (see Section 3 for more details). Where suitable in the report, you should refer to specific lecture slides (or parts of Lab worksheets), e.g. “as seen in Lecture 10, slides 32-34”.
2.1 OOP features (12 marks)
Over the course of the semester, you have learned a number of OOP features (e.g. encapsulation) and principles (e.g. single responsibility principle). In your report, you will explain where you have incorporated these in your design and how you have done so; include a brief definition of the features/principles in question. Be as precise as possible, illustrating with small portions of code if necessary. Note that not all the features and principles we saw in the lectures need to be incorporated into your design; your report should only discuss those that are. This section should be one-and-a-half to two pages in length.
Good example: The Single Responsibility Principle states that every class in the program should have responsibility over a single functionality of the program; a class should do one thing. This principle is incorporated into our class design: all the classes have their own, separate, purpose. For instance, the Company class ...
Bad example: Encapsulation and inheritance are two core features of OOP; they are used in many parts in my program.
2.2 Testing description (12 marks)
As covered throughout the Lectures and Lab sessions in this module, testing is an essential part of writing computer programs. In your report, you will include a description of how you tested the various parts of the program described in Section 1. You will state clearly what functionalities you tested, and describe how you tested them, thinking carefully about possible corner cases. You may include some sample code if you wish. You should test in the Controller class of your project, using only tools and techniques that we covered in the Lectures and Labs throughout the semester. For testing, you must NOT use any new or more advanced tools such as JUnit that weren’t taught. This section should be one-and-a-half to two pages in length (screenshots excluded).
2.3 Improvements (6 marks)
Finally, this program is, by necessity, a simplified model. In your critical evaluation document, you will list two (2) possible improvements to the system. These could be for instance additional features to be implemented, changes to existing featuresso that the system is a more accurate reflection of a real-world system, and so on. Give a brief justification for why these would improve the system. This part should be no longer than one page in length.
3 Submission instructions
In the dedicated “Resit submission” Assignment activity on the Learning Mall Online, you will need to submit the following two (2) documents. The submission deadline is: Sunday, 4 August, 2024, 23:59.
- A single ZIP archive of your entire NetBeans project. Include all the resources your project needs to run. This file will be named “CPT206__Resit__Project__StudentId.zip”.
- Your report from Section 2, typed into e.g. a Word document, and converted into a PDF file. This file will be named “CPT206__Resit__Report__StudentId.pdf”.
This assignment is individual work. Plagiarism (e.g. copying materials from other sources without proper acknowledgement) is a serious academic offence. Plagiarism and collusion will not be tolerated and will be dealt with in accordance with the University Code of Practice on Academic Integrity. Submitting work created by others, whether paid for or not, is a serious offence, and will be prosecuted vigorously. The use of generative AI for content generation is not permitted on this assignment. Such a use would be considered in breach of the University Code of Practice on Academic Integrity, and dealt with accordingly. Individual students may be invited to explain parts of their code in person during a dedicated interview session, and if they fail to demonstrate an understanding of the code, no credit will be given for that part of the code.
Late submissions. The standard University policy on late submissions will apply: 5% of the total marks available for the component shall be deducted from the assessment mark for each working day after the submission date, up to a maximum of five working days, so long as this does not reduce the mark below the pass mark (40%); submissions more than five working days late will not be accepted.