CS2103/T Website - Admin: tP: mid-v1.1 [week 6]

Set up the project repo
Get familiar with the code base
Conceptualize v2.0
Draft the UG
Refine the product design

indicates an individual milestone (i.e., each team member has to do their part of the milestone, graded individually) while indicates a team milestone (some or all members may do the work; graded for the whole team).

Milestone progress is graded. Be reminded that reaching individual and team milestones are considered for grading the project management component of your project grade.

Most aspects project progress are tracked using automated scripts. Please follow our instructions closely or else the script will not be able to detect your progress. We prefer not to spend admin resources processing requests for partial credit for work that did not follow the instructions precisely, unless the progress was not detected due to a bug in the script.

Milestone requirements are cumulative. The recommended progress for the mid-milestone is an implicit requirement for the actual milestone unless a milestone requirement overrides a mid-milestone requirement e.g., mid-milestone requires a document to be in a temp format while the actual milestone requires it to be in the proper format. Similarly, a requirement for milestone n is also an implicit requirement for milestone n+1 unless n+1 overrides the n requirement. This means if you miss some requirement at milestone n, you should try to achieve it before milestone n+1 or else it could be noted again as a 'missed requirement' at milestone n+1.

1 Set up the project repo

Set up the team org and the team repo as explained below:

Relevant: [Admin Appendix E(extract): Organization setup ]

Relevant: [Admin Appendix E(extract): Repo setup ]

Repo Setup

Only one team member:

Fork Address Book - Level 3 (AB3) to your team org.
Rename the forked repo as main. This repo (let's call it the team repo) is to be used as the repo for your project.
Ensure the issue tracker of your team repo is enabled. Reason: our bots will be posting your weekly progress reports on the issue tracker of your team repo.
Ensure your team members have the desired level of access to your team repo.
Enable Travis CI for the team repo.
Set up auto-publishing of docs. When set up correctly, your project website should be available via the URL https://ay1920s2-{team-id}.github.io/main e.g., https://ay1920s2-cs2103-w13-1.github.io/main/. This also requires you to enable the GitHub Pages feature of your team repo and configure it to serve the website from the gh-pages branch.
create a team PR for us to track your project progress: i.e., create a PR from your team repo master branch to [nus-cs2103-AY1920S2/addressbook-level3] master branch. PR name: [Team ID] Product Name e.g., [CS2103T-T09-2] Contact List Pro. As you merge code to your team repo's master branch, this PR will auto-update to reflect how much your team's product has progressed. In the PR description @mention the other team members so that they get notified when the tutor adds comments to the PR.

All team members:

Watch the main repo (created above) i.e., go to the repo and click on the watch button to subscribe to activities of the repo
Fork the main repo to your personal GitHub account.
Clone the fork to your computer.
Set up the developer environment in your computer.
Recommended: Set it up as an Intellij project (follow the instructions in the Developer Guide carefully).

Note that some of our bot scripts depend on the following folder paths. Please do not alter those paths in your project.

/src/main
/src/test
/docs

2 Get familiar with the code base

Do the following tutorials to get familiar with the codebase
- Tutorial 1 - Tracing a Command Execution Path
- Tutorial 2 - Removing a field from an entity
  - If you are an experienced programmer, you can remove a different field than the one given in the tutorial.
  - Submission: Do your changes in a branch named tutorial-removing-field and push to your fork.
- Tutorial 3 - Adding a new Command
  - If you are an experienced programmer, you can add a different command than the one given in the tutorial.
  - Submission: Do your changes in a branch named tutorial-adding-command, push to your fork, and create a PR from your fork to your team's repo.
Ideally, you should do the above tutorials by week 6 (i.e., midnight before the tutorial), but you may take an extra week (i.e., by the week 7 tutorial) to finish them without penalty.
The PRs created for tutorials need not be merged, unless the changes are actually in line with your project idea.
For reference, given below is the workflow you should follow use to merge code in your tP:

Relevant: [Admin Appendix E(extract): Workflow ]

Workflow

Read our reuse policy (in Admin: Appendix B), in particular, how to give credit when you reuse code from the Internet or classmates:

Policy on reuse

Reuse is encouraged. However, note that reuse has its own costs (such as the learning curve, additional complexity, usage restrictions, and unknown bugs). Furthermore, you will not be given credit for work done by others. Rather, you will be given credit for reusing work done by others.

You are allowed to reuse work from your classmates, subject to following conditions:
- The work has been shared publicly by us or the authors.
- You clearly give credit to the original author(s).
You are allowed to reuse work from external sources, subject to following conditions:
- The work comes from a source of 'good standing' (such as an established open source project). This means you cannot reuse code written by an outside 'friend'.
- You clearly give credit to the original author. Acknowledge use of third party resources clearly e.g. in the welcome message, splash screen (if any) or under the 'about' menu. If you are open about reuse, you are less likely to get into trouble if you unintentionally reused something copyrighted.
- You do not violate the license under which the work has been released. Please do not use 3rd-party images/audio in your software unless they have been specifically released to be used freely. Just because you found it in the Internet does not mean it is free for reuse.
- Always get permission from us before you reuse third-party libraries. Please post your 'request to use 3rd party library' in our forum. That way, the whole class get to see what libraries are being used by others.

Giving credit for reused work

Given below are how to give credit for things you reuse from elsewhere. These requirements are specific to this module i.e., not applicable outside the module (outside the module you should follow the rules specified by your employer and the license of the reused work)

If you used a third party library:

Mention in the README.adoc (under the Acknowledgements section)
mention in the Project Portfolio Page if the library has a significant relevance to the features you implemented

If you reused code snippets found on the Internet e.g. from StackOverflow answers or
referred code in another software or
referred project code by current/past student:

If you read the code to understand the approach and implemented it yourself, mention it as a comment
Example:

//Solution below adapted from https://stackoverflow.com/a/16252290
{Your implmentation of the reused solution here ...}

If you copy-pasted a non-trivial code block (possibly with minor modifications renaming, layout changes, changes to comments, etc.), also mark the code block as reused code (using @@author tags)
Format:

//@@author {yourGithubUsername}-reused
//{Info about the source...}

{Reused code (possibly with minor modifications) here ...}

//@@author

Example of reusing a code snippet (with minor modifications):

persons = getList()
//@@author johndoe-reused
//Reused from https://stackoverflow.com/a/34646172 with minor modifications
Collections.sort(persons, new Comparator<CustomData>() {
    @Override
    public int compare(CustomData lhs, CustomData rhs) {
        return lhs.customInt > rhs.customInt ? -1 : 0;
    }
});
//@@author
return persons;

Adding `@@author` tags indicate authorship

Mark your code with a //@@author {yourGithubUsername}. Note the double @.
The //@@author tag should indicates the beginning of the code you wrote. The code up to the next //@@author tag or the end of the file (whichever comes first) will be considered as was written by that author. Here is a sample code file:
```
//@@author johndoe
method 1 ...
method 2 ...
//@@author sarahkhoo
method 3 ...
//@@author johndoe
method 4 ...
```
If you don't know who wrote the code segment below yours, you may put an empty //@@author (i.e. no GitHub username) to indicate the end of the code segment you wrote. The author of code below yours can add the GitHub username to the empty tag later. Here is a sample code with an empty author tag:
```
method 0 ...
//@@author johndoe
method 1 ...
method 2 ...
//@@author
method 3 ...
method 4 ...
```
The author tag syntax varies based on file type e.g. for java, css, fxml. Use the corresponding comment syntax for non-Java files.
Here is an example code from an xml/fxml file.
```

<textbox>
  <label>...</label>
  <input>...</input>
</textbox>
...
```

Do not put the //@@author inside java header comments.
👎

/**
  * Returns true if ...
  * @@author johndoe
  */

👍

//@@author johndoe
/**
  * Returns true if ...
  */

What to and what not to annotate

Annotate both functional and test code There is no need to annotate documentation files.
Annotate only significant size code blocks that can be reviewed on its own e.g., a class, a sequence of methods, a method.
Claiming credit for code blocks smaller than a method is discouraged but allowed. If you do, do it sparingly and only claim meaningful blocks of code such as a block of statements, a loop, or an if-else statement.
- If an enhancement required you to do tiny changes in many places, there is no need to annotate all those tiny changes; you can describe those changes in the Project Portfolio page instead.
- If a code block was touched by more than one person, either let the person who wrote most of it (e.g. more than 80%) take credit for the entire block, or leave it as 'unclaimed' (i.e., no author tags).
- Related to the above point, if you claim a code block as your own, more than 80% of the code in that block should have been written by yourself. For example, no more than 20% of it can be code you reused from somewhere.
- GitHub has a blame feature and a history feature that can help you determine who wrote a piece of code.
Do not try to boost the quantity of your contribution using unethical means such as duplicating the same code in multiple places. In particular, do not copy-paste test cases to create redundant tests. Even repetitive code blocks within test methods should be extracted out as utility methods to reduce code duplication. Individual members are responsible for making sure code attributed to them are correct. If you notice a team member claiming credit for code that he/she did not write or use other questionable tactics, you can email us (after the final submission) to let us know.
If you wrote a significant amount of code that was not used in the final product,
- Create a folder called {project root}/unused
- Move unused files (or copies of files containing unused code) to that folder
- use //@@author {yourGithubUsername}-unused to mark unused code in those files (note the suffix unused) e.g.
```
//@@author johndoe-unused
method 1 ...
method 2 ...
```
Please put a comment in the code to explain why it was not used.
If you reused code from elsewhere, mark such code as //@@author {yourGithubUsername}-reused (note the suffix reused) e.g.
```
//@@author johndoe-reused
method 1 ...
method 2 ...
```
You can use empty @@author tags to mark code as not yours when RepoSense attribute the to you incorrectly.
- Code generated by the IDE/framework, should not be annotated as your own.
- Code you modified in minor ways e.g. adding a parameter. These should not be claimed as yours but you can mention these additional contributions in the Project Portfolio page if you want to claim credit for them.

At the end of the project each student is required to submit a Project Portfolio Page.

PPP Objectives

For you to use (e.g. in your resume) as a well-documented data point of your SE experience
For evaluators to use as a data point to evaluate your project contributions

PPP Sections to include

Overview: A short overview of your product to provide some context to the reader. The opening 1-2 sentences may be reused by all team members. If your product overview extends beyond 1-2 sentences, the remainder should be written by yourself.
Summary of Contributions --Suggested items to include:
- Code contributed: Give a link to your code on tP Code Dashboard. The link is available in the Project List Page -- linked to the icon under your photo.
- Features implemented: A summary of the features you implemented. If you implemented multiple features, you are recommended to indicate which one is the biggest feature.
- Other contributions:
  - Contributions to project management e.g., setting up project tools, managing releases, managing issue tracker etc.
  - Evidence of helping others e.g. responses you posted in our forum, bugs you reported in other team's products,
  - Evidence of technical leadership e.g. sharing useful information in the forum

Keep in mind that your feature(s) will be evaluated for depth, completeness, and effort. Use the PPP to convince evaluator how good those aspects of your features are.
It is fine if you want to directly explain each of those aspects of your features in the PPP i.e., how deep the feature is, why it is complete, how hard it was to implement.

[Optional] Contributions to the User Guide: Reproduce the parts in the User Guide that you wrote. This can include features you implemented as well as features you propose to implement.
The purpose of allowing you to include proposed features is to provide you more flexibility to show your documentation skills. e.g. you can bring in a proposed feature just to give you an opportunity to use a UML diagram type not used by the actual features.
[Optional] Contributions to the Developer Guide: Reproduce the parts in the Developer Guide that you wrote. Ensure there is enough content to evaluate your technical documentation skills and UML modelling skills. You can include descriptions of your design/implementations, possible alternatives, pros and cons of alternatives, etc.
[Optional] If you plan to use the PPP in your Resume, you can also include your SE work outside of the module (will not be graded).

PPP Format

File name: docs/team/githbub_username_in_lower_case.adoc e.g., docs/team/goodcoder123.adoc
Follow the example in the AddressBook-Level3
You can use the Asciidoc's include feature to include sections from the developer guide or the user guide in your PPP. Follow the example in the sample.

PPP Page Limit

Content	Recommended	Hard Limit
Overview + Summary of contributions	0.5-1	2
[Optional] Contributions to the User Guide	1-3
[Optional] Contributions to the Developer Guide	3-6

The page limits given above are after converting to PDF format. The actual amount of content you require is actually less than what these numbers suggest because the HTML → PDF conversion adds a lot of spacing around content.

Follow the forking workflow in your project up to v1.1. In particular,

Create issues to represent project tasks so that they can be tracked using the issue tracker features.
Create a PR when you implement a project task that updates the code.
You can use GitHub's draft PRs feature to indicate that a PR is not yet ready for merging.
PRO TIP LGTM is common abbreviation you can use in the review comments to mean Looks Good To Merge.
Get team members to review PRs. A workflow without PR reviews is a risky workflow.
- After setting up Netlify, you can use Netlify PR Preview to preview changes to documentation files, if the PR contains updates to documentation. To see the preview, click on the Details link in front of the Netlify status reported (refer screenshot below).
Do not merge PRs failing CI. After setting up Travis, the CI status of a PR is reported at the bottom of the PR page. The screenshot below shows the status of a PR that is passing all CI checks.
- If there is a failure, you can click on the Details link in corresponding line to find out more about the failure. Once you figure out the cause of the failure, push the a fix to the PR.
  PRO TIP You can use GitHub's protected branches feature to prevent CI-failing PRs from being merged.
After merging a PR, close the corresponding issue.
PRO TIP You can use GitHub's Fixes #123 trick to get the issue to close automatically when the PR is merged.

After completing v1.1, you can reduce process rigor to suit your team's pace. Here are some examples:

Reduce automated tests: Automated tests have benefits, but they can be a pain to write/maintain; GUI tests are especially hard to maintain because their behavior can sometimes depend on things such as the OS, resolution etc.
It is OK to get rid of some of the troublesome tests and rely more on manual testing instead. The less automated tests you have, the higher the risk of regressions; but it may be an acceptable trade-off under the circumstances if tests are slowing you down too much.
There is no direct penalty for removing tests. Also note our expectation on test code.
Reduce automated checks: You can also reduce the rigor of checkstyle checks to expedite PR processing.
Switch to a lighter workflow: While forking workflow is the safest, it is also rather heavy. You an switch to a simpler workflow if the forking workflow is slowing you down. Refer the textbook to find more about alternative workflows: branching workflow, centralized workflow. However, we still recommend that you use PR reviews, at least for PRs affecting others' features.

You can also increase the rigor/safety of your workflow in the following ways:

Use GitHub's Protected Branches feature to protect your master branch against rogue PRs.

3 Conceptualize v2.0

Based on your user story categorization in the previous week, given module requirements/constraints for the project, and the current state of the product, select which user stories you are likely to include in v2.0.
Conceptualize the product in terms of how it will look like at v2.0.

4 Draft the UG

Draft a user guide in a convenient medium (e.g., a GoogleDoc) to describe what the product would be like when it is at v2.0.
- We recommend that you follow the existing AB3 User Guide in terms of structure and format.
- As this is a very rough draft and the final version will be in a different format altogether (i.e., in asciidoc format), don't waste time in formatting, copy editing etc. It is fine as long as the tutor can get a rough idea of the features from this draft. You can also do just the 'Features' section and omit the other parts.
- Do try to come up with concrete command syntax for feature that you would implement (at least for those that you will implement by v1.4).
- Consider including some UI mock-ups too (they can be hand-drawn or created using a tool such as PowerPoint, PlantUML or Balsamiq).
- Submission: Save the draft UG as a PDF file, name it {team-id}.pdf e.g., CS2103T-W09-1.pdf, and upload to LumiNUS.

It is highly recommended that you divide documentation work (in the User Guide and the Developer Guide) among team members based on enhancements/features each person would be adding e.g., If you are the person planing to add a feature X, you should be the person to describe the feature X in the User Guide and in the Developer Guide. For features that are not planned to be implemented by v1.4, you can divide them based on who will be implementing them if the project were to continue until v2.0 (hypothetically).

Reason: In the final project evaluation your documentation skills will be graded based on sections of the User/Developer Guide you have written.

5 Refine the product design

Review the UG to ensure the features written by each member fit together to form a cohesive product. Note that cohesiveness of the product is a grading criterion.

tP: mid-v1.1 [week 6]