Continuous integration is a coding philosophy encapsulated into a set of practices whereby development teams implement small changes and check in code to version control repositories frequently, to ensure error-free development. The development team integrates code into a shared repository on a consistent basis, even multiple times a day, after setting up an automated build upfront, to detect any problems in the code.  Development teams working under conventional models defer integration until the last, invariably magnifying the number and severity of the inevitable merge conflicts.

Continuous integration (CI) is now mainstream, thanks to the host of benefits on offer. Identifying issues as and when it occurs, and mitigating it on a timely basis reduces risks, improves code quality, and speed up project execution. It is easier to identify and resolve glitches, quality, and other issues on smaller code differentials rather than over code developed over an extended time. In addition, developers spend less time backtracking and more time building new features.

Here are the specifics on how continuous integration reduces integration risks in software development.

Create a Version Control Repository

One of the first tasks in the Continuous Integration approach is creating a version control repository and placing all code and database artifacts in it. A unified master database capable of updating changes in real-time is another essential requirement.

The code working perfectly fine in some systems, but not in other systems is commonplace. The problem compounds in Continuous Integration, where all iterations pose such a risk. The solution is to eliminate tight coupling between the IDE and the build processes. Use a separate, exclusive machine to integrate the software, and add everything required to build the software to this version control repository.

Another common issue faced by developers is the inability to synchronize with the database, or recreating the database quickly during development. This is mainly owing to poor collaboration between the database development team and the development team.

Deep collaboration is the backbone on which the continuous integration approach sustains, and as such, tight integration of Dev, Ops, QA, and the wider IT team is an essential prerequisite for Continuous Integration. Development teams need to collaborate effectively on technologies and develop a consensus on the approach.

Placing all database artifacts, including scripts, procedures, and other assets, in the unified master database of the version control repository ensures the development and testing teams have access to everything required to develop database creation and data manipulation scripts and recreate database schema, stored procedures, and triggers.

Create a Continuous Integration Server

Side-by-side with the version control repository creates a Continuous Integration server, to keep track of changes in the version control repository and to run the project build script on changes to the repository. Provision the Continuous Integration server with adequate capacity to run the build through various tests, perform inspections, and deploy the software in the development and test environments.

Rebuild the database and data from the build script by dropping and recreating the database and tables. Next, apply the stored procedures and triggers, and finally, insert the test data.

Build a Test Suite

Continuous integration requires continuous testing, in the form of a set of automated regression, performance, and other tests, as a core process. In fact, the effectiveness of CI depends on the stability of this testing suite.

Build a proper testing suite and write test scripts upfront. Configure the continuous integration server to run regression testing automatically whenever there is any major change to the software code. Regression tests are however just the start. Effective CI requires automation of performance testing, API testing, static code analysis, security testing, and other testing forms, and triggering these tests as well, through command line or web service. Make sure all the deployed tests return success or fail status codes.

Ensure the test cases are complete and test all code paths. The test cases not covering the entire functionality of the code renders the process meaningless. Also, make sure the tests are not just repeatable, but actually performed continuously in virtualized systems, replicating unavailable testing environments.

A unified testing suite, however, is not a universal solution. In some cases, the developers would have to create custom database-specific tests. Multiple developers make changes to the source code always raises the possibility of a defect manifesting itself only much later. As such, even though checking in code takes place frequently, implementation of features and fixes take place on both short and long periods.

Adopt the Right Version Control Strategies

Development teams practicing continuous integration use different techniques to control the features and code ready for production.

Version-control branching is one of the common techniques. Here, the development team selects any branching strategy such as Gitflow, to define protocols on how to merge new code into standard branches. The approach entails creating additional feature branches for features taking longer development cycles. On completion of the feature, developers merge the changes from feature branches into the primary development branch.

Feature flags, another popular technique, entail wrapping features under development with feature flags in the code deployed with the master branch to production, effectively turning off the code until ready.

One best practice is to use cloud environments and containers such as Docker and Kubernetes. Containers allow the development team to pack and ship applications in standard, portable ways and also scale up or tear down environments with variable workloads. DevOps teams may use automated database integration, local database sandbox, and version control repository to share database assets.

Continuous Integration offers the best opportunity to develop quality code from the ground up, in compliance with the architectural standards tailored to the specific requirements of the enterprise. However, integrating several iterative builds invariably cause quality issues and defects. DevOps teams need to assess the integration project for potential defects on a continuous basis and adopt a proactive approach to tackle any underlying issue as early as possible.

Author Bio:

Girish R, Programmer for 17 yrs, Blogger at Techathlon.com, LifeHacker, DIYer. He loves to write about technology, Open source & gadgets. He currently leads the mobile solutions team at Fingent.