Call Us: +91-253-2314379
Software Development Methodologies
A decades-long goal has been to find repeatable, predictable processes or methodologies that improve productivity and quality. Some try to systematize or formalize the seemingly unruly task of writing software. Others apply project management techniques to writing software. Without project management, software projects can easily be delivered late or over budget. With large numbers of software projects not meeting their expectations in terms of functionality, cost, or delivery schedule, effective project management is proving difficult.

  • Traditional Software Models (Waterfall, V-Model,RUP, CMM ):
    1. Waterfall Processes:  This is the classic process model, with a linear and sequential method that has goals for each development phase. The waterfall model simplifies task scheduling, because there are no iterative or overlapping steps. One drawback of the waterfall is that it does not allow for much revision.
    2. V-Model:  The V-model can be thought of as an extension of the waterfall, mapping test phases to the phases of the development cycle.
    3. Rational Unified Process (RUP):  RUP is an adaptable process framework allowing organizations to select elements of processes that are most relevant for their project.
  • Iterative Processes:  Iterative development prescribes the construction of initially small but ever larger portions of a software project to help all those involved to uncover important issues early before problems or faulty assumptions can lead to disaster. Iterative processes are preferred by commercial developers because it allows a potential of reaching the design goals of a customer who does not know how to define what he wants.

  • Extreme Programming:  XP, is the best-known agile process. In XP, the phases are carried out in extremely small (or "continuous") steps compared to the older, "batch" processes. The (intentionally incomplete) first pass through the steps might take a day or a week, rather than the months or years of each complete step in the Waterfall model.

  • Spiral Model: The key characteristic of a Spiral model is risk management at regular stages in the development cycle. In 1988, Barry Boehm published a formal software system development "spiral model," which combines some key aspect of the waterfall model and rapid prototyping methodologies, but provided emphasis in a key area many felt had been neglected by other methodologies: deliberate iterative risk analysis, particularly suited to large-scale complex systems.

  • Agile Software Development:  Agile processes seem to be more efficient than older methodologies, using less programmer time to produce more functional, higher quality software, but have the drawback from a business perspective that they do not provide long-term planning capability. In essence, they say that they will provide the most bang for the buck, but won't say exactly when that bang will be.
  • Scrum (Development): Scrum is an iterative incremental framework for managing complex work (such as new product development) commonly used with agile software development.

Agile Software Development
  Software Development at Neo Interactives has adopted the Agile Software Developement Technology and uses it effectively depending upon the scope of the project and customer requirements. Adapting to Agile methodology has proved to achieve timely delivery of projects, customer satisfaction and moreover welcomes changes in requirements if needed by the customer, even in the late stages of development.

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 Agile Software Development should 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:

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) approaches 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 behaviour 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:

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:

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.


Home  | About Us  | Contact Us  | FAQ  | Site Map  | Privacy Policy  | Disclaimer  | Terms & Conditions    
  Copyright © 2012 Neo Interactives, All Rights Reserved.