In this article Prerana Patil gives us a rapid overview of the core ideas of Agile Software Development. The article talks of the features of agile, when to adopt it and when not to. It then goes on to describe the agile process and the steps involved in adopting agile in an organization. An easy to understand tutorial that focusses on the key ideas and points in agile adoption without getting into any of the fluff associated.

—

The literal meaning of the word agile, an adjective, is “Characterized by quickness, lightness, and ease of movement.” So this indicates that Agile Software development is about fast delivery of software with more ease of development. Classically, “Agile software development is a style of software development that emphasizes customer satisfaction through continuous delivery of functional software”.

Key Features of Agile Software Development:

• Iterative: Entire application is distributed in incremental units called as iteration. Development time of each iteration is small (couple of weeks), fixed and strictly adhered to. Every Iteration is a mini increment of the functionality and is build on top of previous iteration.
• Active Customer involvement: There is lot of client involvement and face-to-face interaction. Every iteration is tested and approved by client. The feedback obtained is implemented in subsequent iterations; thus minimizing risk and ensuring higher client satisfaction.
• Feature driven: More emphasis is on providing the required features in the application. 80/20 principle is applied to decide the 20% features which would be used 80% of the time.
• Fixed Time: Each iteration has a fixed time span in which it is delivered.
• Priority based delivery: Features are prioritized depending on customer need, development risk etc. High priority features are developed first. After every iteration, the project priorities are re-evaluated.
• Adaptive: The methodology in general is very adaptive, so that the application that is developed can cater to inflow of new requirements throughout its development. Goal is not to remove the uncertainty in the very beginning, but is to adapt to the changing needs.
• Empowered Teams: The project teams are generally small and have lot of interaction and communication. Since entire team is actively involved, team is empowered to take decisions. No separate team to manage project.
• People Centric: More emphasis is on using the adequately skilled people to do the development than on following the processes. The documentation and other non-development activities are minimized and more time is devoted to development and testing.
• Rapid development: Generally the development is done rapidly using light weight development technologies.
• More disciplined: Being rapid, everything has to be delivered correctly first time. So the process involves lot of team and self discipline Thus, it requires highly skilled and organized team members.
• Simplicity: Emphasis is on keeping things as simple as possible and being open to change.

Why should Agile Software Development be considered:

Benefits to the Customer

1. Customer is more actively involved, and gets higher priority
2. He gets to know regular and frequent status of the application
3. Requirements are accepted after each iteration
4. Since the methodology emphasizes rapid delivery, time-to-market is less. So the key functionalities can be available to use sooner.
5. Delivery is defined by fixed timescale. So customer is assured of receiving some functionality by a fixed time period.
6. More Testing is done, so better software quality is delivered

Benefits to the Project Teams

1. Project teams are involved more actively in all the stages, have to ask right question. The teams collaboratively take the decisions and are more empowered.
2. Since the development is Incremental, teams can focus on the specific requirements at any given point of time.
3. More emphasis is on developing the application only, and not on documentation. Simple and minimal documents are used to exchange the views
4. The teams receive frequent feedback as the testing is integrated; so the rework is reduced
5. Less time is spent in gathering requirements as all the requirements are not gathered upfront and are implemented as and when they arise.
6. So less time is required for planning.
7. Less cost of development as rework, management, documentation and other non-development work related cost is reduced.
8. Teams develop applications collaboratively and in cooperative environment.

Agile vs. Traditional Software development

Table below compares Agile methodology with traditional software development methodology of various parameters:

Parameter	Traditional	Agile
Requirements	Fixed	Evolve
Time & People	May vary	Fixed
Customer Involvement	Before, After	During
Negotiable	Estimates	Schedule
Testing	After code	Integrated
Feedback	After	During
Concentration on	Processes; reviews	Workable software
Focus	Plan driven	Value driven
Stages	Requirements, Design, Code, Test, Feedback	(Plan-do-adapt)*

Challenges involved in Agile Software development

• Agile is difficult as
  It Requires more TESTING & active CUSTOMERS involvement
  It impacts Management more than Developers. Management had to be more open, be actively involved in development process and more importantly allow the teams to take decisions.
• Agile is More disciplined
  The code may be integrated continuously, sometime after every update in source code repository. To ensure the application is always in workable state, all the code has to work fine always.
  Higher(?) technical and managerial expertise is needed.
  Each feature has to be completed before moving on to the next.
  Needs teams and self-discipline
• More Planning is needed
  Since the planning is done frequently (for each iteration), and the plan is updated as and when needed more focused planning needs to be done. The plan has to be adaptive to meet the changing requirements.

When to (not!) use Agile

Before going Agile; Ask

1. Is functionality split-able
2. Is customer available
3. Are requirements flexible
4. Is it really time -constrained
5. Is team skilled enough

Agile software development methodology is best suited for a project with

1. Frequently changing requirements
2. Not highly distributed environment
3. Client open to lot of involvement and ready to invest time

To implement Agile methodology following support may be needed

1. Organization Support:
   Culture: open to change
   Hierarchy: ready to empower teams
   Bureaucratic : less focus on processes & steps
2. Infrastructure Support:
   Preferable the team and the customer should be co-located
   Hardware support for continuous integration, pair programming and other practices
3. Team Support:
   Highly skilled & flexible people with passion should be involved
   More & frequent testing is needed

Though agile software development is suited for small project, many teams for e.g British Telecom has successfully implemented a huge project, involving several hundred developers situated in UK, Ireland and India, using the Agile Methodology. This indicates the strength of the concept.

The Process of Agile Software Development involves the following:

1. Starts with a kick-off meeting
2. The known requirements are understood and prioritized. The development is plan is drawn accordingly.
3. Relative complexity of each requirement is estimated
4. Sufficient design using simple diagrams is done
5. Test Driven Development (TDD) approach may be used. TDD emphases on “writing test first and then writing code to pass the test”. It can help in avoiding over-coding.
6. Development is done, sometimes in pairs, with lot of team interaction. Ownership of code is shared when pair programming is done.
7. The code is tested more frequently. Sometime a dedicated “Continuous Integration” Server/Software may be used to ease the integration testing of the code.
8. Depending on the feedback received, the code is refractor. Refactoring does not impact the external behavior of the application but the internal structure may be changed to provide better design, maintainability. Some ways of refactoring may be add interface, use super class, move the class etc.

The iteration life cycle stages are illustrated below:

Using Agile

Some of the artifacts that can be used while doing Agile planning, estimation & designing are:

Domain Model: Domain Model can provide and overview of sample entities involved in the application and their interactions with each other. For an employee working for a department and knowing some skills the domain model would be:


UI Prototype: User Interface Prototype can be created while designing the sample screens. UI prototype can be as simple as screen layouts drawn whiteboard.

Story Board: Story board depicts the application flow between the screens. It can also be called UI Flow Diagram.
The Story board below depicts the various screens accessible to Employee & Admin after Sign in:

User Stories: User Stories are simple statements using which user can tell the features needed in the application. They are the system requirements in user’s words.

For e.g Admin user may want to add employee details as a new employee joins the organization.
Prioritize Once user stories are identified, they are prioritized on the basis of user need, risk involved in developing it etc.

Release Plan: After prioritizing the user stories, a release plan will be decided which would include the number of iterations, features to be included in a Iteration. Release date would be decided on the basis of estimated time needed for the iteration.
Sample release plan can be:

Iteration	Features	Release Date
0	Setup envi.	10-June-08
1	All priority 1 stories	23-June-08
2	All priority 2 stories	26-June-08
3	All priority 3 stories	..
4	All priority 4 stories	..

Story point Estimate: To estimate the efforts needed for providing the functionality, story points may be allocated against each user story. The story point would indicate the relative complexity of the user stories.

For e.g. Searching an employee details by employee id may need double the efforts than needed for adding or editing an employee.
The time needed for developing a feature of 1 story point an be decided to derive actual estimates.
For e.g if 1 story point would take 3 days, means “Add Employee” functionality can be provided in 3 days.
Table below lists the User Stories, their relative Priorities & associated story points:

User Story	Priority	Points
Add Employee	1	1
Edit Employee	2	1
Delete Employee	3	1
Search Emp by ID	1	2
Search by Dept	3	3
Search all in a dept knowing a skill	4	5
	Total	13

So all user stories with priority 1 have to be included in iteration 1, then estimated story points covered in Iteration 1 would be 3 and assuming each story point takes 3 days to develop it would take 9 days to release Iteration 1. Other estimation techniques like ‘ideal day’ may be used.

CRC Card : CRC cards indicate the details of Classes, their Responsibilities and their Collaborations with other classes.
Sample CRC Cards may look like:

Many other artifacts like Class diagram, other UML diagrams may be used depending on the need

Various Agile Software development methodologies

Some well known Agile Software Development methods are:

1. eXtreme Programming: eXtreme Programming works on the principle of Simplicity, Communication, Feedback and Courage. The application is designed such that it is adaptive to changing requirement and is simple. Lot of client interaction and communication in team are key factors which help in development of adaptive application.
2. Scrum: In Scrum, a list of all the deliverables for the project, named backlog, is identified and is continuously updated. Project is divided into small units named sprint, lasting 2-4 weeks generally. Deliverable, which is visible and usable increment, is decided for each sprint. Active communication in the team and follow-up using the backlog help and ease the development.
3. Agile Modeling: Agile Modeling is used for modeling and documentation of software systems. It involves the software values, principle and practices which lead to software development in more flexible manner.
4. Adaptive Software Development (ASD): Adaptive Software development works on the principle of continuous adaptation. It uses repeated series of speculate, collaborate and learn cycles to develop the application.
5. Crystal Clear and other Crystal methodologies: Crystal family of methodologies is people-centric and focuses on enhancing the work of people involved. The logic is to start with small tasks and then build them up into larger ones. The overhead activities are reduced and efforts are diverted to work building. It’s a collaborative process involving tracking and iterations.
6. Dynamic Systems Development Methods (DSDM): DSDM is based on Rapid Application Development (RAD) and can be used for projects which have tight schedule and budget. DSDM works on pareto principle-80/20 rule i.e. 80% of the business benefit comes from 20% of the system requirements. Therefore DSDM starts implementing this first 20% of system requirements to meet 80% of the business needs. And then it progresses to cover rest of requirements.
7. Feature Driven Development (FDD): The main purpose of FDD is to deliver tangible, working software repeatedly in a timely manner. The development process involves 5 activities: Develop Overall Model, Build Features List, Plan by feature, Design by feature, Build by feature. Milestones are identified and progress is tracked on basis of the achievement of milestone.
8. Lean software development: Lean software development is based on lean manufacturing principle. The principles followed are:
   1. Eliminate waste i.e. anything that does not add value to customer.
   2. Amplify learning by doing and testing things rather than documenting them and them implementing.
   3. Decide as late as possible thus keeping all the possible the options open as long as possible in the life cycle.
   4. Deliver as fast as possible. It works on basis of the fact that sooner the end product is delivered, sooner is the feedback received and sooner it is implemented in next iteration.
   5. Empower the team by keeping people motivated.
   6. Build integrity in by keeping the code simple and avoiding repetitions.
   7. See the whole so the problems can dealt at application level, product level, instead of dealing with them at minute levels.
9. Agile Unified Process (AUP): AUP is simplified version of Ration Unified Process (RUP). It distinguishes Development Release iterations from Production Release iterations. It works on building up a model, implementing, testing and deploying it and then followed by configuration management. The focus is on the covering the high-value activities rather than covering every possible thing

Author:Prerana Patil has over 5 years of experience of working with Java and Java Enterprise Applications. She is currently working in Technology Practice group of Oracle Financial Services (formerly i-flex solutions limited). She is a Masters in Computer Science from UOP and loves exploring the new things in software world. She has been involved in various trainings on Java, Java EE and can be reached at prerana.patil AT gmail DOT com