1. Overview

This project portfolio details my key contributions to the software engineering project Athletick.

1.1. About the project

Athletick is a desktop team-management application designed for coaches and captains who manage time-based sports (e.g. swimming, racing) teams. Athletick allows users to manage athlete information, record training sessions and save competition results. Athletick also allows users to monitor their training schedule and track an athlete’s attendance, performance and sporting progress. This enables users to better manage their team, plan for trainings and prepare for upcoming competitions.

1.2. About the team

Athletick was designed by a team of student athletes who were passionate about making team-management hassle-free for captains and coaches. Our team comprises of five second-year computer science undergraduates from the National University of Singapore (NUS) and we created Athletick as part of a requirement for our second-year software engineering module. We were tasked with morphing a desktop address book application with the constraint that it had to be a command line interface application. This project was completed over six weeks.

Note the following symbols and formatting used in this document:

This symbol indicates important information.
command

A grey highlight (called a mark-up) indicates that this is a command that can be typed into the command line and executed by the application.
component

Green text with grey highlight indicates a component, class, object or method in the architecture of the application.

2. Summary of contributions

This section contains a summary of my contributions to the project. This includes code, documentation and other helpful contributions to the team project.

Enhancement added: I added the ability to add and delete training information.

  • What it does:

    • The training command adds training information to Athletick. Users store the date of training and players attended, allowing them to view, edit and delete past training data.

  • Justification:

    • Coaches and captains keep records of past trainings so they can use the information to manage their team. Allowing them to store training dates helps them to monitor their training schedule and plan for future training programs. We also allow storage of attendance information as a coach or captain would want to know attendance for that training session.

  • Highlights:

    • The training feature was designed to function as a standalone unit and does not rely on any other components. This allows for easy extension of the feature to cater to different users. We have plans to extend the training feature to include more information, like type of training (e.g. gym training, sprints training) and athlete performance.

    • There are 2 variations of the training command. This allows users to indicate attendance of a training by listing members present, or by members absent. We understand that keying player attendance can be very tedious for big teams. Giving the option to coaches and captains to mark attendance by entering players absent will reduce the amount of typing which will save time.

  • Credits:

    • Saving of training data into .json files is done with the use of the Jackson library.

Enhancement added: I added the ability to monitor an athlete’s attendance.

  • What it does:

    • A built-in attendance tracker allows users to track their team’s attendance using the attendance, select, view attendance and calendar commands.

  • Justification:

    • Coaches and captains are concerned about their team’s overall attendance rate as it is a good indicator an athlete’s commitment and how prepared an athlete is for a competition. Providing an automatic attendance tracker removes the need for manual calculation as it can be tedious for them, especially if they have to go through many training sessions.

  • Highlight:

    • Attendance of a particular training is used in the calendar command and attendance rate is used in the select command. A TrainingManager was implemented to provide other components use with important information from training information and attendance rate.

Code contributed: The links provided show my code contribution for the project. (RepoSense) (All commits)

Other contributions:

  • Project management:

    • Managed release version 1.3 of Athletick on GitHub. (v1.3)

    • Performed manual testing of application before every release to detect bugs that were not covered by test classes.

    • Served as the team’s quality assurance engineer — reviewed code quality and documentation of every pull request before merging.

  • Enhancement to existing features:

    • Extended the existing delete command to support deletion of trainings. (Pull request #194)

    • Tweaked the edit person command to work with training information. (Pull request #195)

    • Tweaked the clear command to clear training information. (Pull request #194)

  • Documentation:

    • Created the general framework for the Developer Guide. (Pull request #19)

    • Added documentation for the training, attendance and view attendance commands in the User Guide. (Pull requests #121, #131, #227 )

    • Added documentation for training feature in the Developer Guide. (Pull requests #131, #227)

    • Standardised product screenshots for training, attendance, select features and FAQ in User Guide to make it more reader friendly. (Pull request #227)

  • Community:

    • Reviewed other team’s PRs to give suggestions and comments.

    • Stress tested applications from other teams, reported bugs and gave suggestions. (Bug reports and suggestions)

    • Reviewed and commented on pull requests. (Pull requests #28, #30, #63, #64, #187)

3. Contributions to the user guide

This section displays excerpts of my contributions to the user guide for the training and attendance features. They showcase my ability to write documentation targeting end-users of our application. You can view the entire document here.

{Start of extract from User Guide}

3.1. Training

Athletick allows you to record your team’s training sessions, so that you can store important information like date of training and training attendance. After adding a training session, you can look at past trainings to check attendance on that particular date. You can also edit training attendance or delete a training from Athletick.

3.1.1. Record training session by indicating athletes absent : training -a

This command saves a training session to Athletick, and marks the athletes indicated as absent. You will need the date of training and indexes of athletes who were absent.

Let’s say you want to record a training session that took place today and everyone was present except Tao Li.

What you should do

Type in the training command, the absent flag -a, date of training and the indexes of athletes who were absent in the following format and press Enter to execute it.

Format : training -a [d/DDMMYYYY] #/INDEX [INDEX] [INDEX ] …

Examples : training -a d/29112019 #/3 6 or training -a #/3

If no date is entered, the training will be recorded under today’s date.
training with flag before

What you should see

If successfully added, the result box will display the following result as shown in the diagram below. A green dot will appear also at the date on the calendar, indicating that the training has been recorded.

training with flag after

3.1.2. Check overall attendance of your team : view attendance

This command allows you to check the overall attendance of your team.

Let’s say you would like to track your team’s overall attendance but don’t want to manually type the attendance command multiple times.

What you should do

Type the view attendance command and press Enter to execute it.

view attendance before

What you should see

If the command is successful, the result box will display the following result as shown in the diagram below. The feature box will show you your team’s overall attendance.

view attendance after

{End of extract from User Guide}

4. Contributions to the developer guide

This section displays excerpts of my contributions to the developer guide for the training feature. They showcase my ability to write technical documentation to developers, as well as the technical depth of my contributions to the project. You can view the entire document here.

{Start of extract from Developer Guide}

4.1. Training feature

Athletick allows users to record training information like the date of training and an athlete’s attendance. This is done using a training command. With this information recorded, Athletick allows users to get the team’s overall attendance rate, and get an overview of all training sessions in a month.

4.1.1. Implementation

A Training class stores the training information. To facilitate management of trainings, a TrainingManager class stores all the Training sessions. The class diagram below shows the interaction of different components to produce the training feature.

training class diagram
Figure 1. Class diagram of the training feature components

A training session is represented by a Training class and it contains information like the date of training and training attendance. The AthletickDate class represents the date of a training session in Training. This class is shared across both the frontend and backend of the application, allowing training information to be used in other features that use AthletickDate. A HashMap<Person, Boolean> represents attendance in Training and indicates whether a Person has attended that training session. If a Person attended, the value associated with him in the HashMap<Person, Boolean> will be true, and false if he did not attend.

The TrainingCommand is an abstract class that extends the Command class and allows users to record training sessions. Users have the ability to add training sessions by indicating members present or members absent using the training or training -a commands. The TrainingCommandPresent and TrainingCommandAbsent are classes that extend TrainingCommand which allows for this polymorphism. They are created by the TrainingCommandParser class.

A TrainingManager stores and manages all Training sessions in Athletick. It contains a list which is used to maintain information of multiple trainings. A Training is added to this list whenever a user executes a training command. The activity diagram below shows how training information is stored after a user executes the training command.

training command activity diagram
Figure 2. Activity diagram showing execution of training command

TrainingManager also provides functions for users to calculate the attendance rate of one individual, or the entire team. The following operations are used for this feature:

  • TrainingManager#getPersonAttendanceRateString — Returns the person’s overall attendance rate in String format.

  • TrainingManager#getAttendanceRateOfAll - Returns a list of everyone’s attendance rate.

These operations are used by the select, attendance and view attendance commands. The following sequence diagram shows how the TrainingManager provides other components with attendance rates.

view attendance sequence diagram
Figure 3. Sequence diagram showing how view attendance command gets attendance rate

TrainingManager also allows users to get the attendance of one particular training using the following operation:

  • TrainingManager#getTrainingAttendanceListOnDate — Returns training attendance on the specified date.

The sequence diagram below shows a use case of how training attendance is obtained from TrainingManager when a calendar command is executed.

calendar sequence diagram
Figure 4. Sequence diagram showing how calendar command gets training attendance

4.1.2. Design Considerations

This section contains some of our considerations for the training feature.

Aspect: How to store attendance information of an individual.

Alternative 1: Make extensions to the Athletick class by storing and tagging each Person with number of trainings attended and total number of trainings.

Alternative 2 (Current Choice): Create separate classes to manage training information.

Pros

It is easy to implement.

Allows storing of specific training information without depending on the Athletick class. This also allows new features to be easily introduced to training in the future.

Cons

Violates software engineering principles (single responsibility principle) and is not useful when we want more detailed information (attendance on specific date) about a training session.

More time needed to design system architecture.

Reason for choosing alternative 2: Training and TrainingManager are created as standalone classes to contain training information. We intend to introduce new features (e.g. training category) in the future and this implementation allows us to easily do so.

Aspect: Which data structure to store training attendance.

Alternative 1: Use a linked list to store training attendance.

Alternative 2 (Current Choice): Use a hash table to store training attendance.

Pros

Most intuitive way to maintain training attendance. Also provides us with functions to easily access and edit data.

Makes obtaining information much quicker.

Cons

Accessing attendance and attendance rate of one person takes more time.

Requires more effort to maintain and requires coding of new functions to edit data.

Reason for choosing alternative 2: The select and attendance commands require the attendance rate of only one person and a hash table provides us with the fastest access time to access attendance information of one person.

Aspect: How to edit training information.

Alternative 1 (Current Choice): Edit by replacing an existing training with a new training on the same date.

Alternative 2: Create a command to support editing of training.

Pros

Users will not need to type lengthy edit commands.

More intuitive to a user who wants to edit.

Cons

Unable to support multiple trainings on same date.

Users have the option to edit date, attendance and even add a person which will require lengthy commands.

Reason for choosing alternative 1: Editing training information would require typing long commands which will be very time-consuming and this defeats the purpose of having a command line interface. Editing training by replacing an old one with the training command makes it editing much quicker.

{End of extract from Developer Guide}