Survival of the Most Efficient: Intro to Agile Software Development

With the software industry moving forward rapidly and trends shifting, a delay in product release can be disastrous for a company.

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 to. 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

Scrum process

‍Image Credit: www.agilesoftwaredevelopment.com

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 as quickly as possible.

Throughout a scrum sprint and afterward, the scrum team meets to discuss progress and identify issues that caused delays to sprints. Scrum has allowed 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:


over Processes and tools


over Comprehensive documentation


over Contract negotiation


over Following a plan

That is, while there is value in the items on the right, we value the items on the left more.

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 codebase and never make it beyond production. Team members are notified of broken builds to prevent the further degradation of a codebase. 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 the 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 the software. Making releases a simple, automated task allows for more time to be focused on frequent development and accepting new feedback from users.

More Confidence, Less Risk

With continuous integration, that risk is almost completely mitigated. Small changes are quickly added to the development codebase 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

More and more remote software developers are moving their software testing to hosted solutions in the cloud. Popular continuous integration tools like Travis-CIJenkinsBambooCircleCISnap CIBuildkiteElectric 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 for this unique offering as a Mac-centric Infrastructure-as-a-Service provider.

The Efficient Future

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.

Further Reading

Stay tuned for more articles on Agile Development practices by following @MacStadium on Twitter and subscribing to the MacStadium Blog RSS feed.