50% off your 1st seat of GitKraken Pro — only $4/month!

Git Blog

Releasing the Power of Git

Getting Started with Continuous Integration

This article was written by guest author, Cagla Ertugrul, CEO, MONCCO PR. 

It is impossible to overestimate the importance of a strong development environment when scaling your team’s capacity. 

Nowadays, most organizations use Git, and one of the popular and successful development models used by many organizations is Gitflow. When making use of such models, continuous integration (CI) is key as it enables faster project delivery and offers reduced risk and expenses thanks to self-managed and easy-to-control dedicated teams. In this article, I will explain the benefits of continuous integration and how to achieve them. 

What is Continuous Integration?

Continuous integration starts with developers interacting with and collaborating on code through a shared repository through a version control system, like Git. Developers push their work at regular intervals, and once changes are finalized, a series of automated actions run. 

Automated actions might include static code analysis, spell checks, security checks, unit testing, integration testing, and more. These actions are meant to quickly notify developers if any failures occur throughout the steps in their workflow.

Continuous Integration Tools

There are various continuous integration tools available. Some of the most popular tools include:

  • Jenkins: This CI tool manages and controls software delivery processes. Enable Jenkins to watch for code changes on your hosted repos and initiate automated builds.  
  • Azure DevOps: Microsoft created this set of DevOps solutions to allow developers to go from code to cloud by automating every step of the process with continuous integration. 
  • GitLab CI: Providing a seamless experience from planning to deployment, this tool can split builds over multiple machines for rapid execution.  
  • GitHub Actions:  Perfect for teams hosting project repos on GitHub, GitHub Actions offers automated actions for building, testing, and deploying. 

Static Analyzers for Code Review

Code quality is paramount in any software project, but often developers will take shortcuts to meet deadlines. Including a static analyzer helps enforce quality in code by avoiding mistakes. 

Static analyzers can be easily incorporated in the development environment and the continuous integration process. Analysis-Tools.dev has curated a list of popular static analysis tools by programming language. 

By enabling analyzers, developers can more easily identify and fix errors. This in turn eases the task of an eventual code reviewer, who can instead concentrate on reviewing the code’s functionality instead of concentrating on common anti-patterns or code style. 

Unit Testing

Unit testing is a process where a unit of functionality is tested. This is an automated testing process where test cases are written and executed every time code changes are pushed to a repository. 

Unit tests are good for testing logical functionalities or algorithms, and can avoid breaking changes when code is refactored. Here are some tips for avoiding fatal mistakes when writing unit tests

In unit tests, an external dependency is mocked which helps run several thousands of tests within minutes.  Properly written unit tests covering more code helps reduce risks when your team is refactoring existing functionalities. 

Integration Testing

In integration testing, whole functionality is tested instead of just the unit of functionality. Here, databases or external dependencies are not mocked.  Because dependencies and databases are not mocked, integration tests will take more time to run compared to unit tests. Integration tests should be written smartly to cover all functionalities, and there should be just enough tests to ensure the system is running as expected. 

Adding too many integration tests may create a maintenance nightmare, especially if not written properly. If functionality can be ensured using unit tests, that should be a preferred strategy to integration testing. More integration tests will require more execution time which in turn slows down the deployment process.

Integration testing can run on a scheduled basis or on-demand, instead of running integration tests on every pull request, for example. Integration tests also help avoid breaking changes in existing functionality when a codebase or team is scaling and can save hours of manual testing. 

Learn more about integration testing, including a method called snapshot-based testing

Pull Requests & Continuous Integration

Pull requests create an opportunity for a healthy discussion of code. No matter if your team is small or large, pull requests should be encouraged. 

When a developer submits a pull request, they are requesting that a peer, or manager perhaps, review and approve code changes before they are accepted as final into the project. Code review helps improve quality and avoid common mistakes. 

Increase your knowledge about pull requests in this intermediate Git tutorial video. Learn Git: What is a Pull Request?

While not mandatory for continuous integration, pull requests enable a human checkpoint, a benefit that can’t be automated by design. 

Feature Toggles for Faster Release

Feature Toggles, also known as Feature Flags, help deliver features at a much faster pace. With this technique, a feature is enabled or disabled using a configuration which sometimes is as simple as true/false condition check. When a feature is completed, it is enabled in a product by just turning the configuration value to true for that feature. This can be especially helpful when working on a large feature that is scaling to multiple releases. 

In Git, a common workflow is merging a feature branch from development into production once a feature is fully complete. While this process can be great for small features, it can create complications for larger features that might take a month or more to implement. In such a case, the local branch will become outdated compared to the development branch, likely causing numerous code conflicts. Feature toggling is a great solution to this problem. 

This technique can also be used to push to a remote repository in parts, but also merged and released. During the release, features that are not yet completed can be turned “off,” while other features are released. When a feature is fully tested and ready to go, it can be turned “on.” 

Lastly, developers can use this technique to turn on a feature for a certain group of users for A/B testing. 

Optimize Your Workflow with CI

If equipped with the right tools, continuous integration can be easier to implement than you might expect. Automation is the way of the future when it comes to software development, and teams who fail to adopt these strategies now will be left in the dust. 

Like this post? Share it!

Read More Articles

Make Git Easier, Safer &
More Powerful

with GitKraken
Visual Studio Code is required to install GitLens.

Don’t have Visual Studio Code? Get it now.