Previous
¶ Scrum Activities
¶ What it is
As a software product development strategy, Scrum organises the production team to reach a common goal. The main ways to get the goal are the scrum activities.
During production, not only developers are involved in scrum activities, but also designers, testers, project sponsors, product owners, etc.
¶ Why it is useful
Scrum activities are essential to make the project Information transparent, align the periodical goal set for a fixed length (sprint), and adjust the goals in the following steps quickly according to the changing situation.
¶ When to use
During the whole project lifecycle
¶ How is it done
The five most common Scrum activities are
- Sprint Planning.
- Daily Scrum.
- Sprint Review.
- Sprint Retrospective.
- The Sprint.
Let’s introduce some other useful Scrum activities:
1. Design review
- Design Dev Review: The dev team to check the design feasibility and confirm the logic closed-loop and user experience
- Design client review: Clients or businesses to verify and sign off the design before the development team starts implementation
2. Dependency resolving
To analyse and resolve the project dependencies regularly to plan for and prevent risks
3. Backlog refinement
Review and adjust the backlog according to the actual status of the project and the product.
4. Test case review
Align with PO, design team, and development team on the expectations of variants of user scenarios.
5. Tech design review
When a technical design is needed during development, it is a must to have a formal review with the technical team.
6. Design QA
The design team performs QA tasks on the implemented product to inspect it from the design perspective.
7. User Acceptance Testing
After the production team completes all the development and the internal testing, the internal or external team to finally signs off on the product is responsible for doing the UAT to verify that the product is completed as designed.
8. Project handover
With the sign-off supported by the UAT activities, the project assets and codes should be well managed and handed over to the right teams. A product manual should also be created if necessary.
¶ Do's & Don't
Do's
- Send out the agenda and topics for each meeting beforehand so that every attendee knows their part to play and prepare. This guarantees the meeting efficiency.
- Strictly control the meeting duration and remind everyone about the meeting’s purpose whenever needed.
- Summarise the meeting, and action items, assign them to the right persons, and make the follow-up plan.
Don't
- Don’t do scrum for scrum, but understand its nature and principle to use it as the tool to help coordinate.
-
Don’t take chances to skip some must-do regular activities for the sake of
time, e.g., The following cannot be skipped no matter how.
- Sprint planning(user story review, dependency checking)
- Design review (both dev review and client review)
- Test case review
- User acceptance testing
- Sprint review
- Project handover
¶ Tools needed
- Jira
- Trello
- ActiveCollab
- ClickUp
- easyBacklog
- Infinity
- MeisterTask
- Nutcache
- OrangeScrum
- ScrumDo
- Scrumwise
- Zoho Sprints
¶ Example
¶ GenAI Tool Use Case
¶ Writing Code with the Assistance of GitHub Copilot
GitHub Copilot is an AI-powered code completion tool that helps programmers by suggesting whole lines or blocks of code as they type.
Key Workflows:
- Get code suggestion
- Optimize the code continuously
- Make the code able to handle the dates that contain time components.
- I want both "%Y-%m-%d" and "%Y-%m-%d %H:%M:%S" supported.
- You assume two dates would follow the same format, but maybe that's not the case.
- Generate the documentation
- Select the code and click the context menu Copilot -> Start Inline Chat (or simply use the Ctrl+I shortcut on Windows).
- Type the slash command “/doc”, and the documentation will appear right below the function name.
Write some comments and wait for the suggestion, or directly type your request in the Copilot Chat window.
When you make a conversation in the Copilot Chat window, it will show you a detailed explanation of the code.
In the example, a prompt “create a function that calculates the difference of two dates” is sent, and a working code snippet is returned.
The code suggestion returned from Copilot may not exactly meet the requirement. You could keep talking with it continuously just like in ChatGPT, to make the code more closely meet your requirements.
The conversations sent in the examples are as follows:
In the end, the code it suggests is a bit more robust than the first version.
Besides the code suggestion, GitHub Copilot is able to suggest the documentation as well. This could be done in the Copilot Chat window, by selecting the relevant code and typing “generate docs”.
Another way is to use the Inline Chat feature,
¶ Debugging with GitHub Copilot
GitHub Copilot can generate the code suggestion for you. In addition, the power of LLM enables it to understand the error message, which makes it a proper tool for the debugging as well.
Example:
- The problem
- Fix it via GitHub Copilot Chat
- Optimize the output
The screenshot on the right shows a simple code of a CLI program that asks the user to input two numbers and then calculate their division. It is not that robust so when non-numeric text is provided, it shows error immediately.
Open Copilot Chat, and send the error message with a bit more context:
When I input 'd', it shows error as follows:
{{ Error message goes here }}
fix it
Then Copilot Chat would return the explanation along with the updated code. Verify the code after replacing it and it may surprise you.
The conversation in the same chat window would be considered as in a single context. Type more messages to get a better output. E.g. “Make sure the divisor is not zero”.
¶ Writing Unit Test with AI Assistant
GitHub Copilot is not just a tool to assist developers by autocompleting general code. It can help to suggest the unit testing code as well.
Tip & Tricks:
- How to generate the unit tests
- Option 1: Select the code and directly click “Generate tests” in the Copilot context menu.
- Option 2: Open the GitHub Copilot Chat side window, select the code and simply type “Write unit tests”.
- Always verify the code
- Sometimes it may suggest irrelevant code or even lead to syntax errors. So make sure the code is verified before production.
- Handle edge cases properly
- Due to a lack of context and user behaviour, the edge cases may not be fully covered by what GitHub Copilot suggests. So it’s the developer’s responsibility to ensure the edge cases are handled properly.
Read more:
Write Tests using GitHub Copilot Chat
Other Inspirational Tool:
¶ GitHub Copilot Workspace Feature Intro
In December 2023, new workspace and context commands were introduced in GitHub Copilot, so it can better understand your codebase by allowing Copilot to go through your entire project.
Example:
- Create a new workspace
- Explain the workspace
- Add a feature
- Git commit and create pull requests
- Provide Detailed Scenario Descriptions
- Clearly State Expected Outcomes
- Specify Edge Cases and Exceptions
- Iterate and Refine
- Provide the designers with the right ways and environments to log in and test.
- Explicitly announce what is testable and what is not, which is to make sure the designers are not focusing on the elements not ready for testing (usually, this can be done with a good task management system).
- Make sure the designers know what to do when things are right or wrong (E.g. Ticket passed -> Go to ‘DONE’ status; Ticket failed -> Create bug reports).
- If needed, borrow the test data from your QA team for the designers so they can carry out their design QA work efficiently.
- Do design QA on both UI and UX.
- Do design QA in a reasonable frequency, as depending on the project goal, the requirements level on the quality of UI/UX may vary.
- Properly define the priorities of the issues found by design QA activities. For example, the severity should be low if it’s a minor UI issue.
- Make sure the elements are massively tested by QA engineers before you ask your designers to start design QA.
- When you find the designers are reporting a number of similar UI issues, ask them to stop reporting duplicates first. Then tell the frontend developers to fix the relevant UI style components before the designers start the next round QA.
- Don’t be too sturbon on what have been designed - sometime you have to negotiate and do trade-offs between design and technology.
- Don’t start design QA too early - For example, you start design QA when the system isn’t stable enough to render your screens. There definitely will have a bunch of UI issues.
- Don’t assume that designers may only find UI issues. But I hope you won’t receive any UX or even logical issues raised by the designers. Because that may take longer than a UI issue to be fixed.
- Any issue tracking systems
The @workspace command can be used with /new, followed by the concrete requirements to create a new workspace.
In the example, a prompt “@workspace /new scaffold a react website” is sent, and a project directory structure is proposed. If you are good with it, click the “Create Workspace” button to really perform the action.
In the previous version of Copilot, you could ask it to explain a function or code snippet. And now it has evolved a bit.
In Copilot Chat, send the prompt “@workspace explain current project”. Copilot would analyze your workspace and give you a detailed explanation.
In the example, you could find out that Copilot understands the workspace is a React application project, and give a detailed description of each file.
By prefixing the @workspace command, we don’t need to explicitly mention the file. While Copilot might be able to figure out the context.
In the example, we send a prompt “@workspace add a google login button in the main page”. Copilot would suggest you install the required package first and is smart enough to suggest you put the code snippet in App.js, which is indeed the main page of the project.
You can find the new Copilot button (a sparkle icon) in many places, including the commit message input, the PR message input, and even in the embedded terminal. By clicking it, the relevant suggestions would be generated accordingly, and save you some time from the tedious work.
In the example, we leverage the Copilot button to generate the commit message and the PR description for us.
¶ GenAI Tool Use Case
¶ Writing Test Cases
ChatGPT isn't merely a tool for generating text; it also aids in creating detailed test cases, enhancing the testing process beyond basic scenario creation.
Tip & Tricks:
ChatGPT generates test cases based on the details you provide. To create more accurate and comprehensive test cases, describe the scenario or feature in clear, specific terms. This helps the AI understand your requirements and tailor the test cases accordingly.
Include expected outcomes or behaviours in your descriptions. This guides ChatGPT in generating test cases that not only test functionality but also verify that the outcomes align with your objectives.
Mention any known edge cases, exceptions, or unusual conditions in your request. This prompts ChatGPT to consider these scenarios when generating test cases, ensuring a more thorough testing process.
Provide feedback and refine iteratively for more accurate test cases.
Read More:
Using ChatGPT to Write Manual Testing Scenarios
¶ Design QA
¶ What it is
Design QA is the audit activity carried out by designers on the developed software.
¶ Why it is useful
Design QA is required in order to deliver high-quality software and make sure it is aligned to the original design to the most extent - even a pixel. That can convey the best effect of the design.
¶ When to use
Usually at the polish stage of a product development process, when the product is relatively stable in the aspect of functionality, but before the client reviews and performs the acceptance test.
It can be once a sprint (when the system and features are stable enough), or twice, which varies depending on project needs.
¶ Whom to perform
The designers who designed the UI/UX.
¶ How is it done
¶ Do's & Don't
Do's
Don't