1. Agile Musings by Jack Wendel
Agile maturity Includes Continuous Integration / Continuous Deployment (CI/CD)
Continuous Integration (CI) is an important part of agile. It involves automatically building
the code, running tests, performing code quality checks and generating metrics each
time a developer finishes writing a section of code and checks it in. If the code conforms
to the standards set, the build is “successful”. If the code does not conform in any area,
the build “fails”. The result of a developer “breaking the build” is that they must
immediately bring the code into compliance because no other developers can check in
code with a failed build in place. Implementation of CI results in a high quality code base
and elimination of “technical debt”.
Continuous Deployment (CD) is the next level of agile maturity. It involves automatically
pushing the code to a server once it successfully passes the CI process. Once this
process is in place, the need for a hardening sprint is eliminated.
Ideally, both Continuous Integration and Continuous Delivery are combined into what is
known as CI/CD. A big advantage of the CI/CD process is the immediate feedback
provided by the process. Automated reports are generated whenever a developer
finishes writing code and “checks it in”. A sample of a report is shown below:
One of the tenants of agile is to “fail fast and avoid technical debt”. The generated
reports, combined with historical data, allow teams to immediately identify issues with
their code. Forward thinking organizations track trends from these reports and look for
continuous improvement in each category with each sprint. Alarms can be set such that,
2. even though nothing is “broken”, the build will still fail because certain quality metrics are
not met or have dropped when compared to the last build report.
In conclusion, a properly implemented CI/CD process allows teams to proactively
monitor their development process and ensure that the end product is of the highest
quality.
Technical debt – code that becomes increasingly fragile and difficult to maintain due to
ongoing unresolved quality or technical issues. The result is that developers become
hesitant to make changes due to unintended consequences.