This site is from a past semester! The current version will be here when the new semester starts.

Week 6 [Fri, Sep 10th] - Project

iP:

  1. Add Increment: A-MoreOOP
  2. Add Increments as PRs: Level-8, Level-9, A-JUnit

tP:

  1. Choose user stories for v1.0 during the lecture
  2. Conceptualize v1.0
  3. Draft the UG before next lecture
  4. Refine the product design

iP

1 Add Increment: A-MoreOOP

  • As in the previous week, commit, tag, and push, as you do the following increments in the master branch (no need to use separate branches).
Duke A-MoreOOP: Use More OOP

2 Add Increments as PRs: Level-8, Level-9, A-JUnit

  • Note how to merge PRs:

  • Practice using parallel git branches and PRs, as explained below:
  1. First, do each increment as a parallel branch (follow the branch naming convention you followed earlier branch-Level-8 etc.), but do not merge any.
  2. Then, push each branch to your fork, and create a PR within your fork (i.e., from the increment branch to the master branch). Be careful not to create a PR to the upstream repo. If you did create such a PR by mistake, no worries, just close it yourself.

  1. Now, merge one of the PRs and update the remaining PRs accordingly, as given below:
    1. Merge one of the PRs on GitHub e.g., Level-8. Remember to choose the Create merge commit option when merging.
    2. Pull the updated master branch from your fork to your Computer.
    3. Note how the remaining un-merged branches are no longer in sync with the latest master. To rectify, merge the master branch to each of them. Resolve merge conflicts, if any.
    4. Push the updated branches to your fork. The PRs will update automatically to reflect the updated branch.
    5. As before, tag the merge commit in the master branch and push the tag to your fork.
  2. Merge the remaining PRs using a procedure similar to the above.
Duke Level-8: Dates and Times optional
Duke Level-9: Find
Duke A-JUnit: Add JUnit Tests

tP: Conceptualize the product

1 Choose user stories for v1.0 during the lecture

Project planning, with a twist

Intuitively, you might think the right thing to do is to decide what features will be in v3.0 and then plan the intermediate versions based on that. But that's not what we are going to do.

Why? Given the difficulty of reliably estimating the effort each feature will need, any such long-range plan is likely to be inaccurate.

Instead, what we will do is to assume the current iteration is the last iteration, plan that iteration to deliver the product (based on available time), and try to follow that plan as best as we can. After the iteration is over, we plan the next iteration as if it's the last iteration. But that time, you can factor in the experience from the previous iteration to do a better job of planning.

How is that better?

  • Shorter-term plans have a better chance of being accurate and doable.
  • You get multiple clean shots at project planning. Each try can learn from the previous tries. Hence, more learning.
  • As each iteration produces a working product, you always have a working product, which practically eliminates the risk failing to deliver a working product by the final deadline.

The goal of this activity is to come up with the smallest possible product that is still usable so that it can be implemented as v1.0, to be delivered at the end of the first project iteration. We try to make it small because you will have only two weeks to implement v1.0 and coding as a team is a lot harder than writing code alone.

Do not discuss features, UI, command format, or implementation details yet. That would be like putting the cart before the horse. At this stage we are simply trying to choose which user needs to fulfill first.

  • If the product can be of some use without a given user story, that user story should be left out of v1.0, even if the omission makes the product hard to use, as long as the product is not impossible to use e.g., in most cases a product can be used without an 'edit item' feature because the user can always delete an item and add a new item instead of editing an existing an item.
  • Don't worry about v2.0. You can design v2.0 after v1.0 done.
  • Don't worry about v1.0 being 'too small'. You can always add more features to v1.0 if you finish it ahead of schedule.
    You can also select an additional set of user stories that are nice-to-have in v1.2, to be done but only if there's time left.
  • If possible, narrow the scope of v1.0 further e.g., narrower target user, a smaller value proposition.

Suggested workflow:

  • First stage:
    • Divide the user stories among team members.
    • Each member will go through their user stories to discard (e.g., cross out, or move to a different location, but not delete) which are definitely not needed for v1.0.
  • Second stage:
    • All members discuss the remaining user stories (i.e., the ones not discarded in the first stage), and try to trim the list further.

FAQs

Q: What if the chosen user stories for v1.0 is not enough to do a meaningful work division among team members?
A: In that case, you can add more user stories until there is enough for a meaningful work distribution.

2 Conceptualize v1.0

  • Based on your user stories selected previously, conceptualize the product in terms of how it will look like at v1.0 in the form of a feature list.
    Note down the feature list in your online project notes document.

3 Draft the UG before next lecture

  • Draft a user guide in a convenient medium (e.g., a GoogleDoc) to describe what the product would be like when it is at v1.0.
    • We recommend that you follow the 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 Markdown 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 the CLI commands that you will deliver at v1.0.
    • Include only features that will be delivered in v1.0.
    • Consider including examples of expected outputs too.
    • Submission [one person per team]: Save the draft UG as a PDF file, name it {team-id}.pdf e.g., TIC4001-F18-2.pdf, and upload to LumiNUS.

Recommended: Divide i.e., work related to the User Guide and the Developer Guidedocumentation work among team members equally; preferably 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.

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

4 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 can affect the grading of the product design aspect.