Recent Question/Assignment

ATMC ICT221 Java Programming Assignment 2018.1
This is Task 2 of the ICT221 assessment, which is worth 30% of the course. It is an individual assignment, so your submission must be completely your own work. You cannot collaborate with other students or share code with them, but you can ask your tutor for help.
Your task is to build an interactive graphical program for exploring various ICT Careers, and their connections with the minors and the courses in the BICT degree.
The Excel screenshot on the right shows the kinds of information your program will enable students to explore.
We would like to release this BICT Explorer to future students, as an app to plan their degree. One of your GUI designs could be chosen for this!
Overview
You will be given some core Java classes and data files that capture the careers, minors and courses of the BICT.
Your job is to test that code, to print a report about the available minors, and to design and build a GUI that allows a student to interactively explore various careers and minors.
Learning Objectives
1. Use object-oriented design (OOD) to design Java programs;
2. Be able to use inheritance and subtyping relationships between classes;
3. Be able to use association or composition relationships between classes;
4. Be able to develop a comprehensive suite of unit tests for the core logic classes of an application (the model part of the program);
5. Demonstrate your ability to read and write text files, to save and load data;
6. Build graphical user interfaces using JavaFX;
7. Use a distributed source code control system: GIT.
Getting Started
1. Start by creating your private GitHub repository by clicking on the link in the Assessment / Task 2 area of Blackboard, then accepting this assignment.
2. Then clone your new repository down to your development machine using IntelliJ, so that you can work on it. When you finish each of the following steps, make sure you commit and push your changes back to GitHub.
3. Create au/edu/usc/bict_explorer/rules/CourseTest.java, and add some JUnit 5 tests for the ‘rules/Course.java’ class. This will help you understand how the Course class works. Note that it is a subclass of the Option class, so you should also read the Javadocs for that class too. The superclass (Options) has already been tested, so your Course unit tests should focus on thoroughly testing the new features of this class (semesters and prerequisites). You must submit these unit tests as part of your final submission.
4. Create a new package called au/edu/usc/bict_explorer/reports and then in that package write a console program called MinorsReport.java that uses the rules/Degree class and prints out all its minors. After each minor, the courses of that minor should also be shown, indented. (So, use a nested for loop). Your program should print the report output into a text file called minors.txt. For example, the first few lines of output might look like this (Note: this report ignores the minor called -BICT-, since that lists all the core courses, rather than a real minor.):
Minor: Software Development
Description: A software development minor enables you to be a programmer.
ICT112: Creative Program Solving with Programming
ICT221: Software Development 1
ICT310: Systems Analysis and Design
ICT311: Mobile App Development
Minor: Game Programming
. . .
Designing and Implementing the GUI
Design and implement an elegant and usable GUI for the BICT Explorer.
Your GUI should allow students to explore and select the various ICT careers, BICT minors and courses that are defined in the data files.
Requirements:
A. Usability: Your GUI should be elegant, easy to use, and robust.
B. Data-Driven: Your GUI should be data-driven as much as possible, so that when the details of BICT minors or courses change in the resources files, your GUI automatically adapts to those changes without any Java code changes.
C. CSS Stylesheet: You should use a CSS stylesheet to style your GUI, so that the style can easily be changed later by a professional designer, without any Java code having to be modified.
D. Helpful course selection: your GUI should not allow a course to be selected until its prerequisites are satisfied (i.e. until course.isSatisfied(...) is true). If the user tries to select a course whose prerequisites are not satisfied, it would be helpful to display a message (Alert) about this, showing the required prerequisites.
E. Helpful course arrangement: for good readability, your GUI should group the courses by their year level, or sorting them into alphabetical order by their codes (which groups them by discipline then by year level).
Hints:
• Start by doing some paper mockups, and think about how they will work. Take a photo of your final paper designs, since you will need to include these in your report.
• Design a sequence of deliverable GUIs, starting very simple, and adding features one by one (iterative development). For example, your first GUI might just loop through the minors, and create a toggle button for each minor. Your next iteration might add an Action Event handler to those buttons, which calls the getChosen() method of that minor to select it or deselect it. Aim to complete at least 1-2 features per week.
• The assignment is due on Week 12 (Friday 8 June) at 11:55pm.

Submission and Marking Criteria
You must submit to Blackboard (Assessment / Task 2) just a REPORT.docx file. This should start with your full name, your student username, your GitHub username, and the URL of your GitHub repository containing all your assignment code and data files, and then the four sections described below.
Your submission will be marked using the following criteria:
1. Report 20% (Report.docx): this should contain four sections:
A. Introduction: one paragraph to explain how your GUI works, plus copy the table below and fill it in to show which features you have implemented).
B. GUI sketches: show your GUI sketches (insert a photo of your paper sketches), followed by one or two screen shots of your final GUI. Then discuss what changes you made and the reasons for those changes.
C. UML diagram: a UML class diagram that shows all the model (rules) classes, the GUI classes that you have written, any JavaFX classes that they inherit from (name only, no details), and the relationships between all classes.
D. Reflection: a brief discussion of what went well in your GUI development, any difficulties that you encountered, and what you would do differently if you were doing it again.
2. Unit Testing 15%: your unit tests of Course.java.
3. Minors Report 15%: (your reports/MinorsReport.java program, plus the generated report in a text file called minors.txt).
4. GUI functionality 25%: this will be marked using the following criteria: a playable and robust GUI; good use of JavaFX widgets, layout panes, and controls to build an elegant and functional user interface; appropriate use of bitmap images in the GUI; good resize behaviour when the main window is resized; and ability to generate and save reports about the user's current choices of careers, minors and courses. See the table below for a breakdown of these marks.
5. GUI code, worth 25% (in package gui): this will be marked using the following criteria: helpful Javadoc comments for public and protected classes and methods; good use of event-driven programming; good OOD of the GUI classes with strong encapsulation of the data fields within classes; good use of inheritance and subtype polymorphism; adherence to recommended Java coding style (naming conventions, code formatting etc.); concise elegant code with no duplicated code; and good use of exception handling to catch and report any I/O or other errors.
GUI Feature What you have done to implement this feature?
(leave blank if not implemented) Possible
Marks
Usable Robust GUI
(including resizing) / 5
Data-Driven / 5
CSS Stylesheet / 5
Helpful course selection / 5
Helpful course arrangement / 5