Back to Scaling Scrum in Large Organizations

Continuous Integration

5 minutes 5 Questions

In the context of Scaling Scrum, Continuous Integration (CI) is an essential practice. CI is a development practice where developers integrate code into a shared repository frequently, preferably several times a day. Each integration is then verified by an automated build allowing teams to detect p…

Guide and Exam Tips: Continuous Integration

What is Continuous Integration?
Continuous Integration (CI) is a development practice where developers integrate code into a shared repository several times a day. This practice allows teams to detect problems early. By integrating regularly, you can detect errors quickly, and locate them more easily.

Why is Continuous Integration Important?
CI is critical because it helps maintain code quality, allows for earlier detection of issues, reduces bugs in production, ensures up-to-date software builds and aids in reducing project risk. It also supports faster feedback loops and encourages team collaboration.

How Does Continuous Integration Work?
Developers first write their code and perform unit tests in local environments. After successful unit tests, they commit their changes to the version control repository. An automated build system then fetches the latest code from the repository and runs the necessary tests for that code. If the tests fail, developers fix the code immediately. This process repeats multiple times a day.

Exam Tips: Answering Questions on Continuous Integration
-Understand the definition and purpose of Continuous Integration.
-Be familiar with its benefits such as early bug detection, maintaining code quality and ensuring software is always up-to-date.
-Describe how Continuous Integration works, including the role of the developer and the automated build system.
-Always relate the importance of CI practice to software quality and collaboration among the team.

Test mode:

Exam (Timed)

Practice (With explanations)

Start practice test

CSM - Continuous Integration Example Questions

Test your knowledge of Continuous Integration

Question 1

A developer on your team commits a change to the repository, but later it is found that this change breaks other existing functionalities. Though you have been using Continuous Integration, this issue was not detected before deploying. What could be the best solution to prevent these issues from getting into the production system?

Conduct a Sprint Retrospective specifically focused on improving commit practices Incorporate peer review before merging changes to the main branch Increase the frequency of code commits to the repository to minimize integration issues Implement a code freeze during the Sprint to stabilize the code base, allowing changes only in the first half of the Sprint. This approach, while intended to maintain stability, could inadvertently slow down the development process as it restricts the developers’ ability to make necessary adjustments throughout the entire Sprint duration. By limiting modifications to the initial phase, it may also lead to a backlog of changes that need to be integrated and tested in a shorter timeframe, potentially impacting the team’s ability to effectively address and rectify any emerging issues or errors. Consequently, this practice could affect the team’s agility and their capacity to adapt to changes swiftly, which are key aspects of the Scrum framework.

Correct Answer: Incorporate peer review before merging changes to the main branch

Incorporating peer review before merging changes encourages collective ownership of code quality and can catch potential issues early. Increasing commit frequency might help with smaller integration issues but does not address quality directly. Conducting a retrospective focused on commit practices could help improve processes but would not prevent immediate issues from reaching production. Implementing a code freeze during the Sprint is not a recommended Scrum practice as it directly counters the principles of iterative development and flexibility.

Question 2

A team member has raised a concern about the frequency of integration. They have noticed that pushbacks due to failed tests have increased, leading to the delays in merging into production. How can this be corrected?

Increase the frequency of integration to remove the bottlenecks faster. Introduce a policy that changes should not be pushed if local tests are failing. Ask developers to push their code changes to the repository irrespective of the test results. Stop running the tests on the local development environment to push for a faster integration.

Correct Answer: Introduce a policy that changes should not be pushed if local tests are failing.

The best solution is to 'Introduce a policy that changes should not be pushed if local tests are failing.' In Agile development, frequent integration is necessary, but the updates should never compromise the quality of the production code. If the tests are failing, there's a high chance that the pushed changes will cause issues in the live environment, so the new code should not be pushed to production until all the tests pass locally, reducing burden on the integration phase and hence the pushbacks. On the other hand, asking developers to push their changes irrespective of the test results, increasing the frequency of integration, or stopping the test runs on the local environment will not solve the issue but potentially increase it. These approaches might bring damaged code into production faster and increase the overall issues and workload.

Question 3

Developers often have to wait for a long time to get feedback after checking in their changes. How can this be improved for faster feedback and improved efficiency?

Increase the infrastructure resources to accommodate all test cases at once. Optimize the test times by implementing techniques like parallel testing or prioritizing important tests. Fully test the application before each integration rather than just testing new or changed features. Ask developers to only run the build after a set of commits instead of after each single commit.

Correct Answer: Optimize the test times by implementing techniques like parallel testing or prioritizing important tests.

The best possible answer to reduce the waiting time for developers for feedback after checking in their changes is to optimize the test times by implementing techniques like parallel testing or prioritizing important tests. This approach allows for faster feedback and improved efficiency as multiple tests are run simultaneously or vital tests are prioritized. Let's consider the other answers. The suggestion for developers to run the build only after a set of commits instead of each single commit may lead to issues being detected late in the process, increasing the complexity of debugging. Running a full test of the application before each integration could also be inefficient and time consuming, as it might lead to redundant tests. Finally, increasing infrastructure resources to accommodate all test cases at once may not only be costly but also may not address the root cause of the delay if the problem lies within the organization of the tests or the conducting of unnecessary tests.

🎓 Unlock Premium Access

Certified ScrumMaster + ALL Certifications

🎓 Access to ALL Certifications: Study for any certification on our platform with one subscription
3861 Superior-grade Certified ScrumMaster practice questions
Unlimited practice tests across all certifications
Detailed explanations for every question
CSM: 5 full exams plus all other certification exams
100% Satisfaction Guaranteed: Full refund if unsatisfied
Risk-Free: 7-day free trial with all premium features!

Start Your Free 7-Day Trial