tP week 8: mid-v1.2

Note that tutors are not allowed to contribute to graded components of your project work. For example, if you are faced with a design decision in your project, the tutor is not allowed to make that decision for you.
Reason: to ensure fairness across teams, and to ensure the work you submit for grading is entirely your own

Following from the above, don't expect the tutor to answer questions that are specific to graded deliverables (e.g., ask which design alternative is better -- that's a decision you need to make yourself). At best, the tutor can channel the question to the professor. However, you can raise such questions in the module forum where the professor can answer the question in a general way that's not unfair to other teams (and other teams can benefit from the answer as well).

Functionality Expectations

You will get full marks for implementation effort if you meet the expectation stated above. There are no extra marks for exceeding that bar. You are better off spending that effort in improving other aspects of the project.

Individual Expectations

Individual Expectations on Implementation

• Expectation Contribute to the functional code of the product.
  • User-visible features are preferred, but it is not a strict requirement.:
  • The enhancement(s) should fit with the rest of the software (and the target user profile) and should have the consent of the team members. You will lose marks if you go 'rogue' and add things that don't fit with the product.

• Tip: Contribute to all aspects of the project e.g. write backend code, frontend code, test code, user documentation, and developer documentation. Reason: If you limit yourself to certain aspects only, you could lose marks allocated for the aspects you did not do. In addition, the final exam assumes that you are familiar with all aspects of the project.

• Tip: Do all the work related to your enhancement yourself. Reason: If there is no clear division of who did which enhancement, it will be difficult to divide project credit (or assign responsibility for bugs detected by testers) later.

Individual Expectations on Documentation

• Objective: showcase your ability to write both user-facing documentation and developer-facing documentation.
• Expectation Update the User Guide (UG) and the Developer Guide (DG) parts that are related to the enhancements you added. The minimum requirement is given below. (Reason: Evaluators will not be able to give you marks unless there is sufficient evidence of your documentation skills.)
  • UG: 1 or more pages
  • DG: 3 or more pages
• Tip: If the UG/DG updates for your enhancements are not enough to reach the above requirements, you can make up the shortfall by documenting 'proposed' features and alternative designs/implementations.
• Expectation Use at least 2 types of UML diagrams in your DG updates i.e., diagrams you added yourself or those you modified significantly.

Individual Expectations on Testing

Individual Expectations on Teamwork

• Expectation Do an equal share of the team-tasks.

• Expectation Carry an equal share of project roles and responsibilities.

• Expectation Review each others work. Reason: reviewing skills is a learning outcome, and it is mutually beneficial.

Team Expectations

• Expectation Preserve product integrity i.e. ensure,
  1. features fit together to form a cohesive product,
  2. documentation follows a consistent style and presents a cohesive picture to the reader, and
  3. final project demo presents a cohesive picture to the audience.
• Expectation Maintain product quality i.e. prevent breaking other parts of the product as it evolves. Note that bugs local to a specific feature will be counted against the author of that feature. However, if a new enhancement breaks the entire product, the whole team will have to share the penalty.
• Expectation Manage the project i.e. ensure workflow, code maintenance, integration, releases, etc. are done smoothly.

tP Issue Tracker Setup

We recommend you configure the issue tracker of the tP team repo as follows:

• Delete existing labels and add the following labels.
  Issue type labels are useful from the beginning of the project. The other labels are needed only when you start implementing the features.

• Create following milestones : v1.1, v1.2, v1.3, v1.4

• You may configure other project settings as you wish. e.g. more labels, more milestones

tP Project Schedule Tracking

In general, use the issue tracker (Milestones, Issues, PRs, Tags, Releases, and Labels) for assigning, scheduling, and tracking all noteworthy project tasks, including user stories. Update the issue tracker regularly to reflect the current status of the project. You can also use GitHub's Projects feature to manage the project, but keep it linked to the issue tracker as much as you can.

Using Issues:

• Record each of the user stories you plan to deliver as an issue in the issue tracker. e.g.,

• Assign the type.* and priority.* labels to those issues.

• Formalize the project plan by assigning relevant issues to the corresponding milestone.

• Define project tasks as issues. When you start implementing a user story (or a feature), break it down to smaller tasks if necessary. Define reasonable sized, standalone tasks. Create issues for each of those tasks so that they can be tracked.

  • A typical task should be small enough for one person to do in a few hours. eg.,

    • Bad (reasons: not a one-person task, not small enough): Write the Developer Guide
    • Good: Update class diagram in the Developer Guide for v1.4

  • There is no need to break things into VERY small tasks. Keep them as big as possible, but they should be no bigger than what you are going to assign a single person to do within a week. eg.,

    • Bad:Implementing parser  (reason: too big).
    • Good:Implementing parser support for adding of floating tasks

  • Do not track things taken for granted. e.g., push code to repo should not be a task to track. In the example given under the previous point, it is taken for granted that the owner will also (a) test the code and (b) push to the repo when it is ready. Those two need not be tracked as separate tasks.

  • Write a descriptive title for the issue. e.g. Add support for the 'undo' command to the parser

    • Omit redundant details. In some cases, the issue title is enough to describe the task. In that case, no need to repeat it in the issue description. There is no need for well-crafted and detailed descriptions for tasks. A minimal description is enough. Similarly, labels such as priority can be omitted if you think they don't help you.
      
      

• Assign tasks (i.e., issues) to the corresponding team members using the assignees field. Normally, there should be some ongoing tasks and some pending tasks against each team member at any point.