Agile Model

Flexible (Agile) methodology helps to reduce the risk in software development by moving the workflow into several small cycles. These cycles are called iterations and typically last two to three weeks.

An iteration is like a small software project that consists of tasks, each of which improves functionality. These include: drawing up a plan, evaluating requirements, agreeing on a project, writing code, testing, and creating technical documentation.

One iteration is usually not enough for a full-fledged software release. However, the good thing about Agile is that small parts of the project are ready for evaluation at the end of each iteration. This allows team members to change priorities for further work without waiting for the final release.

Applying an “agile” development methodology, you can see a concrete result after each iteration. That is, the developer can understand whether the result of his work meets the requirements or not. This is one of the important advantages of the flexible model.

As for the cons, when using Agile, it is sometimes difficult to estimate the cost of labor resources and the budget of the project. If we take the options for the practical application of the flexible model, then the most famous among them is Extreme Programming (XP).

Java webinar

XP is based on brief meetings of team members that take place every day, and regular meetings (once a week or less). At daily rallies (daily standup) are usually discussed:

  • current results of work;
  • a list of tasks to be completed by each team member;
  • difficulties encountered and ways to resolve them.

Manifesto

Agile is a whole direction in development, so the rules for working on it are declared in a special document - Agile Manifesto. This includes both practices and principles by which the team should work.

Agile Manifesto consists of 4 fundamental ideas and 12 principles.

Key Ideas:

  • collaboration between developers is more important than tools;
  • the working version of the product takes precedence over the documentation;
  • mutual understanding between the team and the customer is more important than the terms of the contract;
  • The original plan can always be changed if necessary.

As for the 12 principles of Agile, here they are:

  • the main priority is the compliance of the finished program with the customer's expectations;
  • changing conditions is allowed at any stage, even at the final stage of development (if this can improve the quality and competitiveness of the software);
  • regular delivery of working versions of the software product (every 14 days, month or quarterly);
  • the key to success is regular interaction between the customer and developers (preferably daily);
  • projects should be built among those who are interested in them, such people should be provided with the necessary conditions for work and all kinds of support;
  • the best way to share information in a team is a personal meeting;
  • the working version of the software is the best indicator of progress;
  • all stakeholders must be able to maintain the desired pace of work throughout the software development process;
  • technical improvement and good design improve flexibility;
  • it is important to keep it simple and not over-create;
  • the best results are obtained from those teams that are able to self-organize;
  • team members should regularly think about ways to improve their efficiency by changing the workflow.

According to the Agile manifesto, a good software development process directly depends on the people who are involved in this process. To do this, you need to organize their interaction as efficiently as possible, create the most organized team.

Methodologies

There are also several methodologies in the Agile Manifesto that explain values ​​and principles:

  • Agile Modeling;
  • Agile Unified Process;
  • Agile Data Method
  • Rapid Application Development (DSDM);
  • Essential Unified Process;
  • extreme programming;
  • feature driven development;
  • Getting Real;
  • OpenUP;
  • Scrum.

Agile Modeling is a collection of principles, terms, and practices that speeds up and simplifies the development of software models and documentation.

The goal of Agile Modeling is to improve modeling and documentation. It is important to note that this does not include coding, testing, or issues related to project control, deployment, and support. However, this methodology includes code review.

Agile Unified Process is a methodology that makes it easy for users to approximate (model). Usually used to develop commercial software.

Agile Data Method - several similar methodologies in which customer conditions are achieved through the cooperation of several teams.

DSDM - this approach differs from the others in that, along with the developers, users of the future product take an active part in it.

Feature driven development is a development methodology that has a time limit: “each feature must be implemented no longer than two weeks.”

It is worth considering that if the use case is small, it can be considered a feature. If it is significant, then it must be divided into several functions.

Getting Real is an iterative methodology in which the program interface is developed first, and only then its functionality is developed.

OpenUP is a development method that divides the project cycle into four stages: inception, refinement, construction, and handover.

According to the principles of Agile, regardless of the duration of the work, it is necessary to provide all stakeholders and team members with a way to get acquainted and make decisions. Thanks to this, it is possible to effectively control the situation and evaluate intermediate results in time. The project plan defines the life cycle, and the final result should be considered a stable release of the application.

As for Scrum, it regulates the rules for managing the development process and allows you to apply existing coding practices with the possibility of adjusting the conditions or making changes. Using this methodology allows you to see and eliminate deviations from the expected result in the early stages of development.

Let's take a look at this in a little more detail...