Agile Testing

[agile-testing-blog]

Things to consider for a product to go live.

Whether an application or software product is ready to go live, is a very simple question difficult to answer. It is mostly towards the deadline that all the final development and testing is squeezed in. Most important functionalities are prioritized and the product is declared complete based on a certain self determined quality level. Generally, everyone depends on the tester to speak about the quality, but actually it needs to involve all the people in the process.

Deciding if an application is ready to go live is different from the regular testing process. It is the phase after testing has already been done. As projects grew bigger, they became more complicated and the development timeline shorter. With more development in less time, bugs filled in and quality degraded. Testers were hence introduced at the end of the development phase to detect bugs for rectification. With Agile methodologies in practice, testing now runs parallel to the development process.

It is only after testing the product that it is the time to determine the readiness of the product for release, that it is technically complete and ready for use by the customers. While testing, several defects will be found, which need to be managed as necessary for the organization. These bugs can be classified as per their level of severity.

-      Critical bugs that can impede the software operation.

-      High priority bugs that hinder the operation of a product and have no workaround.

-      Mid level bugs that cause user inconvenience, but have an alternative workaround.

-      Low level bugs which do not affect the system

The utmost effort is to release a product which has no bugs, but this rarely happens. Hence, the application is released as such it has no critical, high priority and mid level bugs. Setting a goal of delivering a bug free application may delay delivery date and alter revenue projections. Hence, to manage all aspects, bugs need to be placed in priority order making necessary trade offs.

Once the development is complete, the development  environment needs to freeze. Here no development is done unless it is bug rectification. Once this triage with bugs is complete, it is considered ready to go live. Here the product is considered to be stable, bug free and ready for customer use. However, an organization still faces operational disruption at the time to go-live which most often are self inflicted and can be mitigated easily. Finally, it comes down to the following which indicates an imminent go-live.

-      All the new processes and functionalities of the application has been accepted by the users.

-      Users understand the new business transactions.

-      Everyone understands how to use the system.

-      There is adequate support ready.

-      There is a good contingency plan.

Once all the above points are addressed, the application can go live.

Conclusion:

Making a software product live is not a smooth process. Many technical and administrative hiccups occur during this process. However, it must be noted that this entire process depends on the testing process and proper test planning.

[agile-testing-blog]

Leveraging feedback to improve software quality

Feedback can be said to be the cheapest, but still the most under used software management tool at our disposal. It  is the information that is required to achieve both, effectiveness and productivity. Feedback helps to clarify one's understanding and see things in new ways. It helps correct the course of action, learn and work better. Early feedback is the most critical aspect of being successful. The Agile methodology has feedback as the core component of all its principles in one form or another.

Feedback can be taken at each step of the development cycle used for improving the performance.

Feedback on Requirement Priority: This is all about making sure that the client and the development organization are both aligned with the requirements and the deliverables.

Design Feedback of Software Design: A feedback on design identifies more clearly what the customer actually requires and not what the designers feel good about. Any difference in design and the requirement is a symptom of  gaps in conceptualization and communication between the client and the analyst.

Feedback on Software Functionality: This feedback is associated with the working of the software. A continuous and iterative feedback on the developed software is the main change in Agile practice. It is built in small consumable increments and submitted for feedback early and often. Although it may seem time consuming and tiresome early on, but it saves cascading errors and time required for testing and debugging later on.

Feedback on Software Code: This involves collaboration with the developers. It helps in getting a fresh perspective on the developed code and makes sure that nothing is overlooked. It is a good way of understanding the code and the related changes.

Feedback is used to gauge a system, program  and properly operate it. Broadly, feedback can be categorized into three forms – Coaching, Evaluation and Appreciation. It works best when it relates to a specific goal. Its timeliness is equally important.  The sooner the feedback is given, the sooner that problem can be corrected. Feedback, most of the time, needs to be provided in a positive manner. This is mainly because, people respond to feedback which is provided in a positive manner. However, it needs to be factual, complete and accurate. Also, it is most effective when it identifies the  hard work and clearly states what is required to be done in future.

Some feedbacks occur naturally, while some feedbacks need to be carefully planned and managed. Self evident feedbacks can be formed by the developers as they work. Planned feedback runs the system through a measurement system and the developer receives it automatically. Effective feedback  improves the performance of the employees and the organization as a whole.

Conclusion:

Soliciting feedback early and repeatedly forms a critical component of the software development process. It brings transparency into the system and incorporating the feedback in the system helps to improve it further with respect to the customer.

[agile-testing-blog]

The Agile Context Exploratory Testing

Exploratory testing is a rigorous investigative practice. It is test design and test execution at the same time.  Unlike scripted test cases, they are not pre-defined and are not carried out as per any plan. It may be confused with ad-hoc testing as well, which is an improvised form of bug detection.

Exploratory testing is a sophisticated and thoughtful approach to ad-hoc testing. It helps software testers keep up with the rapid development speed of the Agile methodology. It is a core testing practice in Agile.

Continuous Integration in Agile, execute typically automated scripted regression tests. However, all such automation is not enough to ensure that the system is built and functions perfectly. Hence, manual tests are still required. These are not those repeatable scripted tests. This manual testing refers to an approach that is adaptable and gives out a lot of information quickly. This refers to exploratory testing.

Here, instead of documenting stepwise instructions, simple questions are chartered which needs to be answered through testing. Then, using these charters, testing moves through the software, poking it to reveal unintended sequences and risks of design decisions which were not considered earlier.

A test charter for exploratory testing may include the following:

- The intended user of the program. - The objective of the user, i.e., the test conditions. - The test environment. - The relative importance of the charter with respect to the user level. - Data gathered during the test. - Test activities - Input and output evaluation notes - Alternative evaluations  for  results of the test activities.

Exploratory test results should include the following :

- Test Coverage - Notes of evaluation, observations, stability and features of the system. - The risk matrix and its coverage. - Issues and anomalies related to the efficiency of the test approach,  test environment, test data, functional misinterpretation and the test script. - Actual behavior of the system.

Further, exploratory testing uses the results from the last test  to form the next. If some vulnerability or risk is noticed, the testing approach is adapted accordingly. As this testing type does not follow a test script, it focuses on what actually important at that time.

Exploratory testing is more of a practice characterized by the following aspects:

- Emphasizes the  skill, creativity and autonomy of the tester. - It recommends the performing of test activities throughout the development life cycle rather than in a fixed sequence or phase. - Emphasizes on diverse test approaching rather than following one single scripted technique.

Exploratory Testing is suitable in situations when very little is known about the product or the involved test scripts. It is called for at the time when the next test to be performed is not obvious or when it is required to go beyond the obvious.

Conclusion

Exploratory testing is required to make the testing relevant in order to manage the constant changes in an Agile Project. This requires understanding of the risks and the areas to focus the test coverage.

[agile-testing-blog]

Accelerating DevOps Processes through Agile.

DevOps makes a faster delivery of software or software products. It is now the main differentiator of competitiveness. Agile plays an important role to meet the urgent goal of accelerating the development process of an application through its very effective iterative development process. By promoting this concept of iterative and incremental changes, Agile development in turn accelerates the DevOps process.

Very few people can understand the guidance in the Agile Manifesto. Valuing employees and individuals as well as processes and tools are critical for being able to successfully implement the principles of DevOps. It highlights effective communication and collaboration.

Many organizations suffer from dysfunctional communication between employees which in turn affects the success of the organization. Also, many people do not want to waste time in creating project documentations that possibly may not be used by anyone. But they fail to recognize the struggle of the new people when project managers move to different locations without leaving enough documentations for reference.

Another challenging area is managing change. Developers do not realize the importance of interacting with the operations for the required infrastructure. Similarly, the operations may not be able to predict the performance of new technologies. A strong teamwork is required to overcome this and identify potential risks.

Clients and product owners often change their requirements in the middle of the ongoing development phase. This is mainly because as they see the processes being developed, they get a better insight of what they actually require. These changes may also be induced due to competitive pressure or change in regulatory laws.

Successful  teams practice the agile principles utilize its concepts to work as a well collaborated team.DevOps is based on Agile and hence enables merging of new code with the main code base. With such fluid characteristics, it empowers the present day developer to be a curious, innovative and business oriented risk taker. DevOps is the logical consequence after years of improvement in IT processes to respond faster and better to business requirements.

DevOps brings order into the complex world of development, testing and deployment. By implementing the Agile methodology, it minimizes the distance between the independent teams and unifies the approach to software development and delivery. It strives for more collaborative and productive relationship between the development and the operations team.

Implementing DevOps to accelerate and innovate the development methodologies requires adopting the Agile methodologies.  For this the Agile infrastructure is also required to provide the dynamism for the various stages of continuous delivery and continuous integration. For being a true Agile, teams have to develop and test faster as well as deliver products and enhancements faster. Agile and DevOps are thus two sides of the same coin.

Conclusion:

DevOps has emerged from the collision of the agile operations and an extensive collaboration and communication between the development and the operations team. DevOps shares a very strong affinity with Agile. Agile principles lay the foundation for DevOps which further channelizes it beyond the code into the entire product delivery service.

[agile-testing-blog]

The role of Test Manager in Agile Organizations

The role of the Test Manager (TM) is different in an Agile environment than in a traditional environment. In traditional methods, a test manager is responsible for assigning resources to projects, monitor the progress of the testers, review and provide feedback and train the people who need it. In Agile practices, testing moves closer to development. The developers learn testing techniques and the testers become aware of some smart development tricks.

The TM is the lead of the testing part of the Agile Approach. His role in Agile elevates to a higher level as compared to the traditional model.

- The TM helps in transitioning a project from one development model to another. He provides the necessary understanding and insight to the team through this difficult process of migration.

- He is the main advisor to the team on how to cope up with quality. Some organizations do not put enough importance on testing and quality assurance. The Test Manager is responsible for supervising quality across the entire project.This may involve restricting product releases due to core quality issues. It may also imply recruiting new members in the testing team and explaining the customer, the extra cost required by the project.

- He is responsible for the support, mentoring and development of the testers. The TM is experienced enough to understand the growth plans of the company and further plan the growth of the group under him. The test manager can set up training sessions and help in the development or acquiring of new skill sets by the team members.

- In the absence of a team member, the TM can step up and fill in the work gap. Thus, at times the TM also requires to contribute at an individual level

- Facilitates the communication between different teams across different Agile projects. Allocates an reallocated resources, thus increasing efficiency and productivity.

- Provides an aggregated report of the testing to the management. He acts as a buffer between the team and the decision making process of the senior management. He integrates the management strategies into the test organization. Also the TM is responsible to push back on bad ideas as the team members may not have the time or the experience to realize itis a bad idea. The TM analyses and explains the senior management the possible side effects of the inappropriate approach.

The success factor of the TM includes

- Building inter-staff trust relationships.

- Improving the skills and capabilities of the testing team.

- Trusting the approaches and working methods of the different teams and facilitating it rather than dictating preferred approach.

Conclusion

The TM is the first member of the team with privileges for corporate purchases. They work closely with their management counterparts and collaborate on cross discipline objectives, budgeting and scheduling. They also work with development managers to integrate coding and testing to achieve a profitable development cycle.

[agile-testing-blog]

Increasing the value of Testing in Agile.

Adopting Agile depends on the project context. In an agile environment, extensive documentation of requirements are not available as it focuses more on communication. This poses a substantial challenge for software testing which is difficult to be carried out without detailed resources.

The key element in software development is testing as it ensures software quality assurance of a product’s readiness for production, completeness, purpose and risks.

In sequential development life cycles, the team always prioritizes the definition, review and the validation of the initial requirements. This approach, when combined with a full testing strategy of the life cycle along with developer level testing, ensures higher levels of software quality. However, the traditional approach of development has, most of the time, failed to deliver working software in terms of specified business needs, cost and time. The failure generally occurs due to lack of management, testing and processes. There is often a communication gap between the developers and the testers. The requirements changes that may be specified during the development process may not have been communicated  to the testing team. This results in the application failing in the corresponding test case or the test process being incorrectly aligned with the real product. To overcome this challenge a lot of time and effort is spent in managing mid-development changes.

The agile approach in software development is based on an iterative development with a continuous evolution in the requirements and solutions. This methodology offers a better solution to the problems faced in the traditional Independent software development and testing approaches. Using iterative, repetitive and incremental steps in the process theoretically ensures a better product delivery.

Agile ultimately is all about software quality assurance and the customer. Hence, testing has a very important role in Agile driven development.

The value of testing can be maximized in an Agile discipline in the following ways –

- Adopting a test driven development approach to maximize quality and minimize duplication. A TDD emphasizes on writing the test, coding it and then refactoring.

- The test strategy and its planning should be adaptable and flexible to the new modification received after each iteration. A Hybrid testing approach thus combines the elements of both agile and the traditional methodologies.

-  The tester’s role needs to be flexible. The testing team needs to become significant agile team members. Thus the nature of the tester in agile testing is no longer that of a fault finder or a high profile quality inspector. Rather, they are included in a collaborated team striving to achieve quality.

- Implementation of automated testing can greatly reduce the unnecessary repetition of manual tasks. Building of integration processes, unit tests, static tools for analysis, environment management and functional testing can be automated in Agile.

Conclusion

The best practices for efficient and high quality assured software product delivery can be leveraged through the Agile methodology. Professional testers need to evolve with agile testing methodologies to address traditional development challenges by collaborating with the developers, analysts and the stakeholders more closely.

[agile-testing-blog]

Quality assurance through agile testing

Quality is not only an attribute of the software product but also that of the development procedure followed to build it. The first consideration to any quality assurance is - are we building the correct product and if so are we building it correctly. Agile Software Testing methodologies adhere to the very well defined rules in its manifesto

Individuals and interactions over processes and tools

Working software over comprehensive documentation

Customer collaboration over contract negotiation

Responding to change over following a plan

In Agile Testing, the customer's perspective is taken into consideration as early as possible. Testing is done as code is written and is stable enough for unit level testing. Since testing is done often with every increment of the working software, it is done by automated testing. Manual Agile testing is more likely to result in flawed product or delayed time line. Agile testing covers all types of testing. They can be defined into the following main four.

• Functional Testing • Exploratory Testing • Unit Testing • Performance and Load Testing

Main Testing Practices:

• Paired Programming • Test Driven Development • Continuous Integration • Automated Unit Tests • Automated Functional Tests • Restructuring Code without altering corresponding functionality • Defining 'done' clearly.

Testing Approaches:

• Scrum: This concentrates on the task management within a team. It implements working in small teams. Each iteration of a scrum is called a Sprint. All the details of the end product are entered in the product backlog. The top items of the product backlog are selected and listed in the Sprint backlog. The team checks for the daily work the Sprint backlog. The team then delivers the product functionality after each sprint.

• Kanban: This framework can be better defined through its difference with scrum. Here there in no definite sprint size, optional prioritization of product backlog and adding items whenever possible.

• Crystal Methodologies: This is based on the concept of chartering, cyclic delivery and wrapping up. Chartering involves the creation of development team, feasibility analysis and defining the development methodology. In delivery cycles, the team implements and reviews a subset of the requirements. Then the entire developed software is deployed and reviews are performed.

• Extreme Programming: This approach is very useful when the requirements are constantly changing and evolving. The product is frequently released in short development cycles called iterations. This introduces a checkpoint where additional requirements can be easily implemented. There are six phases in this method which are Planning, Analysis, Design, Implementation, Wrapping and Closure.

• Dynamic Software Development Model (DSDM): The main focus of DSDM is frequent delivery. It is a Rapid Application Development (RAD) approach. DSDM consists of seven main phases which are self explanatory in their terminologies. They are Pre-project, Feasibility Study, Business Analysis, Functional Model Iteration, Design and Development Iteration, Implementation and Post Deployment.

• Development of Lean Software: It is a just-in-time production approach which basically aims at increasing development cost and decreasing cost. The main steps of this system are Waste Elimination, Amplification of learning, deferring commitment, early delivery, team integrity and empowerment and optimization of the whole.

• Feature Driven Development: Unlike other approach, this method focuses on the separate accomplishment of each feature.

Conclusion:

Agile Testing methodologies ensure the perfect alignment between the development process and testing process, thus optimizing the overall project outcome. Whichever tools we choose and whatever methodology we follow, Agile testing acts as a catalyst which takes the team to a whole new level.