The most important concepts of agile methods in software development

A good definition of agile methods was made by Pressman (Software Engineering A Practitioner’s Approach):

“Agile software engineering combines a philosophy and a set of development guidelines. The philosophy encourages customer satisfaction and early incremental delivery of software; small, highly motivated project teams; informal methods; minimal software engineering work products; and overall development simplicity. The development guidelines stress delivery over analysis and design (although these activities are not discouraged), and active and continuous communication between developers and customers.”

It would be a great irresponsibility to write about the main concepts of agile methods without quoting the principles of the agile manifesto, from “agilemanifesto.org”.

Following are the 12 principles that are generic to agile methods, regardless of which one is used.

1. “Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
2. Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage.
3. Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.
4. Business people and developers must work together daily throughout the project.
5. Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
6. The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.
7. Working software is the primary measure of progress.
8. Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
9. Continuous attention to technical excellence and good design enhances agility.
10. Simplicity--the art of maximizing the amount of work not done--is essential.
11. The best architectures, requirements, and designs emerge from self-organizing teams.
12. At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.”

According to Pressman, regarding the 12 agile principles:

“Not every agile process model applies these 12 principles with equal weight, and some models choose to ignore (or at least downplay) the importance of one or more of the principles. However, the principles define an agile spirit.”

With the definitions of Pressman, in addition to the 12 fundamental agile principles mentioned above, from “agilemanifesto.org”, we can complement with some concepts that are the core of agile methods.

• A project involves people and change, especially when we talk about constant deliveries. In this way agile methodologies work with highly motivated teams and support for changes during the development process.
• Agile development is incremental, that is, we do not make a complete plan with everything we must do to start development, let alone develop the product without contact with the customer, instead, we develop incrementally, that is, the product is done slowly and delivered constantly.
• Early system increments can provide high-priority functionality, so customers will soon be able to get system value during their development.
• The constant contact with the customer also generates knowledge, because the team will understand the business, to develop it, to do it with greater speed and precision.

In addition to the fundamental concepts, agile development needs agile practices, which as concepts are also fundamental for success:

• Use of TDD(Test-driven development): technique that allows continuous testing and not only the completion of the system, improving the technical quality of the product;
• Incremental Planning: Instead of planning software as a top, we can plan in a systemic way, that is, define the whole, but plan in stages, performing incremental planning. The increment requirements can be recorded in cards, which some methodologies call user stories, here we determine the priority that the client defines and also the time that the developers define as necessary for the development;
• Increases developed in reduced time: small releases, delivering functionalities in months or weeks, instead of years;
• Using Refactoring: Improving code and making it easier to maintain constantly;
• Continuous integration: when the increment is ready, it is integrated into the system as a whole, that is, it is done daily.

In this chapter, we have seen the basic concept of agile methodology, which aims to improve productivity. We have seen that the important of agile methodologies is the focus on continuous communication with the customer, on constant delivery and on the development team. Note that it changes the traditional concept, in which we first plan the whole product, with a complete analysis, functional and nonfunctional requirements of the entire product, and then start development, which can cause problems, since a bad requirement will only be noticed when the product is delivered months later.

In the agile methodology, we only plan what will be done in that increment, with details, so that we can develop and deliver to the client. If the requirement has been misinterpreted, it can be quickly corrected, as the incremental time is course and the correction is fast, different from when the product was delivered complete, and that many requirements errors appear, many things to be corrected and improved, leading team time and demotivation.