- Divide MVP features among members
- / [Optional] Rename packages/classes
- Add the first functionality increment Thu, Oct 10th 23:59
Intro to tP Week 8
What's happening this week:
Having practiced the workflow in the previous iteration, this week's iteration v1.2 adds the first wave of functional code changes.
v1.2
- Learning outcome: Able to update functional code while working in parallel.
- Product goal: Take the first step towards an MVP by delivering at least some functionality changes.
- Strategy: Define the smallest possible MVP (simplest versions of must-have features only). Each member tries to merge at least one PR that moves the product towards that MVP.
The breadth-first iterative approach requires each intermediate version to be a full working product. However, to make things a bit easier for you (as you are only getting started with the project), we will not be releasing any new product version at the end of this iteration. This means you have the freedom to create PRs for small code changes, without the pressure to implement a feature end-to-end within one PR (or even within this iteration).
Things to note:
- Read our reuse policy (in Admin: Appendix B), in particular, how to give credit when you reuse code from the Internet or classmates:
- Note the individual and team expectations of the tP, if you haven't done so already.
COMMON MISTAKE: Not following the required phrasing style for the first sentence of Java method header comments.
1 Divide MVP features among members
Although MVP version is scheduled to be released in v1.3
and not in the current iteration v1.2
, in this task we refine the MVP features and divide them among the team members, because MVP is the first full product version anyway (i.e., there is nothing earlier that we can aim our plans at).
- Re-confirm MVP feature design. Recall that you decided on features to include in the MVP version of the product. Revisit that design. Ensure the following (you may refine the MVP feature design if necessary).
- It consists of not only
the most essential features of the target product, but also,
the simplest implementation of those features (e.g., when adding a new feature to track birthdays of contacts, the simplest implementation of it could be simply adding a new text field for the contact). - It will still be a working product (i.e., it can be used)
Reason: As we are following the breadth-first iterative approach, each intermediate version should be a working product.
- It consists of not only
- Divide the features among the team members i.e., who will be implementing which feature.
- Reminder: We recommend that the work to be divided primarily based on features/enhancements, not by components.
Ways to level up your tP game:
Consider the feature flaws and implementation bugs in the panels below that could cost you marks if they remained in the final version (these panels are extracts from the final product evaluation instructions given in the practical exam). If they are avoided from the start, there is no need to hunt them down and fix them later.
Tip: Especially note the part on overzealous input validation, which is a common issue found in tPs.
2 / [Optional] Rename packages/classes
- If you wish to rename AB3 packages/classes to fit your product, this is the best time to do so (i.e., before starting any functionality changes), as such changes cause widespread changes to the codebase, causing many merge conflicts with any other ongoing PRs.
- Renaming packages/classes is optional. It is fine to keep the existing ones. But if you decide to rename them, do it quickly, and probably best done by one person in one shot (to minimize merge conflicts).
3 Add the first functionality increment Thu, Oct 10th 23:59
Each member is expected to in each .
Reason: As each iteration focuses on a different learning outcome, it is better for you to take part in each of them fully.
Prefer smaller PRs.
Reason: The ability to divide work into small yet meaningful PRs is another intended learning outcome.
- For example, suppose you are asked to implement a feature F in the current iteration. Instead of creating one big PR for it, you can start with a smaller PR that implements a very VERY simple version of F, followed by a few more PRs that improve F incrementally.
- Side reading : [blog post] Small Pull Requests: 6 reasons why they are the best choice.
Steps:
- Select a code change to implement, as follows:
- Consider the feature that you have been assigned to implement for the upcoming MVP version of the product (which will be released by the iteration
v1.3
, not by the current iterationv1.2
). - Pick a small code change that you'll need to do to implement that feature. This is a small code change contributing towards the feature, not the entire feature itself. Examples: add parser support for a new command word, add a field to the person class.
This code change should not 'break' the code base though (e.g., it should not refer to a class that you plan to add in a future PR but doesn't exist yet). Ideally, it should not cause any existing tests to break either. That is, the change should take the codebase forward in a meaningful way.
- Consider the feature that you have been assigned to implement for the upcoming MVP version of the product (which will be released by the iteration
- Implement that code change while following the workflow that you practiced in the previous week. A summary of the steps:
- Create an issue for it. Assign it to yourself. Assign it to milestone
v1.2
. - Create a PR from a separate branch in your fork. Assign it to
v1.2
. - Get the PR reviewed.
- Get the PR merged. Close the corresponding issue.
- Create an issue for it. Assign it to yourself. Assign it to milestone
- Continue to implement more code changes (i.e., repeat S1 and S2) to implement more code changes that move you towards your MVP feature(s). Recommended to create , when implementing code changes with no/low dependency between them.
- Wrap up the milestone When the iteration period is over, do the following:
- Move any pending issues/PRs to the next milestone (i.e.,
v1.3
). As we did not plan to release a product version at the end of this iteration, we can freely move any pending work to the next iteration. - Close the milestone.
- There is no need to do a product release.
- Move any pending issues/PRs to the next milestone (i.e.,
End of tP Week 8
Shocked by iP to tP transition? Around this time you will realize how the speed you can implement things in the tP is significantly slower compared to the iP. As discouraging as this might feel, there are several ways this can contribute towards the learning outcomes of this course, and it is not expected to affect your tP grade either.
Feel free to improve AB3 in any way you see fit. While not very 'buggy', AB3 is not 'perfect' either (it is not meant to be a 'model solution'). In particular, find and fix any bugs it has. If you are not sure if something is a bug or an intended behavior, you can post in the forum to check.
While we are on the topic, also note that the architecture of AB3 doesn't suit every kind of application either. As you gain more experience in other application domains, you will learn different types of architectures that you can add to the collection of different architectures that you can consider for future projects. The same goes for the tool chain and the tech stack of AB3. Therefore, do not try to apply AB3 as a template for every other project you encounter in the future.