What is Continuous Integration?
Continuous Integrations and TV Tropes: How Poor Communication Kills DevOps
Key Takeaways
Continuous Integration (CI) is the automated practice where developers are continuously merging changes back to a main branch.
Have you ever thought about how many movies and TV shows wouldn’t have plot lines if the characters had just decided to communicate with each other? This storytelling trope “Poor Communication Kills” is common in movies, tv shows, and books. [We’re looking at you, Stranger Things] This trope can happen in real life. In fact, development teams often see this trope play out in their software development lifecycles.
When individuals creating software don’t actually communicate with each other, they miss a lot of important points. DevOps was born out of a need for better team communication and collaboration when developing software. Continuous Integration supports the foundation of a good DevOps practice, helping teams avoid the all-too-common storyline.
What is Continuous Integration?
Continuous Integration (CI) is the automated practice where developers are continuously merging changes back to a main branch. Whenever merges occur, an automated chain of events, containing tests and other forms of validation, also get kicked off. This process ensures that any commits to the main branch do not contain errors. Continuous Integration must contain an automation component (e.g. a CI or build service) and a cultural component (e.g. learning to integrate frequently).
How does Continuous Integration work?
For Continuous Integration to work, developers must continuously be able to commit changes to their main repository. Continuous Integration automatically builds and runs tests on new code changes, ensuring faster and better quality builds. The workflow for Continuous Integration runs multiple times a day and follows these six steps:
Developers check-in code to the main repository
Automated code build
Automated tests run
Reports sent
If successful tests, an executable file is created (Continuous Delivery, here we come!)
If a test fails, the developer works to fix the code, and then cycles back to code build
Continuous Integration Benefits for DevOps
The reason Continuous Integration is so highly adopted by development teams is because of the business benefits it provides. The following CI benefits directly improve product quality and delivery speed.
Less Bugs.
Because automated tests set in motion as soon as commits happen, each change is more likely to be well-built, with minimal errors. And if an error does come through, code fixes are a part of the continuous process, so cycles aren’t bottlenecked.
Effective team collaboration.
Since developers are able to check the main repository in real-time and see which components their teammates have already built, they won’t accidentally re-build the same pieces and repeat work. And if a build breaks, the team has visibility into what code needs their attention.
Faster releases.
Developers can release faster without sacrificing quality when using Continuous Integration. This speed comes from frequent testing (meaning less backtracking and code correction), as well as automated processes (meaning less bottlenecks than if they relied on human-triggered events).
How does Continuous Integration fit into CI/CD?
Let’s think about CI/CD pipeline as a solution to the “Poor Communication Kills” trope. Another example of this trope is a classic poem called The Blind Men and the Elephant. In this story, six blind men try to decipher what an elephant is, simply by touching it and explaining what they are feeling.
However, because each one approaches a different part of the elephant, they each get an incomplete understanding of what the animal actually is. One man touches the flank of the elephant and assumes it’s like a wall. Another feels the elephant’s tail and assumes it’s like a rope. A third assumes the elephant is like a snake because he’s touching its trunk. And the story goes on.
Because they didn’t communicate about their different perspectives of the whole picture, each of the characters in this story never gained a full understanding, leading to an inaccurate final product.
The CI/CD pipeline solves disjointed development lifecycles, much like the disjointed approach taken by the six men in the poem. When a development team utilizes CI/CD, it streamlines the separate components built by developers into a cohesive product that’s both well-built and efficiently made.
Continuous Integration covers the first half of the process, while either Continuous Delivery or Continuous Deployment, makes up the “CD” in the acronym.
Continuous Delivery takes builds that were uploaded to the repository in the Continuous Integration step, runs it through further tests, and then puts it into a test environment. Continuous Deployment goes a step further than Continuous Delivery and also deploys the build into a production environment.
Together, these automated processes break down the silos between individual developers and allow them to contribute builds to a final product, in a way that makes sense from each of their perspectives.
Continuous Integration Tools
There are countless Continuous Integration tools out there, created to help teams communicate and automate these pass-offs between stages of software development. But not all tools are created equal. Here are the top tools teams use to run their Continuous Integration practice:
Jenkins
Originally developed by Kohsuke, the open-source, platform-independent Java-based CI tool can be used as a simple CI server or turned into the Continuous Delivery hub for any project.
On-premise
Open source
Provides plugins for flexibility
CloudBees Codeship
A Software as a Service (SaaS) solution that empowers engineering teams to implement and optimize CI and CD in the cloud. Develop everything from simple web applications to modern microservice architectures for fast, secure and frequent code delivery.
Cloud-based
Integrates with any tools, service, or cloud
Simple, out-of-the-box Continuous Integration Platform with pre-installed CI dependencies that you can build on
Bitbucket Pipelines
Bitbucket Pipelines is an integrated CI/CD service built into Bitbucket. It allows you to automatically build, test, and even deploy your code based on a configuration file in your repository.
Cloud-based
Integrates into Bitbucket, an end-to-end DevOps solution
Automatically creates containers and operates out of them
GitLab
GitLab empowers organizations to maximize the overall return on software development by delivering software faster and efficiently, while strengthening security and compliance.
On-premise or cloud
Complete coverage for all DevOps processes in a single application
Azure Pipeline
Continuously build, test, and deploy to any platform and cloud. Plus, you can get cloud-hosted pipelines for Linux, macOS, and Windows.
On-premise or cloud
Integrates with GitHub
Final Thoughts
Is your business still suffering from the storytelling trope “Poor Communication Kills”, structured into siloed development teams without automation between SDLC stages? Well, stranger things have happened! If you’re ready to move towards a DevOps model, Launchable is here to help improve your Continuous Integration speed by creating great testing practices to complement your CI/CD pipeline.
