Reference no: EM133045057

COMP1815 JVM Programming Languages - University of Greenwich

Timetable Clash Detection System

You have been asked to work on a University Timetable Clash Detection System. The system should load teaching activities for a particular programme of study and check whether there are any clashes in the timetable.
The following information needs to be captured:

• A programme of study can be undergraduate or postgraduate
o An undergraduate programme runs over three years
o A postgraduate programme runs over one year
• Each year of study consists of two terms
o Term 1 - September to December
o Term 2 - January to April
• A programme of study consists of modules
o Modules can be compulsory or optional
o In total, a student will study four modules each term (can be a combination of compulsory and optional modules)
• For each module there can be one or more activities
o Activities can be lecture, lab, tutorial, seminar or workshop
o Activities start on the full hour
o Activities must not start before 9:00 or finish after 21:00
o Activities can only be scheduled Monday to Friday

When checking for clashes, you would need to consider the year of study (e.g., a year 2 module can run at the same time as a year 1 module without creating a clash).

In a complete timetabling system, students and staff would have to be allocated to activities, but for this assignment we are ignoring these.

The system will need to provide the following functionality:

- Set up/manage modules
- Set up/manage programmes of study
- Timetable activities for modules, according to the rules specified above
- List activities for a particular programme, year and term
- Check for potential clashes (the system must highlight the potential clash) Currently, the only type of user of the system will be an administrator.

Part A - Implementation

Organise yourselves into groups consisting of 3 or 4 students. Exceptionally, you can work individually, but please approach the tutor if you are thinking of doing this. If you cannot find a group to join, your tutors will allocate you to a group.

a) Java GUI for Project Management - Java:

Use Java to create a desktop application with a graphical user interface which enables users to set up and manage modules, programmes of study and timetable activities. It should also be possible to view the timetable of a programme by year and term.

The application should look pleasant and be easy to use.

b) Object-Oriented Design - Kotlin (10%)

Create domain and entity classes that create an object-oriented structure supporting the Java GUI application. You should apply separation of concern to ensure that the Java GUI application contains only the user-interface related functionality, and all other responsibility is assigned to the domain and entity classes. These classes should be implemented in Kotlin and integrated into the Java GUI

c) Persistence and Lambda - Kotlin

Implement persistence for the module, programme and activity data, which makes it possible to save this data. It is up to you to decide how you wish to save the information (e.g. save it to file or to database). You should use Lambda expressions to manage the collections of data. This should be implemented in Kotlin and integrated into Java GUI.

d) Clash Detection - Kotlin

Implement an object-oriented component in Kotlin that can check for potential clashes in a given programme. When clashes are identified, details of the clash should be provided.

e) Integration - Kotlin/Java

Integrate the clash detection component into the programme management process, so that when a programme timetable is edited, the system automatically checks for clashes in the background. A user should also be notified when a clash happens and details of the clash should be provided..

f) Clash Detection - Scala

You implemented the clash detection algorithm using an object-oriented approach in Kotlin. Now implement a clash detection algorithm using a functional approach in Scala.

g) Integration - Scala/Kotlin/Java

Integrate the Scala implementation of the clash detection algorithm into the Java/Kotlin application you developed. Ideally, it should be possible to choose whether the object-oriented or functional implementation should be used at run-time.

Part B - Report

The report is to be completed individually.

Write a report consisting of all the following sections:

• Section 1. - (approx. 700-1,000 words) On this module you have been taught object-oriented and functional programming paradigms, using three different languages (i.e. Kotlin, Scala and Clojure). Critically compare your experience with these different paradigms and languages. You should include discussion of their suitability to different problems and what you perceive their strengths and weaknesses to be.

• Section 2. (approx. 700-1,000 words) An evaluation of the evolution of your application. You should discuss any problems you had during implementation. You should be critical (both positive and negative) of your implementation. Be prepared to suggest alternatives. You should also include a reflection on how it was to work in a group and of your role within the team. Discuss lessons learnt, what you think went well and what you think could have been improved and how.

• Section 3. Screenshots demonstrating each of the features that you have implemented. Give captions or annotations to explain which features are being demonstrated.

• Section 4. Code listing of any code files you have written. You do not need to include generated code. Please clearly label the code, so it indicates the source file and programming language.

The Implementation
The following assessment criteria are used to determine the quality of your implementation and should be addressed in the development process:

• If you have incorporated features that were not explicitly asked for, but which add value to the application, they may be considered if you draw our attention to them.
• The application should look pleasant and be easy to use.
• Code structure - does your code demonstrate low coupling and high cohesion? Have you avoided hard coding (i.e. is your code stateless)? Have you reused external components? Have you minimised code duplication? How much impact would a further change of persistence medium have on your application?
• Quality of Design - how flexible is your application? How easy would it be to add in new functionality, or alter the presentation layer, or change the data source?
• Robustness of the application. Have you properly handled errors and validated input? Is there evidence of testing?
• Quality of code -
o Is the code clear to read, well laid out and easy to understand?
o Is the code self-documenting? Have you used sensible naming standards?
o Is your code structure logical?
o Have you commented appropriately?

The Report

The document should be clear, accurate, complete, and concise. State any assumptions you have made.

• Are all the required sections included and completed properly?
• Does the report give an accurate reflection of what you have achieved?
• Is the report clear and easy read? Does it follow the structure specified?
• Is the evaluation realistic and does it show that you have really thought about your implementation and the specified issues as well as how they may be enhanced to be ready for live deployment. Do you show insight into the complexities of software development?

Demonstration
• You should be able to demonstrate the implementation level achieved in a clear logical and unambiguous manner without encountering errors. You must be able to show knowledge of your code and design choices.

Attachment:- JVM Programming Languages.rar