This site is from a past semester! The current version will be here when the new semester starts.
CS2113/T 2020 Jan-Apr
**Schedule**
  • Full Timeline
  • Week 1 [from Mon Jan 13]
  • Week 2 [from Wed Jan 15 noon]
  • Week 3 [from Wed Jan 22 noon]
  • Week 4 [from Wed Jan 29 noon]
  • Week 5 [from Wed Feb 5 noon]
  • Week 6 [from Wed Feb 12 noon]
  • Week 7 [from Wed Feb 19 noon]
  • Week 8 [from Wed Mar 4 noon]
  • Week 9 [from Wed Mar 11 noon]
  • Week 10 [from Wed Mar 18 noon]
  • Week 11 [from Wed Mar 25 noon]
  • Week 12 [from Wed Apr 1 noon]
  • Week 13 [from Wed Apr 8 noon]
  • Textbook
  • Admin Info
    • **Links**
  • Report Bugs
  • Forum
  • Instructors
  • Announcements
  • File Submissions
  • Tutorial Schedule
  • repl.it link
  • Java Coding Standard
  • Forum Activities Dashboard
  • Participation Dashboard
    •  Individual Project (iP):
  • Individual Project Info
  • Duke Upstream Repo
  • iP Code Dashboard
  • iP Progress Dashboard
    •  Team Project (tP):
  • Team Project Info
  • Team List
  • tP Code Dashboard
  • tP Progress Dashboard
    •

    • Week 8 [from Wed Mar 4 noon] - Project

    iP:

    1. Evaluate two peer iPs before next week lecture

    tP:

    1. Ensure you know tP expectations
    2. Start implementing v1.0
    3. Use GitHub to manage milestones
    4. Add some JUnit Tests

    iP

    1 Evaluate two peer iPs before next week lecture

    This activity is considered for iP grading.

    Your username 1st iP to evaluate 2nd iP to evaluate
    A11riseforme [JAR][User Guide][Code] [JAR][User Guide][Code]
    Bencotti [JAR][User Guide][Code] [JAR][User Guide][Code]
    DDzuikeai [JAR][User Guide][Code] [JAR][User Guide][Code]
    DeetoMok [JAR][User Guide][Code] [JAR][User Guide][Code]
    E0309556 [JAR][User Guide][Code] [JAR][User Guide][Code]
    GanapathySanathBalaji [JAR][User Guide][Code] [JAR][User Guide][Code]
    HAOYUN49 [JAR][User Guide][Code] [JAR][User Guide][Code]
    JLoh579 [JAR][User Guide][Code] [JAR][User Guide][Code]
    JTWang2000 [JAR][User Guide][Code] [JAR][User Guide][Code]
    Janicetyy [JAR][User Guide][Code] [JAR][User Guide][Code]
    JensonWee [JAR][User Guide][Code] [JAR][User Guide][Code]
    JeremiasLiew [JAR][User Guide][Code] [JAR][User Guide][Code]
    Jeremy733 [JAR][User Guide][Code] [JAR][User Guide][Code]
    JosephLimWeiJie [JAR][User Guide][Code] [JAR][User Guide][Code]
    JustinnT [JAR][User Guide][Code] [JAR][User Guide][Code]
    Keith-JK [JAR][User Guide][Code] [JAR][User Guide][Code]
    MeLoveCarbs [JAR][User Guide][Code] [JAR][User Guide][Code]
    NizarMohd [JAR][User Guide][Code] [JAR][User Guide][Code]
    NyanWunPaing [JAR][User Guide][Code] [JAR][User Guide][Code]
    RenzoTsai [JAR][User Guide][Code] [JAR][User Guide][Code]
    Shannonwje [JAR][User Guide][Code] [JAR][User Guide][Code]
    SibingWu [JAR][User Guide][Code] [JAR][User Guide][Code]
    Yukilite [JAR][User Guide][Code] [JAR][User Guide][Code]
    Zhilin-Huang [JAR][User Guide][Code] [JAR][User Guide][Code]
    alaukiknpant [JAR][User Guide][Code] [JAR][User Guide][Code]
    alexlim510 [JAR][User Guide][Code] [JAR][User Guide][Code]
    alwayshuizhen [JAR][User Guide][Code] [JAR][User Guide][Code]
    ananda-lye [JAR][User Guide][Code] [JAR][User Guide][Code]
    andy-aw-why [JAR][User Guide][Code] [JAR][User Guide][Code]
    anqi-nus [JAR][User Guide][Code] [JAR][User Guide][Code]
    benchan911 [JAR][User Guide][Code] [JAR][User Guide][Code]
    bennychanya [JAR][User Guide][Code] [JAR][User Guide][Code]
    brandoncjh [JAR][User Guide][Code] [JAR][User Guide][Code]
    btricec [JAR][User Guide][Code] [JAR][User Guide][Code]
    chengTzeNing [JAR][User Guide][Code] [JAR][User Guide][Code]
    cheongisabella [JAR][User Guide][Code] [JAR][User Guide][Code]
    dejunnn [JAR][User Guide][Code] [JAR][User Guide][Code]
    g-lilian [JAR][User Guide][Code] [JAR][User Guide][Code]
    gmuthu17 [JAR][User Guide][Code] [JAR][User Guide][Code]
    harithadiv [JAR][User Guide][Code] [JAR][User Guide][Code]
    hongquan448 [JAR][User Guide][Code] [JAR][User Guide][Code]
    iceclementi [JAR][User Guide][Code] [JAR][User Guide][Code]
    itskesin [JAR][User Guide][Code] [JAR][User Guide][Code]
    jiajuinphoon [JAR][User Guide][Code] [JAR][User Guide][Code]
    jichngan [JAR][User Guide][Code] [JAR][User Guide][Code]
    jinfayap [JAR][User Guide][Code] [JAR][User Guide][Code]
    joelczk [JAR][User Guide][Code] [JAR][User Guide][Code]
    katelo731 [JAR][User Guide][Code] [JAR][User Guide][Code]
    kcubey [JAR][User Guide][Code] [JAR][User Guide][Code]
    kokjoon97 [JAR][User Guide][Code] [JAR][User Guide][Code]
    lamyuewei [JAR][User Guide][Code] [JAR][User Guide][Code]
    lowjiayee [JAR][User Guide][Code] [JAR][User Guide][Code]
    lowxizhi [JAR][User Guide][Code] [JAR][User Guide][Code]
    lwxymere [JAR][User Guide][Code] [JAR][User Guide][Code]
    matthewc97 [JAR][User Guide][Code] [JAR][User Guide][Code]
    melylopez99 [JAR][User Guide][Code] [JAR][User Guide][Code]
    nguan1 [JAR][User Guide][Code] [JAR][User Guide][Code]
    nigellenl [JAR][User Guide][Code] [JAR][User Guide][Code]
    quinnyyy [JAR][User Guide][Code] [JAR][User Guide][Code]
    rdimaio [JAR][User Guide][Code] [JAR][User Guide][Code]
    rsanchez-macias [JAR][User Guide][Code] [JAR][User Guide][Code]
    sitinadiah25 [JAR][User Guide][Code] [JAR][User Guide][Code]
    siuhian [JAR][User Guide][Code] [JAR][User Guide][Code]
    sliu107 [JAR][User Guide][Code] [JAR][User Guide][Code]
    synCKun [JAR][User Guide][Code] [JAR][User Guide][Code]
    terrytay [JAR][User Guide][Code] [JAR][User Guide][Code]
    thanhduc2000 [JAR][User Guide][Code] [JAR][User Guide][Code]
    trishaangelica [JAR][User Guide][Code] [JAR][User Guide][Code]
    wangqinNick [JAR][User Guide][Code] [JAR][User Guide][Code]
    yantingsanity [JAR][User Guide][Code] [JAR][User Guide][Code]
    yuxianglim [JAR][User Guide][Code] [JAR][User Guide][Code]
    zi-hui [JAR][User Guide][Code] [JAR][User Guide][Code]

    1. Find out which iPs are allocated for your evaluation from the panel above.
    2. Download the JAR file of the first iP by following the link provided.
    3. Locate the User Guide of the app by following the link provided.
    4. Open the LumiNUS survey (the one named iP Peer Evaluation 1) that you will be using to submit your evaluation and take note of the things you need to evaluate.
    5. Do a light testing of the app (not more than 10 minutes) to ensure the claimed features actually exist.
      If double-clicking the jar file doesn't work, use the java -jar {file_name} command to open it.
      Make sure you are using Java 11 to run the jar file (use java -version command to confirm).
    6. Do a quick examination of the code (~ 5 minutes) by following the provided link.
    7. Submit your evaluation using the survey.
    8. Repeat the above steps for the 2nd iP allocated to you (use the survey iP Peer Evaluation 2).


    tP: mid-v1.0

    1 Ensure you know tP expectations

    • If you haven't done so already, make sure you know individual and team expectations of the tP

    Functionality Expectations

    The expected level of functionality from a team is roughly what you can achieve if each member contribute about the same amount of functional code as required by a i.e., if all requirements were met at the minimal level specifiedtypical iP.

    Note that we have reduced the tP functionality expectations for this semester by about 40-50% compared to the previous semester, in order to reduce your workload. Adding more functionality than the expected level will not increase your marks. You are better off spending that effort in improving other aspects of the project. In fact, here is the grading criterion for the individual project effort:

    Q [For each member] The functional code contributed by the person is,
    Consider implementation work only (i.e., exclude testing, documentation, project management etc.)
    The typical iP refers to an iP where all the requirements are met at the minimal expectations given.
    Use the person's PPP and RepoSense page to evaluate the effort.

    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: at least 1 page
      • DG: at least 1 page
    • 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 some of the UML diagrams in your DG updates i.e., diagrams you added yourself or those you modified significantly.

    Individual Expectations on Testing

    • Expectation Write some automated tests so that we can evaluate your ability to write tests.

    🤔 How much testings is enough? We expect you to decide. You learned different types of testing and what they try to achieve. Based on that, you should decide how much of each type is required. Similarly, you can decide to what extent you want to automate tests, depending on the benefits and the effort required.
    There is no requirement for a minimum coverage level. Note that in a production environment you are often required to have at least 90% of the code covered by tests. In this project, it can be less. The weaker your tests are, the higher the risk of bugs, which will cost marks if not fixed before the final submission.

    Individual Expectations on Teamwork

    • Expectation Do a fair share of the team-tasks.

    Team-tasks are the tasks that someone in the team has to do. Marks allocated to team-tasks will be divided among team members based on how much each member contributed to those tasks.

    Here is a non-exhaustive list of team-tasks:

    1. Necessary general code enhancements
    2. Setting up tools e.g., GitHub, Gradle
    3. Maintaining the issue tracker
    4. Release management
    5. Updating user/developer docs that are not specific to a feature e.g. documenting the target user profile
    6. Incorporating more useful tools/libraries/frameworks into the product or the project workflow (e.g. automate more aspects of the project workflow using a GitHub plugin)

    • Expectation Assume a fair share of project roles and responsibilities.

    Roles indicate aspects you are in charge of and responsible for. E.g., if you are in charge of documentation, you are the person who should allocate which parts of the documentation is to be done by who, ensure the document is in right format, ensure consistency etc.

    This is a non-exhaustive list; you may define additional roles.

    • Team lead: Responsible for overall project coordination.
    • Documentation (short for ‘in charge of documentation’): Responsible for the quality of various project documents.
    • Testing: Ensures the testing of the project is done properly and on time.
    • Code quality: Looks after code quality, ensures adherence to coding standards, etc.
    • Deliverables and deadlines: Ensure project deliverables are done on time and in the right format.
    • Integration: In charge of versioning of the code, maintaining the code repository, integrating various parts of the software to create a whole.
    • Scheduling and tracking: In charge of defining, assigning, and tracking project tasks.
    • [Tool ABC] expert: e.g. Intellij expert, Git expert, etc. Helps other team member with matters related to the specific tool.
    • In charge of[Area XYZ] of the code: e.g. In charge of the code that deals with storage, etc. If you are in charge of an area, you are expected to know that area well, and review changes done to that code.

    Ensure each of the important roles are assigned to one person in the team. It is OK to have a 'backup' for each role, but for each aspect there should be one person who is unequivocally the person responsible for it. Reason: when everyone is responsible for everything, no one is.
    • 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.

    2 Start implementing v1.0

    You may i.e., copy-paste, not clone/forkre-purpose/adopt code from any of the below to be used in your tP, provided you give credit to the source (and do not claim such code as yours).

    • The iP code of any of your team members, or of any other person in the module.
    • Code from AddressBook-Level2 or any code used in module activities e.g., personbook

    • Start implementing v1.0, by adding code in small steps, while working in parallel.

    • As you are expected to follow breadth-first iterative approach, almost all code additions to the master branch should take the product from a working version to a slightly better working version.

      • Bad Let's add all data classes first reason: this is the depth-first approach
      • Bad Let's finish the part of the code that saves and loads data first reason: this is the depth-first approach
      • Good Let's add code to support simple todo tasks first (i.e., read, delete, save, load)

    • Recommended approach for planning the next week of the tP:

      • First, decide how the product will look in one week. It can be really simple, but should be functional.
      • Then, decide what implementation work needs to be done to get there.
      • Divide up that work among yourselves and start doing those work items using the forking workflow.

    • See the panel below for our recommendations on the project workflow.

    Workflow

    Read our reuse policy (in Admin: Appendix B), in particular, how to give credit when you reuse code from the Internet or classmates:

     

    Set Git user.name: We use various tools to analyze your code. For us to be able to identify your commits, we encourage you to set your Git user.name in all computers you use to a sensible string that uniquely identifies you. For example, you can set it to your GitHub username or your full name. If this user name is not set properly or if you use multiple user names for Git, our tools might miss some of your work and as a result you might not get credit for some of your work.

    After installing Git in a computer, you can set the Git username as follows:

    1. Open a command window that can run Git commands (e.g., Git bash window)
    2. Run the command git config --global user.name YOUR_GITHUB_USERNAME (omit the --global flag to limit the setting to the current repo only)
      e.g., git config --global user.name JohnDoe

    More info about setting Git username is here.

      

    Policy on reuse

    Reuse is encouraged. However, note that reuse has its own costs (such as the learning curve, additional complexity, usage restrictions, and unknown bugs). Furthermore, you will not be given credit for work done by others. Rather, you will be given credit for reusing work done by others.

    • You are allowed to reuse work from your classmates, subject to following conditions:
      • The work has been shared publicly by us or the authors.
      • You clearly give credit to the original author(s).
    • You are allowed to reuse work from external sources, subject to following conditions:
      • The work comes from a source of 'good standing' (such as an established open source project). This means you cannot reuse code written by an outside 'friend'.
      • You clearly give credit to the original author. Acknowledge use of third party resources clearly e.g. in the welcome message, splash screen (if any) or under the 'about' menu. If you are open about reuse, you are less likely to get into trouble if you unintentionally reused something copyrighted.
      • You do not violate the license under which the work has been released. Please  do not use 3rd-party images/audio in your software unless they have been specifically released to be used freely. Just because you found it in the Internet does not mean it is free for reuse.
      • Always get permission from us before you reuse third-party libraries. Please post your 'request to use 3rd party library' in our forum. That way, the whole class get to see what libraries are being used by others.

    Giving credit for reused work

    Given below are how to give credit for things you reuse from elsewhere. These requirements are specific to this module i.e., not applicable outside the module (outside the module you should follow the rules specified by your employer and the license of the reused work)

    If you used a third party library:

    • iP/tP: Mention in the README file (under the Acknowledgements section)
    • tP: Mention in the Project Portfolio Page if the library has a significant relevance to the features you implemented

    If you reused code snippets found on the Internet e.g. from StackOverflow answers or
    referred code in another software or
    referred project code by current/past student:

    • If you read the code to understand the approach and implemented it yourself, mention it as a comment
      Example: 
      //Solution below adapted from https://stackoverflow.com/a/16252290
      {Your implmentation of the reused solution here ...}
    • If you copy-pasted a non-trivial code block (possibly with minor modifications renaming, layout changes, changes to comments, etc.), also mark the code block as reused code (using @@author tags)
      Format: 
      //@@author {yourGithubUsername}-reused
      //{Info about the source...}

      {Reused code (possibly with minor modifications) here ...}

      //@@author
      Example of reusing a code snippet (with minor modifications): 
      persons = getList()
      //@@author johndoe-reused
      //Reused from https://stackoverflow.com/a/34646172 with minor modifications
      Collections.sort(persons, new Comparator<CustomData>() {
          @Override
          public int compare(CustomData lhs, CustomData rhs) {
              return lhs.customInt > rhs.customInt ? -1 : 0;
          }
      });
      //@@author
      return persons;
      

    Adding @@author tags indicate authorship

    • Mark your code with a //@@author {yourGithubUsername}. Note the double @.
      The //@@author tag should indicates the beginning of the code you wrote. The code up to the next //@@author tag or the end of the file (whichever comes first) will be considered as was written by that author. Here is a sample code file:

      //@@author johndoe
      method 1 ...
      method 2 ...
      //@@author sarahkhoo
      method 3 ...
      //@@author johndoe
      method 4 ...

    • If you don't know who wrote the code segment below yours, you may put an empty //@@author (i.e. no GitHub username) to indicate the end of the code segment you wrote. The author of code below yours can add the GitHub username to the empty tag later. Here is a sample code with an empty author tag:

      method 0 ...
      //@@author johndoe
      method 1 ...
      method 2 ...
      //@@author
      method 3 ...
      method 4 ...

    • The author tag syntax varies based on file type e.g. for java, css, fxml. Use the corresponding comment syntax for non-Java files.
      Here is an example code from an xml/fxml file.

      <!-- @@author sereneWong -->
      <textbox>
        <label>...</label>
        <input>...</input>
      </textbox>
      ...

    • Do not put the //@@author inside java header comments.
      👎

      /**
        * Returns true if ...
        * @@author johndoe
        */

      👍

      //@@author johndoe
      /**
        * Returns true if ...
        */

    What to and what not to annotate

    • Annotate both functional and test code There is no need to annotate documentation files.

    • Annotate only significant size code blocks that can be reviewed on its own e.g., a class, a sequence of methods, a method.
      Claiming credit for code blocks smaller than a method is discouraged but allowed. If you do, do it sparingly and only claim meaningful blocks of code such as a block of statements, a loop, or an if-else statement.

      • If an enhancement required you to do tiny changes in many places, there is no need to annotate all those tiny changes; you can describe those changes in the Project Portfolio page instead.
      • If a code block was touched by more than one person, either let the person who wrote most of it (e.g. more than 80%) take credit for the entire block, or leave it as 'unclaimed' (i.e., no author tags).
      • Related to the above point, if you claim a code block as your own, more than 80% of the code in that block should have been written by yourself. For example, no more than 20% of it can be code you reused from somewhere.
      • GitHub has a blame feature and a history feature that can help you determine who wrote a piece of code.

    • Do not try to boost the quantity of your contribution using unethical means such as duplicating the same code in multiple places. In particular, do not copy-paste test cases to create redundant tests. Even repetitive code blocks within test methods should be extracted out as utility methods to reduce code duplication. Individual members are responsible for making sure code attributed to them are correct. If you notice a team member claiming credit for code that he/she did not write or use other questionable tactics, you can email us (after the final submission) to let us know.

    • If you wrote a significant amount of code that was not used in the final product,

      • Create a folder called {project root}/unused
      • Move unused files (or copies of files containing unused code) to that folder
      • use //@@author {yourGithubUsername}-unused to mark unused code in those files (note the suffix unused) e.g.
      //@@author johndoe-unused
      method 1 ...
      method 2 ...

      Please put a comment in the code to explain why it was not used.

    • If you reused code from elsewhere, mark such code as //@@author {yourGithubUsername}-reused (note the suffix reused) e.g.

      //@@author johndoe-reused
      method 1 ...
      method 2 ...

    • You can use empty @@author tags to mark code as not yours when RepoSense attribute the to you incorrectly.

      • Code generated by the IDE/framework, should not be annotated as your own.

      • Code you modified in minor ways e.g. adding a parameter. These should not be claimed as yours but you can mention these additional contributions in the Project Portfolio page if you want to claim credit for them.

      

    At the end of the project each student is required to submit a Project Portfolio Page.

    PPP Objectives

    • For you to use (e.g. in your resume) as a well-documented data point of your SE experience
    • For evaluators to use as a data point to evaluate your project contributions

    PPP Sections to include

    • Overview: A short overview of your product to provide some context to the reader. The opening 1-2 sentences may be reused by all team members. If your product overview extends beyond 1-2 sentences, the remainder should be written by yourself.
    • Summary of Contributions --Suggested items to include:
      • Code contributed: Give a link to your code on tP Code Dashboard. The link is available in the Project List Page -- linked to the icon under your photo.
      • Enhancements implemented: A summary of the enhancements you implemented.
      • Contributions to documentation: Which sections did you contribute to the UG?
      • Contributions to the DG: Which sections did you contribute to the DG? Which UML diagrams did you add/updated?
      • Contributions to team-based tasks :
      • Review/mentoring contributions: Links to PRs reviewed, instances of helping team members in other ways
      • Contributions beyond the project team:
        • Evidence of helping others e.g. responses you posted in our forum, bugs you reported in other team's products,
        • Evidence of technical leadership e.g. sharing useful information in the forum

    Team-tasks are the tasks that someone in the team has to do. Marks allocated to team-tasks will be divided among team members based on how much each member contributed to those tasks.

    Here is a non-exhaustive list of team-tasks:

    1. Necessary general code enhancements
    2. Setting up tools e.g., GitHub, Gradle
    3. Maintaining the issue tracker
    4. Release management
    5. Updating user/developer docs that are not specific to a feature e.g. documenting the target user profile
    6. Incorporating more useful tools/libraries/frameworks into the product or the project workflow (e.g. automate more aspects of the project workflow using a GitHub plugin)

    Keep in mind that evaluators will use the PPP to estimate your project effort. We recommend that you mention things that will earn you a fair score e.g., explain how deep the enhancement is, why it is complete, how hard it was to implement etc..

    • [Optional] Contributions to the User Guide (Extracts): Reproduce the parts in the User Guide that you wrote. This can include features you implemented as well as features you propose to implement.
      The purpose of allowing you to include proposed features is to provide you more flexibility to show your documentation skills. e.g. you can bring in a proposed feature just to give you an opportunity to use a UML diagram type not used by the actual features.

    • [Optional] Contributions to the Developer Guide (Extracts): Reproduce the parts in the Developer Guide that you wrote. Ensure there is enough content to evaluate your technical documentation skills and UML modelling skills. You can include descriptions of your design/implementations, possible alternatives, pros and cons of alternatives, etc.

    • [Optional] If you plan to use the PPP in your Resume, you can also include your SE work outside of the module (will not be graded).

    PPP Format

    • To convert the UG/DG/PPP into PDF format, go to the generated page in your project's github.io site and use this technique to save as a pdf file. Using other techniques can result in poor quality resolution (will be considered a bug) and unnecessarily large files. You may un-tick the background graphics option as well if you wish.

    Saving as PDF files

    1. Use Chrome to load the page you want to save as pdf.

    2. Click on the Print option in Chrome’s menu.

    3. Set the destination to Save as PDF, then click Save to save a copy of the file in PDF format. For best results, use the settings indicated in the screenshot below.

    • Ensure hyperlinks in the pdf files work. Your UG/DG/PPP will be evaluated using PDF files during the PE. Broken/non-working hyperlinks in the PDF files will be reported as bugs and will count against your project score. Again, use the conversion technique given above to ensure links in the PDF files work.

    PPP Page Limit

    Content Recommended Hard Limit
    Overview + Summary of contributions 0.5-1 2
    [Optional] Contributions to the User Guide 1-3
    [Optional] Contributions to the Developer Guide 3-6
    • The page limits given above are after converting to PDF format. The actual amount of content you require is actually less than what these numbers suggest because the HTML → PDF conversion adds a lot of spacing around content.

    We recommend the forking workflow for your project. In particular,

    • Protect the master branch: You can use GitHub's Protected Branches feature to protect your master branch against rogue PRs. We suggest the following:
      • Go the the settings of your team repo.
      • Click on the Branches option on the navigation menu on the left.
      • Click the button. In the Branch protection rule page,
        • Specify the Branch name pattern to be master
        • Tick the option Require status checks to pass before merging to ensure that code has to pass CI before then can be merged to the master branch
        • If you think all PRs should be reviewed before they are merged, also tick the Require pull request reviews before merging option.
    • Create issues to represent project tasks so that they can be tracked using the issue tracker features.
    • Create a PR when you implement a project task that updates the code.
      You can use GitHub's draft PRs feature to indicate that a PR is not yet ready for merging.
      PRO TIP LGTM is common abbreviation you can use in the review comments to mean Looks Good To Merge.
    • Get team members to review PRs. A workflow without PR reviews is a risky workflow.
    • Don't merge code that fails CI. Ensure the PRs you merge have CI before you merge them. If your CI breaks, a will show up in your team PR here (the shame!).
    • After merging a PR, close the corresponding issue.
      PRO TIP You can use GitHub's Fixes #123 trick to get the issue to close automatically when the PR is merged.
    • As you add functionality, update the input.txt and EXPECTED.txt as well so that the functionality you add gets regression tested automatically every time the code is updated from that point onwards.
     

    Project Management → Revision Control →

    Forking flow

    In the forking workflow, the 'official' version of the software is kept in a remote repo designated as the 'main repo'. All team members fork the main repo create pull requests from their fork to the main repo.

    To illustrate how the workflow goes, let’s assume Jean wants to fix a bug in the code. Here are the steps:

    1. Jean creates a separate branch in her local repo and fixes the bug in that branch.
    2. Jean pushes the branch to her fork.
    3. Jean creates a pull request from that branch in her fork to the main repo.
    4. Other members review Jean’s pull request.
    5. If reviewers suggested any changes, Jean updates the PR accordingly.
    6. When reviewers are satisfied with the PR, one of the members (usually the team lead or a designated 'maintainer' of the main repo) merges the PR, which brings Jean’s code to the main repo.
    7. Other members, realizing there is new code in the upstream repo, sync their forks with the new upstream repo (i.e. the main repo). This is done by pulling the new code to their own local repo and pushing the updated code to their own fork.

    You can reduce process rigor to suit your team's pace, after following the above workflow for a while. For example, you can switch to a lighter workflow: While forking workflow is the safest, it is also rather heavy. You can switch to a simpler workflow if the forking workflow is slowing you down. Refer the textbook to find more about alternative workflows: branching workflow, centralized workflow. However, we still recommend that you use PR reviews, at least for PRs affecting others' features.

     
    • Expectation Write some automated tests so that we can evaluate your ability to write tests.

    🤔 How much testings is enough? We expect you to decide. You learned different types of testing and what they try to achieve. Based on that, you should decide how much of each type is required. Similarly, you can decide to what extent you want to automate tests, depending on the benefits and the effort required.
    There is no requirement for a minimum coverage level. Note that in a production environment you are often required to have at least 90% of the code covered by tests. In this project, it can be less. The weaker your tests are, the higher the risk of bugs, which will cost marks if not fixed before the final submission.

    3 Use GitHub to manage milestones

    • We recommend using the GitHub issue tracker and its milestones feature to manage your project milestones, as explained in the following panels.

    Issue Tracker Setup

    We recommend you configure the issue tracker of the tP 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.

    Issue type labels:

    • type.Epic : A big feature which can be broken down into smaller stories e.g. search
    • type.Story : A user story
    • type.Enhancement: An enhancement to an existing story
    • type.Task (or type.Chore) : Something that needs to be done, but not a story, bug, or an epic. e.g. Move testing code into a new folder)
    • type.Bug : A bug

    Bug Severity labels:

    • severity.VeryLow : A flaw that is purely cosmetic and does not affect usage e.g., a typo/spacing/layout/color/font issues in the docs or the UI that doesn't affect usage.
    • severity.Low : A flaw that is unlikely to affect normal operations of the product. Appears only in very rare situations and causes a minor inconvenience only.
    • severity.Medium : A flaw that causes occasional inconvenience to some users but they can continue to use the product.
    • severity.High : A flaw that affects most users and causes major problems for users. i.e., makes the product almost unusable for most users.

    • Create following milestones : v1.0, v2.0, v2.1

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

    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. Title: As a user I can add a deadline
      Description: ... so that I can keep track of my deadlines

    • Assign the type.* 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.e.g.

      • A typical task should be able to done by one person, in a few hours.

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

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

    Using Milestones:

    Given below are the conditions to satisfy for a milestone to be considered properly managed:

    Planning a Milestone:

    • Issues assigned to the milestone, team members assigned to issues: Used GitHub milestones to indicate which issues are to be handled for which milestone by assigning issues to suitable milestones. Ensured issues are assigned to team members. Note that you can change the milestone plan along the way as necessary.

    • Deadline set for the milestones (in the GitHub milestone). Your internal milestones can be set earlier than the deadlines we have set, to give you a buffer.

    Wrapping up a Milestone:

    • A working product tagged with the correct tag (e.g. v2.0) and is pushed to the main repo
      or a product release done on GitHub.

    • All tests passing on Travis for the version tagged/released.

    • Milestone updated to match the product i.e. all issues completed and PRs merged for the milestone should be assigned to the milestone. Incomplete issues/PRs should be moved to a future milestone.

    • Milestone closed.

    • If necessary, future milestones are revised based on what you experienced in the current milestone e.g. if you could not finish all issues assigned to the current milestone, it is a sign that you overestimated how much you can do in a week, which means you might want to reduce the issues assigned to future milestones to match that observation.

    4 Add some JUnit Tests