PROJECT: ResuMe

Overview

ResuMe is a desktop application for you to manage all of your resumes from a centralised location. It is easy to build, customise and export different resume versions using only Command Line Interface.

Our developer team consists of five Year 2 Computer Science students from the National University of Singapore. This six-week project is a component of our CS2103T Software Engineering module, and is built upon the code from AddressBook Level 3.

Summary of Contributions

1. Individual Contributions

1.1. Contributions to Source Code

You can view my code contributions via RepoSense

  • Major enhancement: added the ability to generate a .pdf file from an existing resume

    • What it does: allows users to export their resume to a well-formatted and printable .pdf version, which could be directly submitted to their potential employer.

    • Justification: This feature improves the product significantly because users do not need to spend time on manually formatting the final product, making it much more efficient and convenient to create new usable resume using the application.

    • Highlights: This enhancement involves an external library that supports building a .pdf file using Java. It was challenging as it requires a steep learning curve in order to integrate the library into our application, while keeping in mind of both our design consideration and existing architecture.

    • Credits: Apache Pdf Box (#142)

  • Minor enhancement: added more depth to help command, where user can either view a Command Summary for all available commands, or a Getting Started guideline. Both command options will open a new pop-up window to maximise readability and facilitate easy cross-reference.

  • Minor enhancement: integrated the add command with our new model implementation to support more item type like internship, project and skill. Each item type has their own set of attributes, and hence needs a separate command and parser class for the add function.

1.2. Contributions to Documentation:

  • Updated README (#161)

  • Updated the User Guide for the following sections: About this guide, Viewing help: help, Adding an item: add, Generating a resume: rgen

  • Updated the Developer Guide for the following sections: Model Component, Export Feature, Appendix A: Product Scope, Appendix D: Non Functional Requirements, Appendix E: Glossary

2. Team Contributions

2.1. Model Refactoring

  • What it means: Item is now an abstract class with five different subclasses: Internship, Project, Skill, Resume and Note. Each type of item also has its own set of attributes, utilising field classes like Name, Time, Role, Website, Level, Description, ect…​

  • Justification: This ensures flexibility for the user to customise their experiences according their the nature. With such variety of attributes, implementing each type as a separate class is more in line with OOP principles.

  • Refactoring Pull Requests: #66, #73, #75,…​

2.2. Testing

Test Pull Requests: #136, #187, #236, #253, #254,…​

2.3. Reviewing:

  • Reviewed Pull Requests with non-trivial review comments: #159, #25, #86, #256,…​

  • Reported bugs and suggestions for other teams in the class (examples: 1, 2, 3)

Contributions to the User Guide (Extracts)

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

About this guide

Our aim when writing this document is to help you - a new user - get started with ResuMe as quickly as possible. The guide features all the available commands, their syntax, as well as specific examples for illustration.

This section is, well…​ a guide on how to use this guide :) We will be explaining some of the symbols and formatting used, key terms, as well notes and tips for a better user experience.

Symbols and Formatting

Most of us are visual learners, and we figured, what is a better way to present information than using some shapes and colours?

Symbol / Format Explanation

Important information to take note

Tips

Warnings on potential misuse

consola font

Keywords representing an item type or their parameters, or a command that could be executed

Key terms

You will come across these little guys a lot in this document, so let’s get to know them first!

Term Explanation

type

Consisting of five different types: internship, project, skill, resume and note

item

An item stored in the application, which could be any one of the five types above

command

A line of text that you could type into the command box and execute

parameter

Specific information about an item supplied by you

index

The position of the item in the currently displayed list

Adding an item: add

Adds an item to the ResuMe application.

Format: add i/ TYPE n/ NAME [ATTRIBUTE/ VALUE]…​ [#/ TAG]…​

The specific command syntax could be found in the table below:

Type Format

Internship

add i/ int n/ COMPANY_NAME r/ ROLE f/ FROM t/ TO d/ DESCRIPTION [#/ TAG]…​

Project

add i/ proj n/ PROJECT_NAME t/ TIME w/ WEBSITE d/ DESCRIPTION [#/ TAG]…​

Skill

add i/ ski n/ SKILL_NAME l/ LEVEL [#/ TAG]…​

Resume

add i/ res n/ RESUME_NAME [#/ TAG]…​

Note

add i/ note n/ NOTE_NAME t/ TIME [#/ TAG]…​

  • An item could have any number of tags (including 0).

  • There are three possible levels for a skill item: ADVANCED, INTERMEDIATE and BASIC.

  • A newly added note will be automatically marked as undone.
The description of an item could be written in one paragraph (with full stop and a space after each sentence). These sentences, when exported to .pdf format, will be automatically shown as individual bullet points! (refer to rgen for more details)

Example: Try typing in the command box these two commands one by one!

  1. list i/ proj

  2. add i/ proj n/ Duke t/ 06-2020 w/ abc.github.io d/ For a little module named CS2103T. #/ java #/ tech

Outcome:

  1. All project items are listed in the list box.

    ListProject
    Figure 1. List of all project items

  2. A new project item named "Duke" with the specified fields is added. This item is automatically reflected in the list box.

    AddDukeProject
    Figure 2. Application view after project "Duke" is added

Generating a resume: rgen

Generates a .pdf file from an existing resume stored inside the application at the specified index.

Format: rgen RESUME_INDEX [n/ FILE_NAME]

  • A valid RESUME_INDEX is a positive integer that identifies an existing resume.

  • The exported .pdf file will be located in the same folder as the application .jar file.

It is optional to specify a FILE_NAME for the .pdf file. If no name is specified, the filename will be set, by default, to the name of the generated resume.

Example: Let’s try out the following commands!

  1. list i/ res

  2. rgen 1 n/ My Resume

Outcome:

  1. The first command lists out all resume items. Assuming that you want to generate the first resume in the list box.

    ListResume
    Figure 3. List of all resume items

  2. The second command generates a "My Resume.pdf" file from the specified resume. The screenshots of the application view and of the generated file are as below:

    GenerateResume
    Figure 4. Application view after rgen is executed
    PdfFile
    Figure 5. Generated .pdf file

Contributions to the Developer Guide (Extracts)

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.

Model component

ModelClassDiagram
Figure 6. Structure of the Model Component

API : Model.java

The Model,

  • stores a UserPref object that represents the user’s preferences.

  • stores the Resume Book data.

  • stores the Resume Book state using VersionedResumeBook to facilitate undo/redo.

  • exposes an Observable that contains an internal Person with user’s data, and two unmodifiable ObservableList<Item>, one for Note and one for Internship, Project, Skill and Resume.

  • has the UI bound to its observables so that the UI automatically updates when the data change.

  • does not depend on any of the other three components.

Export Feature

The Export Feature supports two main actions: previewing the content of a Resume item, and then generating a .pdf file from it.

Previewing a resume: rpreview

Implementation

rpreview is supported by the new Command, ResumePreviewCommand and the additional method toPreview() implemented in Internship, Project and Skill, which return the content of the item in textual format.

Given below is an example usage scenario:

Step 1. The user launches the ResuMe application. After loading data from storage to the application memory, the list of resumes in the ResumeBook could either contain some resumes, or is empty.

Step 2. The user executes rpreview INDEX. If the specified resume INDEX is out of bound, ResuMe throws an error message.

Step 3. The application retrieves the correct Resume item and calls toPreview() on the items contained in that resume.

The following activity diagram summarises what happens when a user executes rpreview command:

ExportPreviewActivityDiagram
Figure 7. Activity Diagram for ResumePreviewCommand
Design Considerations
Aspect: Where rpreview is displayed

  • Alternative 1 (current choice): Displays in a separate preview pop-up window.

    • Pros: The preview is separated from the application and does not clutter the application view. It is also no longer confined to a small space and hence improves readability.

    • Cons: Additional non-command-line action needed to close the pop-up window after previewing.

  • Alternative 2: Display in the same panel as view

    • Pros: No significant change to UI component.

    • Cons: Multiple commands needed if user finds out about a typo in an item, wants to view the item in details, fix the typo and then check the preview again to ensure there is no more error.

  • Alternative 3: Create a separate preview box to display the resume preview. Additionally, this box could be implemented such that it automatically updates when the content of the Resume item is edited.

    • Pros: User can see the resume preview in the preview box, and the item details in the view box at the same time, hence saving time switching between views.

    • Cons: Too many panels could be confusing for the user to navigate. The space is also often wasted since user does not need to use rpreview regularly.

Conclusion: Given that the application already has quite a number of panels (User Box, Command Box, Result Box, View Box and List Box), alternative 1 is chosen to minimise the layout and improve on user experience.

Every time the user makes an edit, the Result Box will display a confirmation message, and the View Box will shows the edited details. Hence, user will not need to call rpreview after each edit just to confirm that the command is successfully executed and error-free. As such, rpreview will not be a command that is used often, and the benefits of a clean UI outweighs the compromise made when additional action to close the pop-up window is required.

Generating a .pdf file from a resume: rgen

Implementation

This feature utilises the external Apache Pdf Box library. When using rgen, the user could specify the desired name of the generated file, which will be saved in the root directory of the project.

The executing of rgen is facilitated by an addition PdfBuilder class, which implements the following main operations:

  • addPage() - starts a new page in the .pdf file. This method is called dynamically to fit the content of the resume to be generated.

  • addPersonalDetails() - adds the relevant resume and user details to the .pdf file.

  • addInternships(), addProjects() and addSkills() - adds the resume content to the .pdf file in the same order that they appear in the resume. If a section is empty, it will not be added to the output file.

Given below is an example usage scenario:

Step 1. The user launches ResuMe. After loading data from storage to the application memory, the list of resumes in the ResumeBook could either contain some resumes, or is empty.

Step 2. The user executes rgen INDEX n/ FILE_NAME. If the specified resume INDEX is out of bound, ResuMe throws an error message.

Step 3. The application retrieves the correct Resume item, create a new .pdf file and populates it with the corresponding items inside the Resume.

The following activity diagram summarises what happens when a user executes rgen command:

ExportActivityDiagram
Figure 8. Activity Command for GenerateResumeCommand

Detailed steps are shown in the sequence diagram below:

ExportSequenceDiagram
Figure 9. Sequence Diagram for GenerateResumeCommand

Design Considerations

Aspect: How rgen executes

  • Alternative 1 (current choice): Generate .pdf file by iteratively adding items contained in resume.

    • Pros: Better control of the output layout, as the position and formatting of each section could be set individually. Additionaly, rgen is dynamic, in the sense that even without calling rpreview every time, the generated file will be consistent with any item update.

    • Cons: Coupled with rpreview, the content of a Resume must be read twice every time the user wishes to export.

  • Alternative 2: Generate .pdf file directly from the previewed text output by rpreview

    • Pros: Faster and simpler rgen

    • Cons: Limited formatting options (font type, font size and page layout) since the whole document is now input as one long string of text. rgen implemented this way is also static, and might not reflect the most updated content if there are item changes after rpreview is called.

Conclusion: Alternative 1 is chosen because each resume is not likely to hold more than 20 items, hence the cost of reading its content twice (once during rpreview and once during rgen) is relatively small. Choosing alternative 1 will further allows the application to have more control when formatting the output file, and leaving room for potential extended features (e.g. allow user to choose from a variety of pre-defined resume templates).