While much has been said and entire volumes have been written regarding Defensive Programming techniques, few authors have broached the topic of Aggressive Programming. Whereas Defensive Programming finds its ideal environment in high-security and mission-critical environments, Aggressive Programming is an excellent technique for new research-focused projects or initial prototypes in iterative system development.
The primary focus of Aggressive Programming is to churn out deliverables in as short a time period as possible, and focus on building the primary functionality and most challenging code before filling in the details. Aggressive Programming works well during the initial development stages of a project, where functionality may change depending on required interactions with other components. While some development methodologies might first plan the entire software architecture to a high-level of detail, Aggressive Programming instead uses Agile development methods to help speed time-to-market and focus on creating a working prototype.
Aggressive Programming techniques are often necessary in new research projects, where the final architecture cannot be resolved up-front. When creating an entirely new technology, such as when IBM developed one of the first relational databases, it’s often necessary to give up aspirations of a full system design documentation, and instead simply dive into the code and resolve problems during the development.
Upon creation of the prototype, the key leap in development is then transforming that prototype into the final product. In the previous example of IBM’s System R database, when developing the final product, the development team disposed of all the initial prototype code and designed the final database from scratch, using the lessons they had learned during the two years of the prototype development. Teams with smaller budgets might not be able to throw away two years of code, and instead need to adapt the prototype into the final application by applying a rigorous checklist-based analysis to each system component, ensuring security, scalability, reliability, and maintainability needs will be met throughout the project lifecycle. The quality of the software development work in the initial prototype will often influence how much of the code will be transferrable; other times it may boil down to luck in choosing the correct initial design patterns and architecture.
While Aggressive Programming does offer benefits in speed of development and time-to-market, it’s also important to balance those aspirations with a culture of testing and “good code.” The goal is not to “slap something together” and ignore exception handling, error handling, and validation; instead the goal is to break down development into smaller, manageable parts that can be completed quickly and modified as necessary to interact with other logical components in the system architecture. In many ways, Aggressive Programming could really be considered a derivative of Agile Development, with simply more of a focus on the prototype.
Written by Andrew Palczewski
About the Author
Andrew Palczewski is CEO of apHarmony, a Chicago software development company. He holds a Master's degree in Computer Engineering from the University of Illinois at Urbana-Champaign and has over ten years' experience in managing development of software projects.