An agile process is highly driven by the customer requirements and considering the customer as a part of the development team thereby adapting to changes after delivering software increments. The emphasis is on construction rather than the intermediate work products recognizing that plans are short-lived and changes are always happening.
Principles of Agile Process
- Customer satisfaction through early delivery of software.
- Accommodate changes late in project without dramatic cost and time impact.
- Business people, developers and customers work together as a team.
- Gives developers a sense of support and trust in their skills.
- At regular intervals, the team reflects on how to become more effective and adjusts
Concept of Agility
- Rapid and adaptive response to change.
- Effective communication among all stakeholders.
- Adopts customer onto the team.
- Organizing a team that is highly motivated and uses informal methods.
- Rapid, incremental delivery of software and low intermediate work products.
Extreme Programming is the most widely used agile process and it follows an object-oriented approach.
The foundation of extreme programming are the following five values
- Communication – close and informal communication between developers, customers and stakeholders. Focus on continuous feedback and hence avoiding voluminous documentation.
- Simplicity – address only present needs without getting bothered about future needs. Create simple design accordingly.
- Feedback – feedback from software itself after unit testing, feedback from customer after increment delivery, and feedback from software team members regarding next increment plan.
- Courage – courage to design for present scenario and keeping in mind that future requirements may change rapidly hence should not design for future now.
- Respect – all the members of team including customer develop respect for each other by following values mentioned above and it should grow over time.
- Begins with the creation of user stories.
- Agile team assesses each story and assigns a cost.
- Stories are grouped to build deliverable increment.
- A commitment is made on delivery date.
- After the first increment project velocity (number of stories implemented in first release) is used to help define subsequent delivery dates for other increments.
- Follows KIS (Keep It Simple) principle.
- Encourage the use of CRC (Class-Responsibility-Collaborator) cards to identify and organize object-oriented classes.
- For difficult design problems, suggests the creation of spike solutions – an immediate operational prototype.
- Encourages refactoring — changing the internal program without affecting external behavior of code.
- Develop unit test procedures for each stories before starting to code.
- Uses the concept of pair programming where two people work together at one workstation to create code for a story.
- Unit tests are implemented for each unit.
- Code or pair programmers are integrated with others along with implementing smoke testing.
- Unit testing should be implemented in a repetitive nature which will encourage regression testing.
- Integration and validation testing is done on a daily basis.
- Acceptance tests (Customer tests) are done where overall features are reviewed by the customer.
Industrial XP(IXP) combines the properties of XP and an additional focus on management and
upgraded technical practices. It conducts a readiness assessment of the project before
commencement, considers project community, project chartering, test-driven management,
the specialized technical review called retrospectives and encourages continuous learning.
Adaptive Software Developement
- For building complex software.
- Focus on human collaboration and self-organizing team.
- Three Phases : Speculation, collaboration and learning.
Project is initiated and adaptive cycle planning is conducted where customer requirements, delivery dates, and other constraints are considered to define several increments. After each cycle, the plan is reviewed and adjusted.
Create a work environment that supports people to put their skills and ideas. Cultivate trust among members and everyone should be able to criticize without hatred, assist each other, work hard, contribute skills and communicate problems for collaborative solving.
During each cycle, the focus is given to learning from outcomes to improve the level of understanding through focus groups, technical reviews and project postmortems.
SCRUM includes requirements, analysis, design, evolution and delivery but within each activity
incorporates a set of process patterns related to a tight timeline, changing requirements etc.
Requirements are prioritized to create a backlog. Items can be added anytime to the backlog and the backlog assessed and updated whenever required.
Sprints are work units required to complete requirements from backlog which should be fit into a time box, normally 30 days. Changes are not introduced during a sprint.
Meetings are held daily,, usually 15 minutes to analyze work done since the last meeting, problems encountered, and plan for the next meeting. Scrum master leads the meeting.
Software increments are delivered to be evaluated by the customer.
Dynamic Systems Development Method (DSDM)
DSDM is used for projects having tight timelines by using prototyping in a controlled environment. Implements Pareto Principle. (80 per cent of applications delivered in 20 per cent of the time that would have taken to complete the full project)
DSDM lifecycle defines the following activities
Basic requirements are assessed to determine whether the project is viable.
Functional requirements are established and basic application architecture is defined.
Functional Model Iteration
Incremental models are delivered, feedback and additional requirements are gathered.
Design and Build Iteration
Revisit prototypes built during functional model iteration for ensuring and assessing their value.
The latest software increment is implemented in an operational environment, may not be 100 per cent complete, changes may be requested by customers
Crystal methods are a family of software development methodologies. They are mainly focused on people and their interactions. Considering people as the most important project management resource, Crystal Methods go by a colour-coding pattern.
Since each project has unique features software engineering practices must be customized for
each project type and hence, several methodologies are prevalent which are included in
Feature Driven Development
The feature is a client-valued function that can be implemented in two weeks or less. It emphasizes collaboration, decomposition of project based on features followed by integration, effective communication.
In addition software quality assurance activities, design and code inspections, pattern usage
are all implemented. Hence, FDD emphasis on project management guidelines and techniques than other agile methods.
Lean Software Devlopment
Focuses on optimizing development time and resources, eliminating waste, and ultimately delivering only what the product needs.
- Eliminate waste – Don’t add extra features or functions, be keen on assessing cost and schedule, ensure testing finds many errors as possible.
- Build quality – Avoid creating defects, use refactoring if change is needed.
- Create knowledge – encourage systematic learning through development cycle.
- Defer commitment – Postpone irreversible decisions to be implemented for the last moment.
- Deliver fast – consider the customer needs and value their time thereby delivering increments fast.
- Respect people – Respect skills and talent of individuals and nurture their relationship.
- Optimize the whole – Enhance the activities and steps if needed by assessing as a whole.
Agile Modelling (AM)
Applied to large, business-critical systems where better understanding, effective partitioning of project and quality is crucial. It is a collection of values and principles for modelling software in an effective and lightweight manner.
- A model with a purpose. (always keep the aim in mind)
- Use multiple models. (choose those models that give value to the system)
- Travel light. (keep only those models that provide value)
- Content is more important that representation. (content of the model chosen should be strong)
- Know the models and tools used. (strength and weakness of models and tools should be known beforehand)
- Adapt Locally. (modeling should be adapted to needs of agile team)
Agile Unified Process
Agile Unified Process promotes a serial approach in large and an iterative approach in small. The Unified Process(UP) activities inception, elaboration, construction and transition are considered as serial in Agile Unified Process(AUP) but within each activity the team iterates for agility. Each AUP iteration addresses the following activities,
- Modeling – models should be barely good and doesn’t need to be perfect
- Implementation – source code is generated based on models
- Testing – series of tests are done to uncover maximum errors
- Deployment – software increment is delivered and feedback is collected
- Configuration and project management – change management and risk management is considered. Project management tracks the progress of project.
- Environment management – tools and other support technologies must be coordinated and managed