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

Week 7 [Fri, Feb 17th] - Project

iP:

Add Increment: A-MoreOOP
Add Increments as PRs: Level-8, Level-9, A-JavaDoc
Set up a product website
Submit the final version Fri, Mar 3rd 2359

tP:

Set up the project repo during the tutorial
Plan the next iteration

iP

1 Add Increment: `A-MoreOOP`

Why more OOP?

One of the increments below asks you to push the design more towards the OOP approach. This is a good point to remind you the following points:

Good OOP != OOP is good: While the module pushes you to use good OOP, do not interpret it as a message of OOP is good; it's good for many situations but not so for some other situations. The best is usually a combination of approaches. Hence, you are encouraged to get better at other paradigms, the functional paradigm in particular which has been rising in popularity in some areas such as big data, AI, parallel systems.
That said, it is also preferable to use one paradigm as the primary approach and fallback on others only when the primary paradigm is clearly sub-optimal. Reason: mixing everything in equal measures might make the system even harder to understand.

OOP is primary paradigm for this module and you are expected to try to push it to its limits. That should give you a first-hand experience of OOP's strengths and weaknesses. Furthermore, OOP (or any other paradigm) will appear worse than it really is if not used correctly, and learning to use it correctly in increasingly larger systems is another objective you can aim for in this module.

We do not prohibit the use of other paradigms, however. For example, if you find a place where the functional approach is better, go ahead and use it. As you know, Java supports functional programming to a certain extent.

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-JavaDoc`

Note how to merge PRs:

Practice using parallel git branches and PRs, as explained below:

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.
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.

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.
Merge the remaining PRs using a procedure similar to the above.

Duke Level-8: Dates and Times optional

Duke Level-9: Find

Duke A-JavaDoc: JavaDoc

3 Set up a product website

Add a brief User Guide (UG)

Duke A-UserGuide: User Guide

4 Submit the final version Fri, Mar 3rd 2359

Soft deadline: midnight before the tutorial
Create a new jar file
- Create the JAR file in one of these ways:
  - If you have added a GUI or using third-party libraries: use Gradle.
  - Else: you can use Intellij.
- The JAR file should be cross-platform and should work in a computer that has Java 11.
Do the following smoke tests to ensure the jar file works (reason: a similar flow will be used when grading your iP).
1. Copy the jar file to an empty folder and test it from there. This should surface issues with hard-coded file paths.
2. Pass the jar file to team members and ask them to do a test drive. Assuming some of your team members' OS differ from yours, this should verify if the app is cross-platform.
  If you don't have ready access to a specific OS, post a link to your JAR in the forum and ask others to help with the smoke testing -- some of them will even appreciate the opportunity to help a classmate.
Create a new release on GitHub (e.g., v0.2) and upload the JAR file.
- Recommended to refrain from uploading multiple JAR files as this can cause extra work for the evaluators.

Duke A-Release: Release

tP: Get ready for iterations

1 Set up the project repo during the tutorial

Set up the team org, the team repo, and individual forks as explained below:

2 Plan the next iteration

Plan the next iteration. As you know, you should follow the breadth-first iterative process. Therefore, first you must decide what functionalities should be in the product if you had only two weeks to implement it. You have done that already when you chose user stories for v1.0, translated that to features, and even drafted the UG based on those features. You can tweak that plan further at this point if you wish, given that you now have some idea of how fast the team can work when using the prescribed workflow.
- Aim to produce a working MVP at the end of this iteration even if the functionalities are not polished (polishing can be done in a later iteration).
- [Recommended, Optional] Break the iteration into two increments i.e., aim to produce an even simpler but working version after one week.
- Avoid depth-first implementations: "I'll do the back-end part of feature X in this iteration" is not acceptable as that is not in the spirit of breadth-first iterative process. Remember, we are pretending this to be the last iteration; why would you implement the back-end part of a feature in the last iteration?
  It is OK to add simpler versions of bigger features, but not OK to add partial features that can't be used yet.
Divide the work among the team members i.e., the work required for the current iteration.
Reflect the above plan in the issue tracker by assigning the corresponding issues (create new issues if necessary) to yourself and to the corresponding milestone. For example, the user story pertaining to the increment show a place holder for photo, showing a generic default image should be assigned to Jake and to milestone v1.0
If you split the iteration into two smaller iterations of one-week each (recommended), name the first one v1.0 and the second one v1.0b so that the dashboard can track them accurately. The reason for naming the earlier milestone as v1.0 is so that even if you fail to finish the second one, you can still get credit for reaching v1.0 (which is the milestone tracked by grading scripts) -- think of the first iteration as minimal deliverables for v1.0 and the second one as containing do-if-there-is-time improvements.