iP:
A-Assertions
, A-CodeQuality
, A-Streams
A-CI
tP:
.jar
file is smaller than 5MB, most likely JavaFX libraries are not inside it.A-FullCommitMessage
.A-Assertions
, A-CodeQuality
, A-Streams
Guidance for the item(s) below:
As you know, one main goal of the iP is to prepare for you for the tP. The task below is heavy on the 'training for tP' aspect.
In previous iP increments, you learned:
master
branch to an upstream repoIn the following iP task you will learn how to do the following new things, which are relevant to the tP:
master
Due to the above learning goals, this iP task is a bit complicated. Pay attention and try to achieve all learning goals along the way.
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.
When you are doing the next step, you can run into merge conflicts. In some cases, GitHub will give you a way to resolve those conflicts using the Web interface. While this approach may be good enough for simple merge conflicts, de-conflicting locally in the standard way is safer (e.g., you can run tests to confirm the updated code is correct) and more standard (it's a standard Git feature that you can use even when you are not using GitHub for your project).
Create merge commit
option when merging.master
branch of your local repo to fall behind that of your fork (). Therefore, you need to sync the local master
with the remote master
branch. One way to do that is to switch to the local master
branch and then pull the updated master
branch from your fork e.g.,$ git checkout master
$ git pull origin master
A-Assertions
PR first.master
. To rectify, merge the master
branch on to each of them. Resolve merge conflicts, if any. The outcome will be something like the below:A-CodeQuality
PR and syncing the local branch-A-Streams
with the updated master
branch.A-CI
B-DoWithinPeriodTasks
or C-Sort
or D-Places
BCD-Extension
to the corresponding commit.BCD-Extension
.Discuss with your team members to ensure that each member picks a different extension.
You may want to pick an extension that is potentially relevant to your tP so that the code can be reused in the tP later, if possible.
Connecting the dots so far ...
We already know that the tP will be done in breadth-first iterative manner, each iteration delivering a working version that will be evolved further by subsequent iterations. Now is a good time for us to plan those iterations.
Intuitively, it feels like we should decide features of the final version first, and then, work our way backwards to plan intermediate versions.
But that approach is not advisable, due to the difficulty of reliably estimating the effort each feature will need, especially because we are not experienced in doing similar projects. So, any such long-range plan is likely to be highly inaccurate anyway.
Instead, our approach is to assume the current iteration is the last iteration.
Then, we aim to deliver the best possible product at the current iteration, based on available time.
We execute the iteration accordingly, and even tweak the plan further along the way, as needed.
After the iteration is over, we plan the next iteration as if it's the last iteration. But that time, we can factor in the experience from the previous iteration to do a better job of planning.
How is that better?
However, it does not mean we simply keep adding features without any plan and declare whatever we have at the end as the 'final product'. Instead, we should still set targets, and follow a plan that aims to hit those targets.
Thus, we can adopt the following two Planning Strategies:
Along PS1, we have already defined (in the previous week) the target user profile, and the problem addressed.
Along PS2, we have not done anything yet.
What's happening this week:
You can do this step as if the tP is a greenfield project (i.e., as if there is no AB3), to get the full experience of this activity. Some of the user stories you come up with may already be implemented in AB3, but that can be sorted out later.
Follow the steps in the recipe mentioned above to arrive at user stories for the product, with your team members. If you don't follow the recipe mentioned above, you could end up with a different set of user stories than otherwise.
User stories for what version? At this stage, collect user stories to cover at least the final version you hope to deliver at the end of the semester. It is OK to go even beyond that (reason: we are simulating a project that will continue even after the semester is over).
Do not omit user stories already covered by the features in AB3 i.e., the user story should be recorded even if AB3 already caters for it.
How many user stories? Aim to collect more user stories than you can deliver in the project. Aim to create at least 30 user stories. Include all 'obvious' ones you can think of but also look for 'non obvious' ones that you think are likely to be missed by other competing products.
User stories of what size? Normally, it is fine to use epic-level user stories in the early stages of a project but given this is a small project, you may want to eventually break them down to smaller user stories (i.e., small enough for one person to implement in 1-2 days). Some examples (from the iP product domain):
What format?: You may use a sentence format or a table format but do maintain the prescribed three-part structure of a user story. In particular, try to include the benefit part in most user stories as that will come in handy when prioritizing user stories later.
Submission (to be checked by the tutor later):
If you choose to use the GitHub issue tracker to manage user stories, you need to set up your team's GitHub organization, team repo, and its issue tracker first. Instructions for doing those steps are in the panel below.
Task: Of the user stories you have collected, select the ones you would put in an version of the product. The goal here is to come up with the smallest possible product that is still usable so that it can be implemented quickly, and delivered at the end of an earlier iteration.
Try to limit the MVP to strictly must-have user stories only i.e., it's NOT what you can or want to put in the MVP, but what you must have in the MVP. If the product can be of some use without a given user story, that user story should be left out of the MVP version, 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.
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.
Don't worry about subsequent versions or the final version. You can design them at a later time.
Don't worry about MVP being 'too small'. You can always add more features to the MVP version if you finish it ahead of schedule.
You can also select an additional set of user stories that are nice-to-have for the MVP, to be done but only if there's time left.
In the interest of keeping the MVP small, you can narrow the scope of MVP further e.g., narrower target user, a smaller value proposition.
Suggested workflow: