Traditional large software development projects are risky. They are notoriously hard to estimate and have a high rate of failure. We mitigate the risk of large scale development by building every system as a series of small things. Using the Agile methodology, we deliver working software iteratively. We work with our customer to prioritize features, and we build the most important features first. The system grows more sophisticated and feature-rich with each iteration, but each iteration can stand on its own. The small things we build grow organically into complex systems.
Large-scale Agile software development adheres to the basic principles of Agile:
Scaling agile software development means we break a large, complex project into small, simple components. The customer tells us which are most important to address and in what order. Basic functionality usually gets built first; bells and whistles are added later.
Simple and Fast
By keeping things small, we keep them simple, and we build them fast. If a concept turns out to be flawed, we find out quickly and learn from the failure. These “failures” very often result from the difficulty of translating vision into reality. Sometimes developers don’t quite understand what customers want, but very often customers can’t know exactly what they want until they see it expressed in software. The software may do exactly what was asked of it, but not, it turns out, what was really needed.
By breaking the problem into small chunks, we can test assumptions thoroughly and correct course quickly.
Large Scale Agile Architecture
In large scale agile development, an architectural vision and direction are established at the outset but the details are worked out through modeling and testing by the whole team as the project proceeds. Iterative and collaborative elaboration results in a more robust architecture than “big design up front” achieves.