Development Process of Agile

The agile developmental process is being increasingly adopted by internationally and plays the main role in various development approaches. It also utilizes iterative development that is widely used in a variety of industry on research projects. The traditional developmental processes are not much effect the change in requirement. It also makes customers have more involvement in the development process. Here in this paper, we identify that agile methodology had on development process with respect to quality within the organization.

As we notice, software development is being expanded. Software’s are merged into many various fields, and it is becoming more complex. Changing needs of customers are making it more difficult is growing technology. Older software development process is not able to satisfy the new needs of the market in the better way. As a result, new software development methods are evolved, as agile methodologies, mainly to find a solution to such problems. The new methods include modifications to software development processes, to make them more flexible to the users.

This paper has the following structure:

• History of agile methodology.
• Agile developmental process.
• Explains the agile developmental process
• Limitation of agile methodology
• Conclusion of paper

What is agile?

Agile development is a group of software development methodologies and this is based on iterative development. Where the requirements and solutions through collaboration between self-organizing cross-functional teams. Agile processes or agile methods generally they promote a disciplined project management process that frequently encourages the inspection and adaptation, and a leadership philosophy that frequently encourages the teamwork, accountability, and self-organization.

History of agile methodology

The agile programming is known that it can be followed back to 2001. At Snowbird ski resort in the Wasatch Mountains of Utah, a group of seventeen people meets to have fun, but also to find a common issue that was too much discussed which was not achieved. They were different currents of improving software techniques. They were adepts of Extreme Programming, SCRUM, DSDM, Adaptive Software Development, Crystal, Feature-Driven Development, Pragmatic Programming and other agile techniques, joined together by the need for an alternative to documents driven, heavyweight software development processes.

All methodologies of software have the common ground of recalibrating themselves and their result, the code, will be a crafter to the user’s desire by asking for input on each stage of evolution. This is also known as sprint or iteration. The sprint is organized into three parts: code creation, user review and setting new goals. Because sprints repeat code continually grows in functionality, this style of programming – Agile – is described as “iterative” and “incremental.”

With the advantage teams can necessities with coding, the process of creating, maintaining and rewriting is been reduced. Thus the customer will not be bored much and fewer errors can be slipped into this process. The agile team can focus on smaller tasks, delivering quality and almost bug-free and also having all the time the good feeling of making progress. While agile teams develop within the short, repeatable work cycles, the owners or users have all the time the opportunity to look at the results, test them and ensure that the product being created really matches the customers’ need. Bottom line, we can conclude that agile programming helps companies build products their customers want.

What is agile software development?

Agile development is a term for several iterative and incremental software development methodologies. Some of the most popular agile methodologies include extreme(XP), scrum, crystal, dynamic systems development method, lean development, and feature-driven development (FDD).

Agile testing methodology:

There are seven agile development processes

Extreme programming:

• It relies on goal-oriented approach.
• It is based on key activities.
• Panning which is done by user stories and ordered by customer value.
• Design
• Coding is based on focuses on unit tests to exercise stories.
• Testing (the unit test is created before the coding is implemented, they used the automated testing framework to encourage the uses of regression testing, regression and validation testing is done on daily basis, acceptance testing features and functions are focused by the customers.

Adaptive software development:

• They arise the self-organization.
• When they emphasize self-organizing teams and interpersonal collaboration, these both individuals and team learning.

Phases:

• Mission
• Component-based
• Iterative
• Change-tolerant and risk-driven
• Speculation
• Learning (implementing the test, focusing on feedback).

Dynamic system development method:

• In DSDM, they usually provide a framework for maintaining the systems and building.
• They provide 80% of the project can be delivered in 20% required to deliver the entire project. (This system is known as a Pareto principle).
• To move to the next increment the functional of each increment only delivers enough.
• They use time boxes, by using this time boxes we can determine how much functionality will be delivered in each increment.
• Guiding principles.
• Teams are very empowered to make decisions.
• Life cycle activities: feasibility study, business study, functional model, design, and implementation.

Scrum:

• Scrum principles:
• The small working team is used to maximize communication, minimize overhead and maximize sharing of information knowledge.
• The term processes must be adaptable to both technical and business challenges to ensure best product produced.
• Hence, the frequent increments are yield that can be inspected, adjusted, tested, documented and built on.
• Once the product is built, testing and documentation are performed.
• Scrum meetings (daily 15 minutes meeting discussing what was done at the last meeting and what will be done by the next meeting).
• Demos (for customer satisfaction).

Crystals:

• It’s always cheaper and faster to communicate face-to-face.
• As projects grow up, teams become larger and methodologies become heavier.
• Some degree of formality will need to be introduced in parts of the methodologies, as projects grow in criticality.
• Once the feedback and communication are become more efficient, automatically the need for intermediate work products is reduced.
• A discipline, skills, understanding counter processes, formality, and documentation are very important.
• Team members who are not on the critical path, they can exceed their time to help the members who are under the critical path.
• Strategy incremental development used with 1 to 3-month timelines.

Feature driven development:

• A practical process model for object-oriented software engineering
• The feature is a client-valued function, can be implemented in two weeks or less
• FDD Philosophy
• Emphasizes collaboration among team members
• Manages problem and project complexity using feature-based decomposition followed integration of software increments
• Technical communication using verbal, graphical, and textual means
• Software quality encouraged by using incremental development, design and code inspections, SQA audits, metric collection, and use of patterns (analysis, design, construction)
• Framework activities
• Develop overall model (contains a set of classes depicting a business model of the application to be built)
• Build features list (features extracted from the domain model, features are categorized and prioritized, work is broken up into two-week chunks)
• A plan by feature (features assessed based on priority, effort, technical issues, schedule dependencies)
• Design by feature (classes relevant to feature are chosen, class and method prologs are written, preliminary design detail developed, owner assigned to each class, owner responsible for maintaining design document for his or her own work packages)
• Build by feature (class owner translates the design into source code and performs unit testing, integration performed by the chief programmer)

• Practice-based methodology for effective modeling and documentation of software systems in a light-weight manner.
• Modeling principles.
• Model with a purpose.
• Use multiple models.
• Travel light (only keep models with long-term value).
• Content is more important than representation.
• Know the models and tools you use to create them.
• Adapt locally.
• Requirements gathering and analysis modeling.
• Work collaboratively to find out what the customer wants to do.
• Once the requirements model is built collaborative analysis modeling continues with the customer.
• Architectural Modeling.
• Derives preliminary architecture from the analysis model.
• The architectural model must be realistic for the environment and must be understandable by developers.

Agile software development methods were developed to provide more customer satisfaction to reduce the development lifecycle, and also to accommodate changing business necessities needed during development.

Agile methodology increases the flexibility, agility and to be more the environment where software development projects are present. The idea behind agile methodology would likely to reduce large projects into small projects which is more flexibility. It’s proven that agile provides software development with minimum risk where projects requirement is well developed.