Continuous Integration

Continuous Integration has become a critical element in current devops practices and is the first step in a CI/CD (Continuous Integration/Continuous Deployment) process. Many agile cloud based companies are implementing this process to achieve two primary goals:

1. Improve Quality
2. Improve Velocity (that is the speed of feature deployment)

Often full CI/CD implementation span development, integration and production with new features and bug fixes being pushed into production via this process and significantly improving deployment speed to production. Thus,features are introduced in production days or even hours after feature development is completed. In contrast traditional development processes would take weeks or even months to deploy features into production.  

For the ease of development, the whole design is broken down into modules which are then handled by different teams of developers and/or individual developer. This whole process has its own challenges when it comes to synergizing these modules into a single unit to verify and validate the end product. The coding process is not an error free activity, despite individual tests being executed  and white box testing being performed by the development team. Issues can crop up while integrating these modules because of a variety of reasons. And these issues, if discovered late in the Software Development Cycle, can prove costly to the business. Here is a definition:

Continuous Integration (CI) is a development practice which takes care of integration issues early in the development cycle thus accelerating collaborative Software Development process.

This article focuses on how Continuous Integration can help the technical and business stakeholders in developing and releasing high quality software, thus ensuring maximum customer satisfaction.

Continuous Integration Process

Continuous Integration (CI) is a software development practice that requires developers to integrate code into a shared version control repository with every task completion. Code check-in triggers an automated build process which then further invokes the testing routines. These testing routines use automated test scripts to test the code and report the bugs, if any. If no errors are found, then it implies that the developer’s code changes are acceptable.  

Typically, a software is an aggregation of several modules which are developed by different developers. Every module is comprised of a significant number of files. Visualize a scenario where the smallest change in a file has a cascading effect on the output of that particular module and eventually impacting the expected outcome of the software. Before the Continuous Integration era, the Developers had to spend a considerable amount of time in integrating their modules seamlessly.  Integration became an expensive exercise since a lot of time was spent in testing, debugging and retesting. Continuous Integration is a pre-emptive measure for detecting integration issues earlier in Software Development Cycle, thus saving critical time which can then be used for improving the software or building new features.

Ideally it is prudent to integrate code at every change that makes even the smallest impact in the functioning of the software. This could range from a minimum of one check-in per day to several times a day.

The main goal of Continuous Integration is to provide feedback on defects discovered during code merges, prompting immediate action, thereby preventing issues which emerge later in the Development Cycle. Risk mitigation is significantly reduced as it is much easier to detect and rectify bugs in early stages of development.

• Source Code Management System

Continuous Integration requires individual developers to merge their code in a shared repository with the master code, also known as Trunk or Mainline Code.

The developers check out the working copy of code to their work station and make the necessary changes. The changes made to the code have to be tested and passed at an individual level before it can be checked in again. Code check-in sets the gears rolling for Build Automation and Testing.

Integrating with Mainline Code leads to sharing the code changes with the peers early in the development cycle. Any conflicts arising due to integration can be then immediately be addressed since the scope of scrutiny is small.

Having a centralized code repository is beneficial for both the development and the management team. The Repository acts as a one-stop place for developers to look for the latest code and submission of completed work. For managers, it acts as a single point for tracking project progress.

• Build Automation

Every commit to source code repository triggers an automated build process.

A typical build process involves compiling source code files and packaging them into a compressed format to produce install-able versions. It may use multiple header files, third party files, database inputs and may have various other dependencies.

Since the build process consists of  multiple steps involving multiple sources of inputs, chances of errors are high, if it is completed  manually every time a code check in is done. Hence, it is better to have a consistent automated build process which can be repeated with no developer/tester intervention, thus reducing the error rate significantly.

Speed of Build process is of utmost significance, since it is triggered frequently due to recurrent code commits, making it extremely important to have the process execute in a minimum amount of  time.

• Automated Testing

The testing process should be automated purely from a practical aspect, so that every time a code check-in triggers a build, the test scripts have to execute to verify the behaviour of the main line code after the integration. Extensive human involvement is expensive and prone to errors since there could be multiple check-ins from multiple sources at the same time.

These test scripts should run with every build to ensure that the new code that has been integrated is working as per expectations and set benchmarks.

These tests should be comprehensive for a successful Integration Process. They should include a variety of testing techniques depending on the module so that all possibilities are appropriately covered.

It is imperative to have a scalable production like a test environment to prevent any surprises at the deployment level.

It is also advisable to keep all build, test and other release related infrastructure up to date.

The results of the build and testing processes are of prime importance to the development and the management team. The results, pass or failure, have to  immediately be reported to the concerned parties. This immediate reporting process gives the developer enough time to take suitable corrective measures and adapt to code changes quickly.

In case of any errors, there should be a stop check mechanism in place which can put further development on hold, till the reported error is resolved.

Successful automated building and testing of projects can act as an input for subsequent automated deployment and release.

Thumb Rules for Continuous Integration

Continuous Integration is not just a practice to be adopted from a technical aspect.  It requires certain cultural changes at the developer and managerial level as well. Certain thumb rules have to be considered for Continuous Integration to work effectively.

Advantages of Continuous Integration

Conclusion

It is quite evident from the string of benefits for using Continuous Integration as a development practice, that it plays a key role in aiding the major stakeholders, be it the developers, managers or customers, in making strategic decisions related to business and technical processes.

Detecting a bug much later in the development cycle has a catastrophic effect on project cost, quality, delivery time and reliability. Hence, it is better to invest money and time earlier in deploying Continuous Integration in order to reap the benefits later.

At Webomates we offer CI/CD tools / services that help our clients to execute not only unit tests but also end to end functional tests before deploying the build to production.

Our CI/CD tool is bundled with a Defect Predictor that uses a combination of algorithm based automatic re-execution and Artificial Intelligence to answer the simple question that developers want – did my new code break anything? It clearly distinguishes between real and false failures leading to a much more efficient review by the developer.

If you are interested in learning more about services offered by Webomates please click here to schedule a demo, or reach out to us at info@webomates.com

Tags: Continuous Integration, Software Testing