With the software industry moving forward rapidly and trends shifting on a weekly basis, a delay in product release can be disastrous for a company—especially a startup with little to no funding. According to CB Insights, in each year from 2010-2013, 70%-80% of internet technology companies died. Why are companies dying? One reason may be inefficient software development workflow burning through time and investment capital.
Lacking any type of efficient workflow, software development can stall and cost companies money and work hours. As the tech industry evolves, companies not using efficient software development practices can fall behind and sink. Software companies that succeed in this evolving sector are delivering timely, efficient updates to their applications to keep up with dynamic customer demand.
In the current software development landscape, continuous integration (CI) and continuous deployment (CD) are becoming key factors in building an efficient software workflow. Both are methods under the umbrella of incremental software development, or agile development as it is often referred. Using these practices, companies can iterate software products in a faster, more efficient process than previously possible.
In traditional software development, programmers follow the waterfall method of project management. This outdated methodology is similar to the automotive assembly line where a product moves directly through a series of stages to becoming a completed vehicle in the final stage. This method may work for automobiles but is no longer effective for software development.
In the waterfall method, every phase must be completed before any other phase can begin. This means when any sort of roadblock is met in the development process, work completely stops. Something as simple as getting color choices approved by a manager can halt development.
Roadblocks can add up to a significant delay in the final release of a product after many months or years of development. The answer is an iterative process where several parts of the application are improved at once. This is agile development.
Agile History and the Agile Manifesto
Agile development itself has a long history with software development. The idea of developing software incrementally was seen in the 1950’s and 70’s. In the 90’s there was more research done into the lightweight methodology of software development with several popular methods still existing from that time. Scrum is one such method that grew in the 90’s and is still in use today.
Software developers that develop using the scrum agile methodology are most often building a product in a series of sprints. In each sprint, a scrum team develops a plan to tackle a set list of tasks, or backlog of issues. After scrum planning completes, the team begins to code, test, and integrate the tasks daily with the hopes of rapidly completing tasks and completing the sprint in as quick as possible.
Throughout a scrum sprint and afterwards, the scrum team meets to discuss progress and identify issues that caused delays to sprints. Scrum has allowed for software development teams to focus on the most important issues that the product faces in a timely manner.
It wasn’t until 2001 that the word agile was used to described the collective idea of incremental software development. A group of software developers met that year to discuss lightweight development and in their talks, they created and published what is now known as the Manifesto for Agile Software Development. The Agile Manifesto is now considered the true starting point from which discussions of agile development have launched since then. The Agile Manifesto reads as follows:
We are uncovering better ways of developing software by doing it and helping others do it. Through this work we have come to value:
Individuals and interactions over Processes and tools
Working software over Comprehensive documentation
Customer collaboration over Contract negotiation
Responding to change over Following a plan
That is, while there is value in the items on the right, we value the items on the left more.
Agile development is based on the idea that the product life-cycle is continuous and as such, the process of software development should iterate and evolve quickly along that life-cycle. The benefits to this development method are constant, incremental updates to a product.
Rather than develop a product based on one vision created in the past, the product can evolve as demand changes. A team that stops every week to review development progress is much more flexible to make important changes and move the development in the right direction. Development costs and time-to-market are both reduced with this approach allowing smaller companies to create better products in a shorter amount of time.
Since the creation of the Agile Manifesto, there have been great strides to push all software products toward an iterative software development process. continuous integration and continuous deployment are two techniques that have flourished in the media in recent years.
Tools of Automation
With continuous integration, software developers, and more importantly teams, can set up tests to quickly ensure the most recent code change, however minor, is tested automatically and as soon as possible after committing the code. Software developers using agile methods, follow an efficient cycle of develop, integrate, and deploy when creating new software features.
In team environments, automatic testing ensures that errors in code don’t linger for too long in the development code base and never make it beyond to production. Team members are notified of broken builds to prevent the further degradation of a code base. Daily integration of minor changes allows for faster detection and easier location of errors as well. This in turn allows developers to solve problems quickly with less back-tracking in code.
Continuous deployment is the next logical step following CI in the agile development method. This process is a way to move successfully tested code into a stable release format or production environment. In the past, software developers maintained a long list of system upgrades, API updates, documentation updates, and other external dependency changes that needed to be made before releasing a new version of software.
Continuous deployment allows for a system to replace all of the manual changes with one automated, all-encompassing solution. After continuous integration tests pass, continuous deployment scripts can auto-generate new builds with all necessary changes to release a new, stable version of software. Making releases a simple, automated task allows for more time to be focused towards frequent develop and accepting new feedback from users.
More Confidence, Less Risk
In the waterfall method, integration was a timely, costly, and high-risk operation in the software development process. For large software projects where multiple dependency-filled aspects were combined for testing, integration could take days or weeks. This was a huge burden on a software development team and meant they were wasting time waiting for integration to finish rather than doing real development work. If integration failed, the entire process would have to start over beginning with research into what aspect of the complex integration failed. The risk in any size company can be dangerous to a project’s life.
With continuous integration, that risk is almost completely mitigated. Small changes are quickly added to the development code base and after short tests against a stable code base, they can be accepted, integrated, and deployed with little to no fuss. Faster, more efficient development leads to better utilized developers and more productive development environments.
Agile Development Anywhere
With the new software development process occurring simultaneously local and in the cloud, integration processes have adjusted as well. Continuous Integration has been one process that has quickly gathered momentum as a hosted service.
More and more remote software developers are moving their software testing to hosted solutions in the cloud. Popular continuous integration tools like Travis-CI, Jenkins, Bamboo, CircleCI, Snap CI, Buildkite, Electric Flow and Codeship offer variations of their service in hosted and/or self-hosted options.
Travis-CI is a great example that offers an open source continuous integration tool for Linux, iOS, and OS X development on a hosted platform with varying plans based on need. Their plans range from free to monthly for single developers with enterprise support available for fortune 500 corporations that may desire their own environments.
Travis-CI offers Mac-based OS X and iOS build testing on dedicated Apple Mac hardware; something very few others can provide from a hosted enterprise-class solution. MacStadium is proud to support Travis-CI for this unique offering as a Mac-centric Infrastructure-as-a-Service provider.
The Efficient Future
Technology and software are now working together on a global scale. Agile development and processes like continuous integration will continue to flourish as the software development ecosystem connects more with cloud services.
More than ever before, it’s important to prepare software with efficient software development methods like continuous integration and continuous deployment. With iterative development, software developers can now take advantage of a growing suite of tools to efficiently create applications for the future.