How was the code review procedure organized in your team?

We used collaborative development with version control system Git and a repository management platform (e.g., Bitbucket or GitLab). The code review process was organized as follows:

1. Creating a branch: The developer creates a separate branch for a new feature or bug fix (git checkout -b feature/my-new-feature).
2. Development and commits: Changes are made in the branch and committed (git add ., git commit -m "Initial feature implementation").
3. Push to remote repository: The branch is pushed to the remote repository (git push origin feature/my-new-feature).
4. Creating a Pull/Merge Request: The developer creates a Pull Request (in Bitbucket) or Merge Request (in GitLab), specifying the target branch (e.g., develop or main). A brief description of changes, links to tasks in the tracker (Jira, Trello, etc.), and attached files (screenshots, videos, diagrams) are included.
5. Assigning reviewers: One or two developers from the team are assigned to review.
6. Review process: Reviewers examine the changes in the Pull/Merge Request. They can leave comments, suggest improvements, ask questions.

   // Example comment during review
   function fetchData() {
     // Maybe add error handling here for data requests
     return fetch('/api/data');
   }
   

7. Making changes based on review: The developer makes necessary changes to their branch based on reviewers' comments and commits the updates.
8. Updating the Pull/Merge Request: Changes are automatically reflected in the Pull/Merge Request after pushing to the remote repository.
9. Re-review: Reviewers review the changes again and approve.
10. Merging the branch: After approval, the branch is merged into the target branch (usually automated by the platform after passing CI/CD pipeline).

We also used a CI/CD pipeline for automatically running unit tests, static code analysis (ESLint, Prettier), and building the project before merging, which helped identify errors early.

Criteria for successful review include:

• Compliance with task requirements.
• Following the team's coding style.
• Presence of unit tests for critical logic.
• Absence of obvious errors and "workarounds".
• Code clarity for other team members.