For more than a decade, software teams have benefited from agile development methods. They have adopted these incremental development practices, where solutions evolve through collaborative development.
Continuous integration (CI) and test-driven development (TDD), as part of
architecture-based approach, extend basic agile practices enough to provide both high quality and project flexibility.
Continuous integration (CI) was created for agile development. It organizes development into functional user stories. These user stories are put into smaller groups of work, sprints.
The idea of continuously integrating is to find issues quickly, giving each developer feedback on their work and TDD evaluates that work quickly. With TDD, you build the test and then develop functionality until the code passes the test. Each time, when you make new addition to the code, its test can be added to the suite of tests that are run when you build the integrated work. This ensures that new additions don’t break the functioning work that came before them, and developers whose code does in fact “break the build” can be notified quickly.
Agile methods allow software and systems teams to respond quickly to the changes. CI helps systems development teams be agile and respond to rapid business changes, while at the same time ensuring that the actual hardware and software under development are in constant sync. CI allows team members to work effectively in their domain groups, focused on the tasks that they’re best at accomplishing. At the end of each day, they know that their contributions to the project are integrated and that the component parts work together. And if something doesn’t integrate, it’s quickly discovered.
From a technical perspective, CI helps teams work more efficiently. These teams can be cross-functional, they can be geographically distributed, because the constant integration work will ensure that you don’t get deviating designs. People can work on a large team, because the different components of a complex system will more assuredly work together. It solves many of the early pitfalls that these nontraditional agile teams might have experienced without CI. Combining CI with test-driven development puts more people under the agile umbrella, because it allows agile methods to work more efficiently.
WHAT IS CONTINUOUS INTEGRATION ?
CI – it is a software development practice where members of a team integrate their work frequently, usually each person integrates at least daily – leading to multiple integrations per day. Each integration is verified by an automated build (including test) to detect integration errors as quickly as possible. Many teams find that this approach leads to significantly reduced integration problems and allows a team to develop cohesive software more rapidly.
The goal of CI is to provide rapid feedback so that if a defect is introduced into the code base, it can be identified and corrected as soon as possible. Continuous integration software tools can be used to automate the testing and build a document trail.
CI BENEFITS
- Prevent integration problems
- Integration bugs are detected early and are easy to track down due to small change sets. This saves both time and money over the lifespan of a project
- Avoids last-minute chaos at release dates, when everyone tries to check in their slightly incompatible versions
- Committing code frequently
- Categorizing developer tests
- Using a dedicated integration build machine
- Using continuous feedback mechanisms
- Staging builds
- When unit tests fail or a bug emerges, if developers need to revert the codebase to a bug-free state without debugging, only a small number of changes are lost (because integration happens frequently)
- Constant availability of a “current” build for testing, demo, or release purposes
- Frequent code check-in pushes developers to create modular, less complex code
- Enforces discipline of frequent automated testing
- Immediate feedback on system-wide impact of local changes
- Metrics generated from automated testing and CI (such as metrics for code coverage, code complexity, and features complete) focus developers on developing functional, quality code, and help develop momentum in a team
- Separate software builds from software deployments
- Say goodbye to long and tense integrations
- Increase visibility which enables greater communication
- Spend less time debugging and more time adding features
- Proceed in the confidence you’re building on a solid foundation
- Reduce integration problems allowing you to deliver software more rapidly
- Automate the build
- Make your build self-testing
- Automate deployment
- CI is quality assurance
From a business perspective, CI offers better business results, they can bring products to market faster, by finding issues when they are young and small, not waiting until they are large and more difficult to fix. They can also respond better to requirements that are introduced while the product is being development. This creates a better product for the customer, which is the real promise of agility.
