Agile software development is a process that enables the quick response to rapidly changing requirements using flexible design principles, patterns and practices. The rationale behind agile development is to find a useful compromise between no process and too much process, providing just enough process to gain a reasonable payoff.
Agile design is the process of using several principles, patterns and practices as part of the whole software development methodology that improves the software infrastructure and simplicity. Each unit of software that is supplied at the end of a development iteration is delivered coded, tested and is a usable piece of software.
A story point is an arbitrary and course unit of measure that is based on the breaking down of software requirements into deliverable items; this unit of measure is consistent and allows the development team (and client) to identify the velocity of the team early in the project. This has the effect of understanding how quickly the software will be developed and gives a realistic timeframe around delivery.
Communication, knowledge, skill and teamwork are integral ingredients of an agile team. In order for agile development to succeed, the development teams must be efficient, effective and work well together. Importantly, there is no individual ownership of code. The team as a whole is responsible for the quality and appropriateness of each module that is delivered.
Large cumbersome documentation is thankfully a thing of the past. Succinct and high-level documentation focuses on the overall design rationale and structure of an agile system. Code is intentionally written in a self documenting style in the simplest way possible to make it work. Unit tests also function as a significant proportion of the detailed documentation.
An agile development approach brings the client into the development team. The project sponsor and business analysts are considered an integral part of the team and are accessible at all times. Development is usually carried out on site where constant collaboration and relationship building is encouraged.
Short cycle development iterations are used to make regular drops of completed story points into a testing environment, allowing the client to obtain a tangible view of progress.
The success of any project relies heavily on the ability to meet challenges and respond quickly to change. Direct collaboration among the client and the development team enables the client to see how a system is shaping up, which gives them the opportunity to request changes as development progresses, delivering a better and more appropriate end product.
Change is considered inevitable and is consciously embraced. Unit testing provides a high degree of confidence in allowing code refactoring.
Test Driven Development encourages the development team to implement functionality in the most straight forward way possible. Unnecessary complexity is avoided. A simple re-usable unit test is written first that will fail until the developer writes implementation code that makes the test pass.
This approach encourages the developer to focus on the requirement, and not get distracted by a complex and over engineered solution. Over the course of the project, a suite of re-usable unit tests will be created that provide confidence in the team’s ability to accommodate changing requirements.
- Ability to make changes throughout the project
- Collaborative approach ensuring customer satisfaction
- Shorter and frequent software deliveries
- Robust software using the highest quality code, design and architecture
- Streamlined software that is flexible, changeable and maintainable
- Better communication between client and the development team
- Self-directing teams that work together as a whole
- Adaptive and Predictive
- Visible, quick, coded and tested all the time
- Most important, people oriented and not process oriented