Agile

Agile is a philosophy for delivering solutions that embraces and promotes evolutionary change throughout the life-cycle of a product/project. Many teams and organizations have been using Agile to deliver software faster, increase quality and ultimately increase customer satisfaction. The Agile manifesto can be accessed at www.agilemanifesto.org.

Manifesto for Agile Software Development

We are uncovering better ways of developing software by doing it and helping others do it. Through this work we have come to value:

Individuals and interactions over processes and toolsWorking software over comprehensive documentationCustomer collaboration over contract negotiationResponding to change over following a plan

That is, while there is value in the items on the right, we value the items on the left more.

Principles behind the Agile Manifesto

We follow these principles:

Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.

Welcome changing requirements, even late in development. Agile processes harness change for the customer’s competitive advantage.

Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.

Business people and developers must work together daily throughout the project.

Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.

The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.

Working software is the primary measure of progress.

Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.

Continuous attention to technical excellence and good design enhances agility.

Simplicity–the art of maximizing the amount of work not done–is essential.

The best architectures, requirements, and designs emerge from self-organizing teams.

At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.

We specialize in Scrum, eXtreme Programming (XP), Kanban and SAFe. We will tailor the right Agile methodology to fit your organization. Our Agile experts will partner with you to create the ideal Agile adoption path for your organization to reach it’s goals.

We approach every Agile implementation using the 5 Levels of Planning, and ensure that Acceptance Criteria are considered throughout the planning process.

1. Vision

Before creating your vision statement, we must focus on the customer by identifying the roles that will be interacting with the product. This step will help better understand the customer and will help in writing user stories based on these roles. Another technique to consider at this stage, is to associate personas for each role. These personas will help the team humanize the work and ensure that they write test scripts for different types of users, that go beyond the obvious user experience.

The simplest way to capture your vision is to use the Elevator Pitch format from Geoffrey Moore’s template from Crossing the Chasm:

FOR (target customer)
WHO (statement of the need or opportunity)
THE (product name) is a (product category)
THAT (key benefit, compelling reason to buy)
UNLIKE (primary competitive alternative)
OUR PRODUCT (statement of primary differentiation)

2. Roadmap

With the Vision published and accepted by all, the Roadmap will serve as the next building block to ensure alignment to the original Vision. This Roadmap is meant to be used as a tool to organize high level pieces of the product. These can be business features and/or architectural components that must be understood in terms of their value and dependencies. These pieces must be organized over a period of time and the most typical way is to maintain a rolling four quarter view of the work. Every time a quarter (or whatever dimension is used) ends, the Roadmap must be updated for the next four quarters.

3. Release

Instead of writing detailed requirements for the entire Roadmap, this next level of planning only focuses on the upcoming release, which corresponds to a quarter, or whatever dimension used in your Roadmap. The goal of the release is to produce a backlog of work that is represented by a list of user stories that are estimated, prioritized, and ordered.

Estimates – all the stories have a relative sizing, typically using story points that include design, development and testing.

Plan – the prioritized work based on value, fits with the capacity of the team(s) assigned to this release

Integration Testing

Integration testing is usually the earliest actual testing that can find integration bugs (although review processes can find some bugs before the software is written, or before the code goes to test). You want to find these bugs before you start showing the software to the product owner or you release it, since fixing bugs at the last moment is very expensive. You want to find these bugs earlier in the process, when they would be cheaper to fix, because you need multiple working components to integrate (by definition). Integration testing–ensures that the units are working together in concert. This is mainly to test your design. If something breaks here, you have to adjust your unit tests to make sure it doesn’t happen again.

Releasable Software

Once a feature is complete and all the testing has passed for that feature, then it is deemed Releasable Software. The key in Agile, when we talk about being faster time to market, has everything to do with shipping completed work as soon as possible, instead of waiting until the end of the project. There are a few clarifications needed here…

A completed feature can be one or many stories, but it doesn’t necessarily mean that all the stories associated to that feature are delivered. This why we do release planning, we want to force brutal prioritization every release in order to focus on Minimal Marketable Features (MMF) or Minimal Viable Product (MVP). The best time to negotiate what is absolutely required in a release, is at the beginning of the release, not once the release started, or even worst by not having any release planning.

A feature fully tested means that the team and organization have agreed on the Definition of Done for testing before software can releasable. There are many types of testing applicable to specific time and environment to test. For example we expect Unit Testing and Behavior Testing to be Done during the iteration. We also expect other types of testing like Accessibility, Front End Performance , Middleware Performance, Security, Load Testing and Web Consistency to be included at the iteration or release level. The key is to have agreement on what type of testing and when they will be performed, so that we ensure that the software is releasable as soon as it’s ready to ship.

4. Iteration

An iterative approach simply means that the work is time-boxed into a set length of time. The ideal iteration length is 2 weeks, any longer than this will most likely cause the business side to disrupt the iteration by adding/changing the content of iteration, the planning and review ceremonies in Scrum to take longer, and procrastination to naturally creep in.

From a testing stand point, all the work planned in the iteration must be tested, in order to embrace the Agile value of focusing on working software. This means that the team will need to test first by embracing TDD (Test Driven Development) and ultimately BDD (Behavior Driven Development). These techniques promote full team collaboration during planning and designing during the iteration in order to define the test case and build the test scripts. As we will describe in the next two sections, it will be very important to write good user stories and include clear acceptance criteria.

Stories

User stories are expressed from the perspective of the person who will be using the feature/capability and therefore should provide what is needed to test that the user will be able to complete the action. It typically follows this simple template:

As a <user>, I can<activity>, so that <business value>.

Or

As a <WHO>, I can <WHAT>, so that <WHY>.

It’s important to note that stories are not the same as requirements. Where requirements try to lock in every possible scenario up front and often provide details on how to accomplish the work, the user story instead does not mention the HOW. The best way to describe a story is to view it as a “vehicle for conversation” as explained in the Three C’s from Ron Jeffries, more specifically, the intent is for people to ask questions and capture the confirmation of these conversations as acceptance criteria, in the user story.

Acceptance Criteria

These cover the boundaries of the story and will serve as scenarios for writing the test cases. Once the story is written or during story writing, it’s important to capture acceptance criteria and make sure that an acceptance criteria is not actually a story and vice versa. The acceptance criteria does not expand the story, it strictly provides the scenario behind a story, in order to write good test cases. Acceptance criteria should ideally be written using the Given-When-Then formula, in terms of scenarios and implemented as classes:

Given [initial context], when [event occurs], then [ensure some outcomes].

There are some types of stories that benefit from creating a checklist for items to look for in a story. For example creating forms and reports are notorious for having missing or changing acceptance criteria once the iteration starts.

For forms, it’s important to understand which fields are mandatory, what are the validation rules and where exactly the form will be submitted.

For reports, the focus is on what are the inputs/outputs for the report, for example what fields are needed to generate the report, what are the columns to show on the report, are the column sortable and/or filterable?

The goal is to make sure to capture the right level of acceptance criteria, these should not turn into dumping what used to be your requirements under a story. The acceptance criteria should not tell you how to do the work, but instead how to accept and test the work. They serve as the key for teams to know before they start working, what will be considered acceptable. Some organization refer to these as success criteria, which re-enforces their importance, as the team fully understand what it will take to be successful at the story level.

Automated Build

Many companies make the mistake of building and testing their code possibly on a daily but more likely on a weekly basis, this leaves too much room for defects to creep in while you’re not looking. By the time a bug is discovered, more code has been layered on top of it – making it harder and more expensive to fix. Testing changes right away dramatically reduces the cost of addressing defects, so you should kick off a build with each commit, or at the very least on scheduled intervals throughout the day.

Working Software

Mentioned as one of the four values from the Agile Manifesto, “Working software over Comprehensive documentation” and also in several of the principles, we must recognize the importance of producing working software, within an iteration. This means that not only the software respects agreed upon testing standards, but also has passed all the tests included in the Definition of Done for the organization. In Scrum it’s referred to as “potentially shippable product increment“, which means that if the work as been accepted then it could ship immediately, and therefore must have been thoroughly tested.

5. Daily Stand Up

The last level of planning should not be undermined. Having a clear plan every morning before starting the day is critical to ensure that the team is on the same page and that everyone on the team has a sense of purpose and meaning about the work to be accomplished each day. This planning level takes place within a daily session lasting no more than 15 minites, where each member of the team answers the following 3 questions:

What did I accomplish yesterday?

What I am planning to accomplish today?

Any impediments in my way?

This short planning session is typically followed by breakout sessions based on the facts shared during the Daily Stand Up. Since we don’t focus on solving issues during the Daily Stand Up, the topics that require deeper conversations or help from other team members, should be tackled immediately during these breakout sessions. The best time for anyone in the organization to communicate with a team, is to catch them at the end of the Daily Stand Up.