In agile development, every user story should have clearly defined completion and acceptance criteria. There are two important parts of defining completion criteria, one is functional and the other is non-functional. In most cases, we define the functional acceptance criteria very well, but do not pay much attention to non-functional completeness checks.
In order to ensure comprehensive software quality, we should make a comprehensive acceptance of both standards. In agile development, you need to define the checklist and ensure that all user stories follow it.
This requires a lot of discipline, and it is not easy to implement. Achieving consistently high software quality requires dedication and strict discipline from the team.
In order to obtain the ideal software quality and results every time, we must honestly follow these processes and continue to trace and improve.
In order to allow our software process to achieve completeness check. I have developed a list of best practices for following user stories, as follows:
1. Requirements analysis-complete acceptance criteria
2. Technical design and review
3. Code review
4. Cross-domain code review-cache, transaction, security
5. Database design and review
6. Performance appraisal
7. Security review-XSS verification
8. Initialize/upgrade data script
9. Accessibility check
10. Browser compatibility test
11. Update of internal version number
I personally like to incorporate these checklists into development practices. People follow them strictly to make the work neater. To ensure that they are followed, two methods are recommended:
1. Create these as tasks for each user story
2. Create a checklist document and sign it from the user story owner
We follow two practices. Some basic ones, such as comments, are created as part of the task list of the user story. In this way, the owner of the user story must complete these tasks. As part of the user story, only by completing these tasks can the new story be accepted.
Although it sounds like a lot of tasks for each user story, a useful checklist can ensure the quality of each user story.
The advantages of this complete checklist are:
1. Code quality
2. Design review
Ensure code quality through reasonable design through each user story. In agile development, necessary documents are also needed. In fact, there is no need to create very detailed low-level design documents. It may be a brainstorming whiteboard design captured and uploaded to user stories. This is achieved through the design review checklist in our process. We have to design incrementally for each user story and make sure to create fast charts for them. Each user story in the sprint will contain design review tasks.
This checklist will ensure attention to the incremental design of each user story, and ultimately ensure a complete version.
Code review
In order to improve the code quality, it is very important to conduct a technical group code review for each user story. During the review, the following items need to be verified:
1. Coding standards
2. Security Best Practices
3. The design is implemented according to the initial design
4. All business rules meet the acceptance criteria.
5. Write appropriate test cases according to the code
There are many advantages to conducting a group code review. The quality of the code is effectively improved. From the senior to the junior developers in the team, they have obtained different views/ideas. Professional domain knowledge and technical knowledge are cross-spread among team members. If the team is doing product development, this is a very important process, it helps to share domain knowledge across teams.
QA verifies their white box test cases based on the written code.
No technical debt
Verify some cross-cutting issues during the code review process, such as caching, security, and transactions.
Database review
1. Database structure
2. Best practices for writing SQL stored procedures
3. Initialization/upgrade script
While carrying out software development, we must also pay attention to data. The data initially in the table is called the initial data script. If the function is already in the production environment, and the new function needs to change the data, you need to upgrade the data script.
If we do not pay attention to these during the development and testing process, we are likely to produce new unexpected tasks, in addition to being caught off guard, and especially prone to errors.
All our test environments should be the same as the production deployment process and environment, and these initial/upgrade data scripts should also be thoroughly tested in the big test environment.
Build number update
This is about version control. It is very important to ensure proper version control of all front-end files (such as JS and CSS files). Version control will ensure that new files are downloaded to the client after the application or website is deployed. If there is no version control, it is possible to use the old cache and cause the product to not work properly. In agile development, this is also one of the best practices implemented as a user story.
In summary, completing the delivery checklist is very useful for building high-quality software development processes. This is good news for software teams, especially for enterprise-level software and large teams.