Informazioni approfondite tecniche / Agile

Iteration that delivers value

Agile development has practical applications in software design, manufacturing, and business. Starting in the 1990s, the pace of business began to accelerate, and software delivery failed to keep pace. It often took years to go from an idea to production software. Industry and thought leaders put their heads together to find ways to develop software more quickly, without the overhead of traditional methods. The Agile Manifesto, an enumeration of key principles for software development first released in 2001, is the result of an effort to establish principles that value people and collaboration over traditional engineering processes and rapid iteration over the traditional “waterfall” software engineering method. Today, the principles of agile development are applied widely in modern application development.

What is agile?

Agile software development promotes well-planned, small iterations by highly collaborative, cross-functional teams. Agile emphasizes continuous self-organization, testing, and monitoring that results in fast, secure, and frequent delivery of software. Agile principles empower you to respond to feedback and make necessary changes at any point in the agile software development lifecycle. A nimble approach to writing and testing code means you can deliver incremental value to your customers and your organization, while also making it faster and easier to respond to changing business needs. And that’s what being agile really means: embracing the iterative nature of continuous innovation through open communication and fast feedback loops between developers, business stakeholders, and customers.

What is agile development?

Agile development grew out of a need for flexibility and speed in modern software development. The central premise of The Agile Manifesto is to promote collaboration, communication, and responsiveness to create “better ways of developing software.” Modern practices such as cloud native app development, continuous integration and delivery (CI/CD), and DevOps are an outgrowth of agile software development processes, integrating software development and application delivery with security and consistency.

In this age of accelerating digital transformation, agile methodologies are a good fit for companies of all sizes and kinds. With its focus on iterative software development, autonomous teams, cross-functional collaboration, early delivery, flexibility, continual improvement, and adaptive planning, organizations can meet unanticipated challenges and shape future projects quickly and securely.

Often the terms agile methodologies and agile frameworks are used interchangeably.

  • Agile methodologies are the distinct practices and principles a team adopts for a given project.
  • Agile frameworks are a more generalized set of agile principles and ideas that teams can adapt and apply to any project.

Agile methodologies

The following methodologies are frequently employed by modern development teams.

  • Agile software development drives the evolution of a product through an iterative development cycle based on ongoing user feedback. With agile methodology, software is built and deployed frequently in order to get immediate feedback as a product takes shape, rather than the waterfall approach of releasing many changes all at once less frequently after a lot of upfront planning.
  • Lean development evolved from the manufacturing industry, but its principles have been adapted to software development and product management. Lean is based on agile values, including eliminating waste, built-in quality, fast delivery, and encouraging communication between people. Lean minimizes the risk of building the wrong thing while maximizing customer value.
  • User-centered design (UCD) develops the product around the user, what the user needs, and how the user wants to use the product rather than forcing the product onto the user and trying to change user behavior. The result is not just about making customers happy, but about ensuring a positive reinforcement loop where happier customers lead to greater business success.

Agile frameworks

There are a number of ways to implement agile practices following the basic principles laid out in The Agile Manifesto. Here are some examples of popular agile frameworks and methods.

  • Scrum is an agile framework that relies on sprints—short, timed iterations of 1–4 weeks—epics, and user stories. Scrum utilizes small, cross-functional teams of 1–10 people made up of a mix of customers, developers, testers, and a project manager. Design, development, testing, and QA is broken down into manageable units to deliver incremental value in a continuous delivery cycle. Teams craft user stories and hold frequent planning and review sessions to track progress and make necessary changes and corrections.
    • Sprints: Each sprint has a planning event, a daily meeting (Daily Scrum), a review, and a retrospective event. Each step of the sprint is assigned a fixed amount of time to completion called a timebox.
    • Epics: An epic is a body of work that can be broken down into specific tasks or on user stories. Epics help organize work into a hierarchical structure.
    • User stories: A user story is a simple description of a product feature that lays out the goals, motivations, and desired user outcome. The product manager keeps a backlog with enough user stories for a team to work on during a 1- or 2-week sprint. User stories help break up software development into small, valuable iterations and are prioritized based on input from users, administrators, and the development team. You can read more about user stories on the VMware Tanzu Developer Center with Tanzu Practices: User Story Writing.
  • Extreme programming (XP) is an agile framework that prescribes short iterations and frequent releases. XP utilizes pair programming, test-driven development (TDD)—which prioritizes testing before code writing or code changes—and continuous integration, testing code changes immediately after code is added to a larger codebase. Customers and software development teams meet often to plan release strategies. User stories and work estimates are created for each iteration, and tasks are assigned to developers at an iteration planning meeting (IPM).
    • Pair programming is a software development technique that pairs two programmers to work on the same problem at the same time, on the same computer (with separate monitors, keyboards, etc.). This highly collaborative approach breaks down knowledge silos, encourages skills sharing, and advances team building while increasing empathy and social interaction between developers. Though pairs generally share the same physical space, a shift to remote pair programming and flexible workplaces is becoming more common. Adjusting to a virtual extension of the physical workspace presents new challenges and opportunities for organizations.
  • Kanban is an approach often used along with other agile frameworks and DevOps practices to help a team match its capacity to the amount of work in progress and to measure a project’s progress by visually mapping workflow. It doesn’t use iterations or sprints; instead, a Kanban board visually separates tasks into three categories: To Do, Doing, and Done.
  • Scaled agile framework (SAFe) is an approach for managing hundreds or thousands of agile teams across an enterprise. Adopters use SAFe to ensure that individual teams—and most importantly, teams of teams—are all moving in the same direction to meet strategic goals. SAFe focuses on the planning, budgeting, and architectural issues inherent in large XP and Scrum-based processes for teams larger than 50 people. It doesn’t go deep into how individual teams are practicing agile; SAFe assumes that it’s already happening. (This blog post explores how VMware Tanzu Labs works with customers implementing SAFe, while this post explains how UX designers can work effectively in a SAFe environment.)

Benefits of agile development

The benefits of agile development may depend on the size of your project and how well your team and organization accept an agile mindset and practices. Agile development can lead to several positive results:

  • Greater transparency: Everyone from customers to the team producing the work is involved and clear about what’s being worked on right now and what still needs to be done.
  • Greater predictability: Work is clearly prioritized and timeboxed in tight iterations that ideally are 1–4 weeks in length. New features are shipped frequently and more predictably as part of a continuous delivery cycle.
  • Greater flexibility: When priorities change due to feedback or new business needs, inserting and reprioritizing user stories in the backlog can occur instantly.
  • Focus on business values: The product team determines the order in which features are built based on what’s most important for the business.
  • Focus on users: User stories are designed to meet the needs of real users. Each feature that’s designed and developed delivers incremental value.
  • Focus on quality: Since all work is broken down into manageable units and frequent builds, testing and reviews are more focused. Quality is improved as a result of being able to locate and fix defects more easily and more rapidly, avoiding bottlenecks.

Agile vs. waterfall

The waterfall methodology was adapted from early 20th-Century physical engineering and manufacturing concepts that favored a step-by-step approach. Agile methodologies provide an alternative to the sequential development and fixed upfront schedules associated with linear approaches like waterfall. An iterative, incremental approach is at the heart of the agile software development lifecycle. Agile’s short iterations and flexible methodology have become indispensable to modern product development.

But agile development may not always be the right choice. Traditional models still have a place in software development. You may be faced with the decision: agile vs. waterfall? Waterfall requires extensive planning and long release cycles. This is good for a well-defined project that isn’t likely to change in any way before completion. However, if you think you’ll need to experiment and test with new products or features, make changes quickly, or deliver software in small releases in order to gather feedback as you go or mitigate the risks of making changes, then choose agile development. These are the main differences between agile and waterfall.

For more on waterfall, see A Brief History of Agile, Part 1: The Rise of Waterfall.

Agile software development lifecycle

A traditional software development lifecycle (SDLC) like waterfall is divided into linear phases that flow from one to the next, similar to a waterfall. Each step must be completed in order before moving on to the next phase.

Phases of the waterfall SDLC are:

  1. Planning
  2. Analysis
  3. Design
  4. Development (coding)
  5. Testing
  6. Deployment
  7. Maintenance

The agile software development lifecycle integrates agile principles to embrace the iterative nature of continuous innovation. These are the six phases of the agile software development lifecycle:

  1. Concept: Product owner determines the scope of the project.
  2. Inception: A team is assembled, tools and resources are organized, and product architecture is designed.
  3. Iteration: The design is turned into code.
  4. Release: The code is tested and the software is released to users.
  5. Maintenance: The software is maintained throughout its life.
  6. Retirement: The product is retired, either because it’s being replaced or is no longer needed.

As shown in the figure earlier, each iteration should go through a consistent set of steps that’s essentially a lighter weight version of most of this lifecycle. Typical elements for each iteration include:

  1. Plan: Determine requirements for the iteration.
  2. Design: Design new interfaces and software elements as needed.
  3. Test: Test the code.
  4. Build: Compile the iteration as part of other project code.
  5. Accept: Review and accept or reject the result.
  6. Deploy: Push the accepted code into production.

Best practices to keep in mind if you're considering agile

Agile software development requires a culture shift and a different mindset from more traditional methods. Business owners and stakeholders need to show patience and empathy for the technical complexity involved and become comfortable with fast, incremental delivery of value rather than big-bang release schedules. Multifunctional product teams made up of product managers, designers, and engineers need to adopt a product mindset and collaborate to deliver value for the business and customers. Make sure your organization is prepared before undertaking a change to agile.

Ensure your team is onboard

Agile is a very collaborative process, and adoption needs to happen at all levels. You want to get people excited by explaining how this will benefit them and the entire organization. Reassure them that this is not simply a fad. An investment in agile drives innovation, flexibility, and shorter development cycles.

Never go it alone

Find people on your team who are familiar with and excited about adopting agile. Implement agile at a grassroots level and anticipate any possible resistance to this change from other teams, management, and business partners. Consider hiring a partner experienced with agile development practices to help your team adopt agile or refine and scale existing practices in your organization. This will help reduce risk and increase time to adoption.

Train, train, train!

You need a plan to train your team. Poor training can lead to poor implementation. Agile is a set of methodologies that must be learned and practiced for teams to succeed. But more important than simply training is having your team learn by doing. Having people work on an actual project helps them learn and reinforces the benefits of agile in a tangible way.

Use the right tools and processes

What product management tools do you presently use and are they suited to agile? You need to be ready to implement TDD, pair programming, and CI/CD. Are your design and UX teams on board? The larger the organization, the more hearts and minds you will need to bring together. Adopting agile is immensely doable, and done well, changes permeate through the entire organization.

Embrace the change

There's no doubt about it: adopting agile is disruptive. Your teams will make mistakes. People will try to solve problems on their own, teams will want to over prepare, and technical debt will accumulate. At the end of the day, as long as your team is committed to becoming agile, you’ll work through the challenges and find your way forward.

Agile at VMware

VMware Tanzu Labs has helped many of the world’s largest and most complex enterprises and government organizations adopt modern software development practices at scale while developing software together. These companies are now building better software—delivered by more productive software teams—and delighting millions of users.

VMware Tanzu defines agile as a set of values and principles that promote iterative delivery, flexibility, teamwork, and communication. In today's evolving landscape where businesses need to respond quickly to change, it’s essential to adapt quickly. The Tanzu Labs agile software development practices help our customers build software in the face of changing requirements. Agile drives the evolution of a product through an iterative development cycle based on ongoing end user feedback. Rather than a “big-bang” approach, software is built and deployed much more frequently—by pushing code to production daily or multiple times a day—to get immediate feedback as a product takes shape. See our blog post, Your Path to Agile Matters.

VMware Tanzu Labs provides software development services to build or modernize applications while teaching modern agile, cloud native development practices to your team. Refocus your organization around agile, lean, and user-centered design principles that quickly validate concepts and get them from idea to production in days, not months.

The principles embraced by Tanzu Labs are closely aligned with agile principles:

  • Empower teams. Diverse teams with shared context, psychological safety and decision-making authority move faster.
  • Start simple. Learn just enough to begin and let the work inform the direction.
  • Embrace changes. Expect change and turn it into opportunity.
  • Delivery early and often. Ship value to users and measure impact to lower risk.
  • Improve continuously. We are always learning and humbled by what we don't know.
  • Give back. Share our time, tools, code and approach with internal and open source communities to maximize impact.

For customers that have already embraced an agile mindset, VMware Tanzu can help you scale agile software development across product teams enterprise wide.