Agile software development quality assurance

Free download. Book file PDF easily for everyone and every device. You can download and read online Agile software development quality assurance file PDF Book only if you are registered here. And also you can download or read online all Book PDF file that related with Agile software development quality assurance book. Happy reading Agile software development quality assurance Bookeveryone. Download file Free Book PDF Agile software development quality assurance at Complete PDF Library. This Book have some digital formats such us :paperbook, ebook, kindle, epub, fb2 and another formats. Here is The CompletePDF Book Library. It's free to register here to get Book file PDF Agile software development quality assurance Pocket Guide.

When organizations were writing code using a waterfall approach, they could afford to have this disconnect, because they tested everything at the end of the development phase and they had detailed specifications that told software developers and QA analysts exactly how the software was supposed to behave. Or at least they were supposed to have those detailed specifications…. With the waterfall approach to software development, software developers and QA analysts could work independently of each other much more easily, because it was a downstream process.

Developers would write code and they would pass that code downstream to QA who would test the code. Bugs would flow back upstream until the software had reached the level of quality that was expected. Many software development organizations practicing Agile methodologies still try to operate in this fashion. It is common to see software development teams staggering iterations so that the developers will work on writing code for one iteration while the QA team is testing the code from the previous iteration. This kind of methodology is not really Agile, it is mini-waterfall.

When organizations are developing code in this manner, they are simply taking the waterfall process and chopping it up into smaller segments. They are getting all the pain of the waterfall process and missing many of the benefits of Agile. To truly operate in an Agile environment, entire organizations need to be Agile. Sure, that is easy to say, but what does that actually mean? It means that organizations need to be able to respond to change quickly and to iterate their software in response to that change. Here is an example that will make things a bit more clear.

Suppose a team is developing a feature for call center software that allows a customer representative to provide detailed notes about a call to their supervisor for review each week.

Integrating Quality Assurance with Agile Development

The software developer on that team's project writes the code for that feature during the current iteration, while the QA team is happily testing the features the development team had completed last week. The development team finishes the feature and in the next iteration, they move on to another feature and hand the call notes feature over to QA to test. Well, it just so happens that when the QA team starts testing the feature, the customer who is going to use the software tries it out as well and discovers that they actually want the feature implemented in a completely different way.

Obviously, at this point it doesn't make sense for QA to continue testing the feature, so they stop. But now, the developers are already working on something else, so they either have to stop what they are doing and start working on the call notes feature again, or they have to put off the changes to the feature for the next iteration.

Even if they manage to complete the requested changes to the feature in their current iteration, it will be a whole other iteration before the feature is tested. Not very agile.

Popular Posts

So, following an Agile process alone does not make one agile. In order to really be agile, in the true sense of the word, meaning an organizations can respond to change rapidly, they need to have their QA and development teams working together each iteration. Instead of developers completing code and throwing it over the wall to be tested in the next iteration, a truly Agile team will have developer and QA team members work together during the current sprint to both develop and test a feature.

By doing this, a team is able to respond to any changes immediately and is truly able to iterate the development of their software. Going back to the example with the call center software. It can be seen that if the QA team was testing the call note feature in the same iteration that the developers were developing it, making changes midstream would be a much easier task. The developers could simply make modifications to the feature and give those modifications directly to QA in the same iteration.

No time would be lost waiting for the feature to make it completely through the pipeline. Of course this is all easier said than done. How can a team develop and test a feature in the same iteration? Doesn't the feature need to be developed before it can be tested? If a team looks at a feature as an atomic element that can't be broken up into smaller parts, then yes, it does. But, most features are not unbreakable stones.

Most features can be broken up into smaller pebbles which can be developed and tested independently of the whole.

To look at features and develop them this way requires coordination and communication between the developers and QA analysts. When a new feature is going to be worked on in an iteration, the development team needs to meet with the QA team together to talk about exactly how the feature is going to be broken up and what exactly is going to be tested.

The term test driven development, or TDD is used to describe the practice of writing failing unit tests before writing code in a software project. This same idea can be applied at a higher level to the development and testing of an actual feature to allow the tests to drive the development of that feature. In this scenario the development and QA teams meet together and the first thing that is decided upon is the high level tests that will be used to verify the correctness of the feature. Developers and QA analysts work together to define, at a high level, what test will be run and created to test the feature.

Developers then start writing the code that will be necessary to make those tests pass, one test at a time. Each time the development team has enough code created to make a test pass, that code is handed over to QA to execute that test against the code for the feature.

TSM - Quality Assurance in Agile-SCRUM environment

One by one, the code required to make each test pass is written and tested and little by little over the course of the iteration the feature is both developed and tested at the same time. This process of developing features one test at a time requires the entire team to work together as a single unit to complete the work for a sprint. It requires developers to understand more about the testing process, since they will need to know how the features they are developing will be tested.

It requires the QA analysts to know more about the development process, since they will need to be aware of when certain parts of a feature are ready for testing. Inevitably, when bugs are found using this process, they are handled immediately.

What is Agile, Part II: Key Agile Terminology

When QA member finds a bug, it indicates that a particular test that a developer thought should pass, does not pass. Work doesn't move forward until the failing test passes, so bugs are always fixed as the software is developed, not after. At least not bugs that are found by normal testing.

Most Agile teams use either a burndown chart or a wallboard with different lanes to show the progress of items being worked on and to let the team know what the priority of work is. These tools can be an important part of getting development and QA teams to work together. Having a central location where team members are able to see priorities and the progress of work being done during the iteration, helps the team to have a unified goal and to visualize how work will progress during the iteration. When adapting a truly Agile process, as suggested in this paper, many teams struggle with a huge backlog of QA work being pushed to the end of the iteration.

  • Trans Fats Alternatives!
  • Deformations of Mathematical Structures: Complex Analysis with Physical Applications;
  • What does it take to build a good QA plan for your Agile set-up?;

Breaking down features into smaller components and testing them as they are finished can reduce this problem, but it can also be very helpful to have a burndown chart or wallboard that clearly shows the work backing up before it becomes an issue. This whole process hinges on one very important thing: communication. For many organizations this is the single hardest barrier to overcome. In many development shops QA teams are not used to communicating with development teams with the frequency that is required to be successful in an Agile environment.

There is no time for indirect methods of communication like complex bug tracking systems and long emails. The development and QA teams need to learn to communicate most things immediately instead. Co-location can help make this communication easier, but when that isn't possible, instant messaging systems can be another fast way to communicate.

If you adopt a new process without understanding the principles behind it, then you run the risks of getting caught up in the mechanics and forgetting about the values. The Scrum guide teaches us that while you do not have to release the product incrementally to your clients, specific deliverables from each sprint must me in usable conditions.

How QA Can Make Agile More Efficient

Now, usable can vary by team, as can the definition of finished. But generally, this refers to software that has been tested, coded, and reviewed by the product owner. When you adopt Agile principles, then you should use those principles to conduct your quality assurance processes as well. Testing deliverables from sprint to sprint is not part of the Agile values. When coming up with your testing approach, consider each of your established practices against the values of Agile, and ensure that they are working together. If you try to apply the Agile principles to Quality Assurance, then you will most likely run into issues that make testing sprints very difficult.

It is easy to just modify your processes around these obstacles, but that will force you to move away from the values that you are trying to uphold. For example, not having enough time in a sprint to test everything the team needs to test. When this happens, the first reaction is to make the Sprint longer. While there may be some valid reasons for making sprints longer, it goes against Agile values. So, before making decisions like these, try to find if there are other root-causes causing this problem. By nature, Agile is meant to expose flaws within your process, but without knowing it teams often make an effort to hide them.

The correct thing to do is address them. The goal is to dig deeper, find the root cause and fix it. Do no compromise values.