Application lifecycle management (ALM) provides a systematic process for managing a software development project through the requirements gathering, design, development, testing and maintenance phases. Even though ALM provides a systematic and disciplined way to manage a potentially chaotic process, it results in a number of costs. Many of them are due to the nature of ALM itself, resulting in wasted time and effort of development and testing resources.
Continuous development (or continuous integration, as it is called sometimes) provides a way of managing software development by coordinating rapid software builds with automated testing. These combined build and automated-test cycles are done multiple times a day or even an hour. Continuous development enforces a discipline of having all developers check in the changes that they have done in a day or since the last build. Automated tests are then run quickly as part of the build itself. If the automated tests fail, developers are forced to sort out the defects and integration issues immediately and add changes into the next build. This cycle is repeated quickly until all the automated tests are successful. Once a build passes all the automated tests, it is tested with the data from the production system in use at that time, and then the production system is updated if those tests are successful.
Continuous development reduces the costs of ALM in a number of ways, including the costs of delayed development and deployment cycles. Here are some of the ways continuous development addresses the costs of ALM:
- Requirements validation costs: Requirements gathering and validation is one of the pernicious costs in ALM. If requirements are not gathered properly and validated, you could spend time designing and developing the wrong solution that does not match the actual requirements. Miscommunication causes requirements rework costs. Continuous development forces the early and rapid production of working code. Requirements can be validated early on in the ALM cycle. In many software development projects, even a user interface prototype created early on with continuous development may be enough to validate requirements gathered so far. If course corrections are made at this early stage, you can avoid the costs of reworking more expensive, fully developed software.
- Design validation costs: Continuous development, with its early and rapid builds, helps development teams prioritize important and open design questions, allows them to prototype alternative designs and test them out early. Unknown questions about complex software architecture always plague design. Continuous development allows for attacking these questions early and quickly, getting them out of the way and avoiding expensive redesign of already developed software.
- Testing costs: In traditional ALM cycles, the quality assurance/testing group waits for the development build to start their testing. Now the development group waits for the testing group to finish their testing and report their defects and issues. There is a lot of waiting, resulting in waste of time and human resources. In continuous development, tests are automated and incorporated into the build itself. The testing resources spend their time in designing automated tests and incorporating them into the build process. This they can do continuously, without waiting for any other activity to happen. Developers are continuously addressing the issues automated tests bring up and resolve them all before the next build. Testing costs are radically reduced simply by the use of automated tools and elimination of waiting time in the ALM cycle.
- Costs of regression errors and rework: Regression errors creep into builds if developers are not disciplined and do not follow the prescribed process for checking in their latest code changes. If by mistake, instead of the latest version, an older version is checked in, bugs already fixed may creep back into the build. These need to be found again in testing. Regression error costs are completely avoided by the automated check-in, build and test processes that continuous development dictates. Builds are not complete if they do not pass all automated tests so far. Rework due to regression errors is totally eliminated.
- Integration costs: Integration testing is usually a separate activity in ALM. Continuous development dictates that all modules be integrated in every build. Integration tests also form part of the automated tests. This means that a build does not pass unless it goes through the full integration testing every time a build is done. There are no separate integration testing costs with continuous development and, in addition, it improves the quality of code.
- Release costs: In ALM, you have a separate release process. This results in unexpected costs due to delays and opportunity costs in bringing down your production system for maintenance and upgrades. Continuous development negates the need for a separate and discrete release cycle. When daily or hourly builds pass all automated tests with a copy of the actual data from the production system, the new build can be installed on production without any further delay. This eliminates release costs and the waiting time of development and testing resources in ALM.
Application lifecycle management is a disciplined process for software development with proper requirements gathering, design, development, testing and maintenance phases. However, time and effort could potentially be wasted by development and testing resources at various phases of ALM, resulting in various costs. Continuous development eliminates a lot of these costs simply by enforcing a check-in discipline with software version management tools. It also makes sure that automated tests become part of every build and so eliminates much of the manual testing necessary, speeding up the development cycle itself.