CSYM025: Visual Object Software PJ1 Assessment Brief 2026 | UoN

CSYM025 Assessment Brief

This assessment is designed to prepare students for creating object-based solutions to software problems within a contemporary integrated development environment. The objective is to equip students with the syntax and semantics of the underlying model while promoting good practice in software construction and testing.

Task:

Design, implement and test a software system using object-oriented principles in Java FX for specific client requirements. Your tutor will act as the client and it is your responsibility to elicit requirements and represent them as user stories. Design should include class diagrams and use case diagrams. Implementation should be in phases adopting principles of agile development. The initial implementation phase should consist of developing a console application.
The assessment consists of 3 key elements:

1.Creation of an Application/System in Java FX
2.Technical Report
3.Video Demonstration

Functional Requirements:

1. The application should have a graphical user interface (GUI) built with JavaFX for user interaction.
2. The data should be persisted in data files. The application should connect to the files and perform CRUD (Create, Read, Update, Delete) operations. The objective is to assess your object-oriented design and development skills. Hence, use of database management systems and query languages (e.g., SQL) are strictly prohibited and would result in an overall failure.
3. The core entities in the application should be modelled as classes (e.g., Customer, Product, Order etc.). These classes should encapsulate data and behaviour.
4. The classes should implement principles of abstraction, inheritance, polymorphism as suitable.
5. The application should provide useful features like searching, reporting, and notifications etc.
6. The code should have sufficient documentation and comments for readability and maintenance.
7. For improved code reuse and modularity, common utility functions could be kept in a separate util package/module.
8. Exceptions should be handled properly to make the application resilient and user-friendly. Custom exception classes can be created.
9. Input data validation should be done to reject invalid/incorrect data and prevent exceptions.
10. Code should follow standard Java coding guidelines and best practices for quality and maintenance.
11. Testing should include both white box (JUnit tests) and black box (test logs).
12. The adoption of object-oriented principles should be evident in your implementation of the above requirements.

Deliverables:

A. Technical Report The report should consist of the following sections (in the same order):

1.Username and password for all relevant accounts (if implemented).
2.UML Class Diagrams.
3.A list of all the user stories implemented in a tabular format. For example: User Story
Details of user story 1 Details of user story 2 Implemented (Partial/Full)
Full

Full

Any comments

No error validation.

4.Explanation of the main sections/fragments of the code. Provide information on how the code has evolved from a console application. How has the code evolved in phases? What was the process followed? You may want to refer to the class diagrams to explain code.

5.Screenshots of the system showing all key features.

6.Evidence of Testing:
a. Blackbox Testing: Test logs providing information of all the tests carried out (including any failed tests for functionality not implemented)
b.Whitebox Testing: Code Listing of all the JUnit test cases.
c.List of any bugs and/or weaknesses in your system (if you do not think there are any, then say so). Bugs that are declared in this list will lose you fewer marks than ones that you do not declare.

7.References If you have borrowed some code from elsewhere (e.g., from a book or some resource
 n the web you must indicate clearly what they are and include references). Click here for further information.

B.Source Code The source code must be well documented with necessary comments. Consistent and clear indentation of the code is also important. Source code needs to be submitted in two forms:
i.As a single ZIP archive (.zip file consisting of all “.java” files, unit tests, data files).
ii.A commented full listing in a separate Word document named “Full Source Code Listing”. This should include the console application.

C.Video Demonstration In addition to the report, you must submit a video demo (URL) of your assignment. The demo should be about 10 minutes long and should cover all your work in a logical way. You should explain the main phases of design and implementation covering the main fragments of code. How did the code evolve in phases from a console application? Your face and voice need to be clear in the video. It should also include a walkthrough of using the software and must demonstrate the key features. The module tutor reserves the right to invite you for an online viva-voce. Poor demo/viva could negatively influence other sections in the marking criteria and may result in an overall fail grade. You may also be referred for a suspected academic misconduct investigation.

Submission:

To submit your work, go to the ‘Assessment and Submission’ area on the NILE site and use the relevant submission points/links:

1. E-Submission of documents through Turnitin on NILE as TWO separate WORD documents [Document 1 = Report & Document 2 = FullSourceCodeListing].
2. E-Submission of a single ZIP archive that contains all the source code files (.java), unit tests, data files, ReadMe file, Properties file and so on. The archive must be named with your student ID, e.g. 12345678.zip where 12345678 is your student ID.
3. Public link (url) to video demonstration. Use of Kaltura (Kaltura MyMedia - University of Northampton) is recommended. You must ensure that the video link is accessible to the marker (do not set it to private access).
4. Failure to follow the above submission guidelines may result in a capped or fail grade.

Learning Outcomes aligned to this Assessment:

On successful completion of this assessment, you will be able to:

1. Select and explain current principles underlying the object-oriented (OO) approach to developing software systems which are complex, conceptually challenging.
2. Demonstrate understanding of how OO techniques help in the development of correct, robust and reliable software systems, through the application to technical problems.
3. Select and explain current practical issues associated with the technology, design, and operation  f GUIs, in line with professional practice.
4. Select and successfully implement appropriate testing methodologies of software systems
5. Demonstrate a consistent and positive work ethic that indicates a preparedness to take appropriate risks, explore multiple options and create opportunities for self-development in a purposeful manner.
6. Apply a wide range of software implementation methods.

Assessment Guidance:

You will find a link to your online reading list on NILE in the “About this module” section.

Use of Generative AI (Artificial Intelligence) within this Assessment:

Some uses of Generative AI may be deemed unethical in your Assessment. Further guidance on the conditions for allowable use of Generative AI will be given by the module team.

AI within assessments.

AI Categories: Category 1: No GenAI allowed For this type of assessment, you are unable to use GenAI due to the design of the assessment. For example, a closed book exam where you are required to demonstrate within controlled conditions that you have core knowledge or a skill in a particular area. As it is not possible to use GenAI within this type of assessment, you do not need to acknowledge use of GenAI.

Academic Practice support

The Skills Hub is a central repository where you will find a range of support for your study and assessments: University of Northampton Skills Hub

Feedback:

Feedback should be received within 20 working days.

An announcement will be sent out via NILE to inform you of when feedback is available. Instruction on Anonymity for students Further guidance is available online

CSYM025 PJ1: Postgraduate Marking Rubric