PROJECT: EazyTutors

Overview

Purpose

  • This project portfolio was written to document my role and contributions to the EazyTutors project. I was responsible for creating the Note feature and the Details Panel that shows a selected student’s progress.

The Team

  • My team comprises of students from the National University of Singapore and we decided on creating this application after observing the hassle tutors have to deal with when marking attendance.

The Application

  • EazyTutors is a desktop statistics recording application used for managing classes of students. It was created with NUS tutors in mind, but can be extended to tutors or teachers from other organizations as well. The user interacts with it using a CLI, and it has a GUI created with JavaFX. It is written in Java, and has about 10 kLoC.

Features

  • Mark students' attendance

  • Record students' assignment scores

  • Calculate assignment statistics

  • Calculate class performance

  • Add students' photos

  • Record notes about students

Summary of contributions

Preface

This section serves to inform you of the improvements I made to the project, including code, documentation and administrative tasks.

Enhancements

  • Major enhancement: added the ability to add/delete/edit a student’s note

    • What it does: allows the user to add, delete or edit notes specific to each student.

    • Justification: This feature will help tutors remember their students better and customise their teaching towards each student to be more effective. This would be especially helpful for tutors with large classes where it is very hard to remember each and every student and their respective personalities.

    • Highlights: Added notes are auto-punctuated. Each note added will have a full stop appended to its end if it does not already end with either !,? or .. When more text is added to the note, the current text’s full stop will be changed to a , before the new text is added.

  • Minor enhancement: added a panel in the GUI for displaying a student’s details such as their assignment grades and respective note.

  • Minor enhancement: added some tests for enhanced AddCommand.

  • Code contributed: [Project Code Dashboard]

  • Other contributions:

    • Project management:

      • Managed releases v1.1 to v1.3.3 (7 releases) on GitHub.

      • Set up issue tracker for team repo.

      • Set up team org and team repo.

    • Enhancements to existing features:

      • Changed the "add" command to only have a person’s name as a compulsory parameter, with the rest being optional. It also takes in an index argument that adds the person at that specified index. (PR #103)

    • Documentation:

      • Update GitHubPages and README to reflect the product and the team details. (PR #22 commits #1, #2)

      • Created first draft of User Guide. (PR #6)

      • Updated ContactUs to reflect our product. (Commit #1)

      • Added implementation details of Note and MoreDetailsPanel to Developer Guide.

    • Community:

      • PRs reviewed (with non-trivial review comments): PR #74, #104, #150.

      • Reported bugs for team T10-1 during Practical Exam Dry Run.

    • Tools:

      • Set up Travis auto-documentation for the team repo.

      • Set up AppVeyor as a secondary integration tool for the team repo.

      • Set up Coveralls to monitor the test coverage of our project for the team repo.

Contributions to the User Guide

Given below are sections I contributed to the User Guide. They showcase my ability to write documentation targeting end-users.

Introduction

EazyTutors is an application for tutors or teachers who prefer a virtual way to manage a class of students. It allows users to mark students' attendance, as well as checking on students' individual progress. This helps users customise their teaching to students with different capabilities. It boasts extra features such as calculating the class statistics and assignment statistics. EazyTutors is optimized for those who prefer to work with a Command Line Interface (CLI) while still having the benefits of a Graphical User Interface (GUI). You won’t need to bring around attendance sheets anymore with EazyTutors! Interested? Jump to Section 2, “Quick Start” to get started. Enjoy!

Add a note about a student : note

Attaches a note with specified text to a student in the student list specified by his/her index.
Format: note INDEX TEXT

  • Any added note is automatically ended with a full stop unless the input TEXT ends with either ., ! or ?.

  • If a note is added to a student who already has a previous note, the previous note is changed to end with a comma before the new text is appended to the back.

TEXT should not begin with a whitespace but alphanumeric and special characters are allowed.

Examples:

  • note 1 hardworking student
    Student at 1st index’s note:

    userGuide noteExample

    note 1 motivated too!
    Student at 1st index’s note:

    userGuide noteExample2

Delete a student’s note : delnote

Deletes the corresponding note of the student at the specified index.
Format: delnote INDEX

  • There can be any number of spaces between delnote and INDEX.

An empty note cannot be deleted!

Examples:

  • delnote 2 (Deletes the note of the 2nd student shown, is invalid if there is less than 2 students in the shown student list.)

Edits the note of a student : editnote

Sets the corresponding note of the student at the specified index to text. Refer to Add a note about a student : note for details on text.
Format: editnote INDEX TEXT

An empty note cannot be edited!

Examples:

  • note 2 check finals mark addition?
    Student at 2nd index’s note:

    userGuide editnoteExample

    editnote 2 marks checked.
    Student at 2nd index’s note:

    userGuide editnoteExample3

    delnote 2
    Student at 2nd index’s note:

    userGuide editnoteExample4

Proposed Enhancement for v2.0

  • Add a section to show users how to use the new and improved GUI that we intend to add in v2.0

  • Show step-by-step examples on how to use the application features using the GUI, using screenshots of the application and text.

Contributions to the Developer Guide

Given below are sections I contributed to the Developer Guide. They showcase my ability to write technical documentation and the technical depth of my contributions to the project.

UI-Model binding of student details

Current Implementation

The data MoreDetailsPanel binds itself to are filteredPersons and filteredAssignments in the Model class.

  • filteredPersons — Current students (filtered by find command) stored in the database.

  • filteredAssignments — The names of all the assignments that the students have in the database.

MoreDetailsPanel will be notified by any changes in the data when a related event is raised, such as PersonPanelSelectionChangedEvent. It will then retrieve the new student’s marks and note using filteredPersons and display them with reference to their names in filteredAssignments.

Note data structure

Current Implementation

A Note stores a String text (content of the note). text is final and never changed once initialized. When a note or editnote command is executed, a new Note is created with the final text. The methods in the Note class return a new Note object with the new text.

Design considerations

Aspect: Note auto-punctuation

  • Alternative 1(current choice): Note texts are automatically ended with a full stop (.) if it is not added by the user, unless the user ends the text with ! or ?. When a note or editnote command is executed on a Note that already has text, the previous text’s punctuation is changed to a comma (,) instead before being added to the final text.

    The workflow for this algorithm is shown below. Text refers to the text being added, noteText refers to the existing text in the Note and newText refers to the final text in the newly created Note.

    NoteTextAdditionActivityDiagram
    Figure 1. Activity Diagram for Text Addition

    • Pros:

      • Note text is standardized without the user having to bother about doing so in their input.

    • Cons:

      • If the user wishes to end their notes with other punctuation such as ! or ?, the user has to add it into their input.

      • Other special characters used to end sentences will not be detected and a full stop will be added to them.

      • Developers have to manually add special characters to be checked for.

  • Alternative 2: No editing of Note text, text will be whatever the user inputs.

    • Pros:

      • Easy to implement, there is no need to check text input.

      • User flexibility in what they want their text to end with.

    • Cons:

      • User has to take more care in adding Note text in their input.

Aspect: Edit note implementation

  • Alternative 1 (current choice): Delete the note, before adding it using note command. As deleting the note is similar in both delnote and editnote, they implement the NoteDeleter interface with has a default method copyWithoutNote to reduce repeated code.

    EditNoteFeatureClassDiagram
    Figure 2. Structure of Note commands (only classes closely related to EditNoteCommand shown)

    An example of how the editnote command would work is depicted in the sequence diagram below. NoteCommand is minimally represented for brevity.

    EditNoteCommandSequenceDiagram
    Figure 3. Sequence Diagram of EditNoteCommand executing (only relevant methods are shown)

    • Pros:

      • Easier to implement.

      • Adapts with any changes to the NoteCommand without needing to update.

    • Cons:

      • Some overhead accrued due to NoteCommand object creation.

      • Dependency between EditNoteCommand and NoteCommand.

  • Alternative 2: Implement a separate edit note command.

    • Pros:

      • Command will be able to work on its own.

    • Cons:

      • Some repeated code with NoteCommand.

Adding a person

  1. Adding a person to the current list

    1. Prerequisites: No student already exists in the student list with the same name. If there is an index specified, it must be a positive integer lesser than the current size of the student list + 1.

    2. Test case: add n/John Doe p/67891234 e/johnd@gmail.com a/Parliament House t/friend s/2
      Expected: Student with name "John Doe" added to 2nd index of list. Details of the added student shown in the status message. Timestamp in the status bar is updated.

    3. Test case: add n/John Doe
      Expected: Student with name "John Doe" added to bottom of list, all other details are empty. Details of the added student shown in the status message. Timestamp in the status bar is updated.

    4. Test case: add n/John Doe s/1
      Expected: Similar to previous, except the student is now added to the top of the list.

    5. Test case: add n/ p/98765432 e/test@example.com
      Expected: No person is added. Error details shown in the status message. Status bar remains the same.

    6. Other incorrect add commands to try: add n/John Doe p/99, add n/John Doe t/good friend, `add n/John Doe e/test (commands where the parameters used are invalid)

Adding a note

  1. Adding a note to a student

    1. Prerequisites: There must be a student at the index specified. The index must be a positive integer.

    2. Test case: note 1 test
      Expected: If the first student had no note, his note as displayed at the bottom right is now test., else, test. is added to back of his existing note, with the full-stop of existing note changed to a comma. Details of student to whom the note was added is shown in the status message. Timestamp in the status bar is updated.

    3. Test case: note 2 great!
      Expected: Similar to previous, except the note ends with an exclamation mark instead.

    4. Test case: note 1 test2
      Expected: No note is added. Error details shown in the status message. Status bar remains the same.

    5. Other incorrect note commands to try: note 1test, note 1 test (where the format is incorrect) Expected: Similar to previous.

Deleting a note

  1. Deleting a note of a student

    1. Prerequisites: Student at specified index must have an existing note.

    2. Test case: delnote 1
      Expected: Note of first student is deleted. Details of the student whose note was deleted shown in the status message. Timestamp in the status bar is updated.

    3. Test case: delnote 0
      Expected: No note is deleted. Error details shown in the status message. Status bar remains the same.

    4. Other incorrect delete commands to try: delnote, delnote x (where x is larger than the list size), delnote -1 (where index should not be negative)
      Expected: Similar to previous.

Editing a note

  1. Editing a student’s note

    1. Prerequisites: Student at specified index must have an existing note.

    2. Test case: editnote 1 test?
      Expected: New note test? displayed on bottom right of window. Details of student whose note was edited shown in the status message. Timestamp in the status bar is updated.

    3. Test case: editnote 2 might need more help on recursion.
      Expected: Similar to previous, except the note ends with a full-stop instead.

    4. Test case: editnote 1 test2
      Expected: No change to the note. Error details shown in the status message. Status bar remains the same.

    5. Other incorrect note commands to try: editnote 2inquisitive, note 1 consult at 2pm (where the format is incorrect)
      Expected: Similar to previous.

Proposed Enhancement for v2.0

  • Adding more UML diagrams as an aid to show readers exactly how the application is built

  • Add more features to the Implementation section to tell readers how our features were implemented and what alternative designs we considered