Tag: agile mindset

My experience as a Panel speaker @LeadDev webinar

Nishi Grover GargLeave a comment

I was invited by @LeadDev organisation to be a part of a webinar where we had a panel discussion on “Building a better testing culture“. I was elated to be a part of this great group pf panelists alongside Thayse Onofrio from Thoughtworks and Marcus Merrell from Saucelabs. We had a spirited and interesting discussion and shared some meaningful ideas on the topic. I would also like to thank our host Amanda Sopkin for her really on-the-nail questions and for directing the conversation, and our organiser Olivia Christian for inviting me and for her support throughout the event!

The webinar panel was live, lasted for 45 minutes and then we had some time for Q&A. There were some great questions and discussions over the LeadDev slack channel as well.

Here is a bit more insight into the event-

The world of software testing is changing under the pressure of ‘speed to market’. The pressure to quickly get products to market means we are starting to see a significant shift towards automated tests during development. This will likely cause socio-technical complexities for orgs and teams currently involved in testing.

In order to be successful through these changes, orgs will need to have a clear strategy and processes in place that will ensure testing is a vital part of the delivery process. In this new age of testing, how can engineering leaders prevent pitfalls such as friction between teams, a culture of blame, and outdated processes?

In this panel, we examined how shift affects traditional testing set-ups, covering what a healthy testing culture looks like and how to avoid the anti-patterns that lead to uncommunicative teams and project bottlenecks. We explored how engineering teams can best work together and how to encourage a shared vision of quality and the importance of efficient and effective tests.

Key takeaways

  • Define clear roles and responsibilities for quality and testing in your org 
  • Encourage QA to be seen as necessary, rather than inhibiting release times 
  • Understand which tests to automate, and which to not

About LeadDev

LeadDev is a community of software engineering leaders that come together to learn and get inspired on all things team, tech, process, and personal development. 

LeadDev has become an essential destination for anyone in tech and engineering who wants to scale themselves and create impact. They provide a range of content that includes articles, thematic content series, video talks and panel discussions, written and delivered by the best voices in engineering.You can register a free LeadDev.com account to gain access to our free engineering leadership content, free online events and our weekly email newsletter. 

Advertisement

How To Compliment Software Outsourcing With Agile Development? 

Nishi Grover Garg1 Comment

As technology advances at a breakneck pace, speed and adaptability have become critical for fulfilling client requirements. While traditional project management systems such as the waterfall approach are incredibly precise and controlled, they do not foster adaptation or feedback.

However, firms across a variety of sectors have succeeded in transforming the way their projects are managed through the use of the Agile development technique. Businesses whose primary business is software development have profited the most from the Agile methodology. 

Today, the value of agile methods in software development is well recognized. Not to mention, the benefits are only brought to those who are clear on what precisely to expect from a software development service provider. Agile improves your development team’s effectiveness and results in a more coordinated project management strategy. Therefore, thorough research before hiring makes a lot of sense in order to work on your expectations.

Along with the increasing popularity of Agile software development, another trend is picking up quickly, and with good reason is software outsourcing. Outsourcing software development has overtaken in-house development as the second most popular trend in the industry. 

Indeed, several businesses have begun to include agile methodologies into their offshore development processes as well. Their purpose is to combine the cost savings associated with outsourcing with the adaptability associated with agile development procedures. However, this begs the following question:

Is it possible for software outsourcing and agile development to coexist?

IT  Outsourcing is a widely used method of accelerating corporate operations and making them more efficient and competitive. Outsourcing enables organizations or independent software vendors to accelerate project delivery. Given the benefits that both Agile and Outsourcing provide to the software development cycle, collaborating on a project is undoubtedly a good option.

Coordination with an overseas team, on the other hand, might be challenging owing to a lack of face-to-face contact, cultural differences, and time zone differences, among other factors. Meanwhile, if a strategic strategy is used to integrate these masterstrokes for software development, the project delivery cycle may be accelerated and elevated.

To overcome the obstacles that collaboration between Agile and Outsourcing entails, both sides (companies and technology partners) must work together. The below section explores some effective strategies for establishing a successful Agile-Outsourcing relationship.

How To Compliment Software Outsourcing With Agile Development?

1. Choose A Trustworthy/Skilled Technology Partner

A technology partner is a business that comprehends the underlying concept of the program and assists in its execution. To begin, a comprehensive investigation of the organization should be conducted, determining whether their portfolio and prior expertise are applicable to your project. Thus, a set of indicators may be reviewed to determine whether the technology partner has the capability to execute a project according to the needs and standards established in advance. 

2. Assess the Team as a Whole, Not Individuals

Finding excellent programmers with extraordinary talents is not a difficult task for customers wishing to outsource a software project. Agile development, on the other hand, necessitates a high level of team participation; it is all about collaboration, not individual perfection. Each team member is critical to the project’s success, and each member must feel at ease cooperating with others, whether in offshore locations or in their own nation. 

As a result, the programmers’ track record in a team context is more essential than their individual accomplishments. Consider utilizing behavioral interviewing techniques to pick team members in the same way that you would when employing staff for your business.

3. Interact

To flourish as an outsourced and Agile software firm, there is a need for adjustment, since these two concepts do not always mesh well. To be successful, it is necessary to carefully modify the Agile software development process as well as the communication channels between the customer and the outsourced provider.

4. Mitigation of Risk

Everybody will claim to be agile. Therefore, if you are otherwise satisfied with the provider, condition awarding the project on a successful iteration/sprint that results in the delivery of functioning software to you. Make Certain that your sprints are brief. Define the success criteria in detail, including acceptance tests and the delivery timetable, as well as any additional criteria that are critical to you and your business. Following each sprint, you’ll have the chance to evaluate the offshore team’s performance, make required improvements, and lead the project in the correct path.

After analyzing the team’s performance and working style, you should be able to determine whether you can accomplish your business objectives while collaborating with this offshore team.

Conclusion

Embedding agile practices throughout the IT department is a journey – a lengthy one. By enlisting a vendor as a partner on the journey, businesses may alter their IT development while retaining the benefits of outsourcing. This dispersed agile partnership necessitates collaboration on a variety of levels, as well as the ability to learn from and adapt to the outcomes. The incentives are substantial for those that do it right, including much cheaper costs, access to a big pool of technology-savvy labor, and the capacity to operate constantly and fast across different time zones.

<This is a guest post by Emily Cooper.>

Author Bio – Emily Cooper is a technical writer with a passion for writing on emerging technologies in the areas of software development, .NET and Dedicated Software Development. 

<Image Credits – Unsplash.com>

Achieving the Goal of In-Sprint Test Automation

Nishi Grover GargLeave a comment

Getting test automation done is a challenge, especially within the tight deadlines imposed by Scrum. As much as the thought of continuous in-sprint test automation sounds enticing, the practicality of it may elude most Scrum teams.

In my article published here– I look at some of the main things you need to consider in order to get your test automation done within the confines of your sprint.

Framework

The first thing to focus on is a framework that is useful, is easy to understand, and helps all stakeholders participate in test automation.

This is essential because you want to make test automation a continuous activity that is a part of daily work, not a once-a-sprint (or once-a-release) work item. For this to happen, the framework must make it equally comfortable for a businessperson, developer, functional tester or automation expert to add their contribution and see the results of their efforts.

There are many business-friendly frameworks and techniques, like behavior-driven development (BDD), as well as many tools that can create tests in a domain language and then translate them to script code.

All stakeholders must be trained on using the framework, and their area of contribution must be made clear to them, with practical hand-holding. The automation tester can then focus on maintaining the framework, generating test suites and editing failing scripts, while the creation of test automation will be a continuous task assigned to everyone involved.

Collaboration

The next thing to focus on is collaboration between the various stakeholders. A continuous automation framework can only survive when it is being fed and tended to by everyone on the team.

  • The business people, like a business analyst or a product owner, can help by adding user scenarios or defining the requirements in a framework-friendly format. This may require them to be trained on the preferred format based on the framework being used
  • The developers can help by creating reusable methods for steps of the script. They can also create and maintain an object repository for all elements they add to the UI while testers use the pseudo names of the elements in the test scripts. This means that the scripts can be created before (and independent of) the application UI, and such scripts won’t need editing when the UI changes, as long as the object repository is kept up to date
  • The testers can help by adding more scenarios, specifying and creating test data, and executing the scripts periodically

Strategy

How to strategize the development of test scripts is crucial to making in-sprint automation a reality. Using API-level automation whenever possible will reduce the time and effort.

Continue Reading –>

Read More »

10 Lessons When Moving from Waterfall to Agile

Nishi Grover Garg1 Comment

Many organizations take up the transition from waterfall to agile with the best intentions in mind. Like so many other companies, you might also be seeking to replace your traditional waterfall processes with agile in a quest to shorten the time-to-market and deliver high quality applications.

The road to agile, though, can be a rocky one! That’s why, in my latest refresh post for Ranorex blog, I have put together a few lessons and tips that will help you in succeeding in moving from waterfall to agile successfully!

The article was published at https://www.ranorex.com/blog/10-lessons-when-moving-from-waterfall-to-agile/

Here is a quick list of lessons we dive into-

1: Embrace the agile culture first

2: Adapt roles and responsibilities

3: Take a whole-team approach

4: Test early and often

5: Remember that agile is iterative

6: Encourage transparent communication

7: Make test automation your friend

8: Commit to early feedback and re-planning

9: Include the whole organization in the agile transformation

10: Adopt tools to enable team collaboration

Check out the complete article to read in detail about each of these learnings that can help you succeed in your agile transformation.

Cheers

Nishi

Read Along- ‘Agile Testing’ Chapter-18

Nishi Grover Garg2 Comments

“Coding and Testing”

  • The beginning of coding is a good time to start writing detailed tests.
  • As testers think of new scenarios to validate with executable tests, they also think about potential scenarios for manual exploratory testing. Make a note of these for later pursuit.
  • Some quick risk analysis can help you decide what testing to do first and where to focus your efforts.

The Power of Three Rule – When unexpected problems arise, you may need to pull in more people or even the entire team. Tester, Developer and Customer (or businesspeople) can together decide on correct behavior and solutions.

Explore It!

As soon as testable chunks of code are available, and the automated tests that guided their coding pass, take time to explore the functionality more deeply. Try different scenarios and learn more about the code’s behavior. You should have task cards for tests that critique the product both business and technology-facing. The story is not ‘done’ until all of these test types are done.

If your exploratory tests lead the team to realise that significant functionality was not covered by the stories, write new stories for future iterations. Keep a tight reign on “Scope Creep” or your team won’t have time to deliver the value you originally planned.

Technology-facing tests that critique the product are often done best during coding. This is the time to know if the design doesn’t scale or if there are security holes.

  • MANAGING DEFECTS
  • Leaving bugs festering n the code base has a negative effect on code quality, system intuitiveness, system flexibility, team morale and velocity.
  • Strive for “zero tolerance” towards bug counts.
  • Teams have solved the problem of how to handle defects in different ways.
    • Some teams put all their bugs on task cards
    • Some teams chose to write a cared, estimate it & schedule it as a story.
    • Some teams suggest adding a test for every bug
  • The more bugs you can fix immediately, the less technical debt your application generates and the less ‘defect’ inventory you have.
  • Try making the estimate for each story to include (atleast) two hours or half a day for fixing associated bugs.

If a bug is really missed functionality, choose to write a card for the bug and schedule it as a story.

Code produced test-first is fairly free of bugs by the time it is checked-in.

  • The Daily Stand-Up helps teams maintain the close communication they need.
  • Use Big, visible charts such as story boards, Burndown charts and other visual cues to help keep focus and know your status.
  • Having story boards gives your team focus suring the stand-ups or when you are talking to someone outside the team about your progress.

Communication

  • Testers can help keep the iteration progressing smoothly by helping make sure everyone is communicating enough. They can help programmers and customers find a common language.
  • Use retrospectives to evaluate whether collaboration & communication need improving and brainstorm ways to improve.
  • Teams in different locations have to make a special effort to keep each other informed.

Build Process

  • Teams take different approaches to make sure their build stays ‘green’.
  • The build needs to provide immediate feedback, so Keep It Short.
  • Tests that take too long, such as tests that update the database, functional tests above Unit level or GUI test scripts, should run in a separate build process.
  • Having a separate, continual ‘Full’ build with all of the regression suites is worth the investment.

During the iteration, you are automating new tests. As soon as these pass, add them to the Regression Suite.

As you start the iteration, make sure that test environments, test data, and test tools are in place to accommodate testing.

You may have brought in outside resources for the iteration to help with performance, security, usability or other forms of testing. Include them in stand-ups and discussions. Pair with them to help them understand the team’s objectives. This is an opportunity to pick up new skills!!

  • Consider what metrics you need during the iteration – Progress and Defect Metrics are 2 examples.
  • Whatever metrics you choose to measure – Go for Simplicity!

Read Along- ‘Agile Testing’ Chapter-17

Nishi Grover Garg2 Comments

“Iteration Kickoff”

  • Most teams kickoff their new iteration with a planning session. – where they discuss one story at a time, writing & estimating all of the tasks needed to implement it.
  • Task cards need to be written along with development task cards and estimated realistically.
  • When writing programming task cards, make sure that coding task estimates include time for writing unit tests and for all necessary testing by programmers.
  • Testers should help make sure that all necessary cards are written and they have reasonable estimates.

Your job as a tester is to make sure enough time is allocated to testing and to remind the team that testing & quality are the responsibility of the whole team. When the team decides how many stories they can deliver in an iteration, the question isn’t “How much coding can we finish?” but “How much coding and testing can we complete?”

Commit Conservatively – It is always better to bring in another story later than to drop a picked story.

  • Working closely with customers or customer proxies is one of the most important activities as an agile tester. Good communication usually takes work.
  • We want “big-picture” tests to help the programmers get started in the right direction on a story. High level tests should convey the main purpose behind the story.
  • Don’t forget to ask the programmers what they think you might have missed. What are the high-risk areas of the code? Where do they think testing should be focused?

When Testability is an issue, make it the team’s problem to solve.

One beneficial side-effect of reviewing the tests with programmers is the cross-learning that happens.

High level test cases along with executable tests you’ll write during the iteration will form the core of the application’s documentation.

People unfamiliar with agile development often have the misconception that there’s no documentation. In fact, agile projects produce usable documentation that contains executable tests and thus, is always up to date.

Read Along- ‘Agile Testing’ Chapter-16

Nishi Grover Garg1 Comment

“Hit the Ground Running”

  • Testers in agile must be proactive. Instead of waiting for work to come to them, they get up and go look for ways to contribute.
  • Working on stories in advance of the iteration may be useful for teams that are split across different geographic locations. By working ahead, there’s time to get information to everyone and give them a chance to give their input.
  • If we make our iteration planning go faster and reduce the risk of the stories we’re going to undertake, it’s worth doing some research and brainstorming before we start the iteration.

The Pre-Planning Meeting

  • Go Over stories for the next iteration
  • The Product owner explains the purpose of each story – business conditions of satisfaction.
  • Team brainstorms about potential risks and dependencies, asks questions and figures out the simplest path.
  • Pull in customers to answer questions, get a better idea.
  • Experiment with short Pre-Iteration discussions and Test-Writing sessions
  • Invest preparation time when it’s appropriate. There is a risk to ‘working ahead’.
  • To go Fast – We need to Slow Down First!

Teams that are distributed in multiple locations may do their iteration planning by conference call, online meeting or teleconference. ( And Cut to 2020 – Coronian Times – Every one of us is doing that!! )

  • One practice that Lisa’s team used was to assign each team a subset of the upcoming stories and have them write task cards in advance.

(I, too, have used this practice – only the Task Cards were in fact story Sub-tasks being created in JIRA for our user story items created by the PO)

  • If the customers aren’t readily available to answer questions and make decisions, other domain experts who are accessible at all times should be empowered to guide the team by determining priorities and expressing desired system behavior with examples.

(I have experienced that – our Product Owners essentially did this job for us)

  • Examples are an effective way to learn about and illustrate desired functionality. Using Examples, you can write high level tests to flesh out the story a bit more.
  • Mock-ups are essential for stories involving UI or a report. Ask your customers to draw up their ideas about how the page should look.
  • Before the next iteration – triage the outstanding issues with the customer. Those deemed necessary should be scheduled into the next iteration.

Read Along- ‘Agile Testing’ Chapter-14

Nishi Grover Garg2 Comments

“An Agile Test Automation Strategy”

Use the Agile Test Quadrants to help you identify the different types of test automation tools you might need for each project, even each iteration.

Test Automation Pyramid (introduced by Mike Cohn)

Lowest Layer- Bulk of automated unit , technology facing tests. Quickest feedback, code much more quickly using xUnit family of tools

Middle layer – Automated business-facing tests that help the team. “Are we building the right thing” Tests operate at the API, behind the GUI level. Bypass the presentation layer – less expensive to write & maintain these tests. Fit & FitNesse are good examples, written in domain language

Top Tier – Should be the smallest automation effort as they  have the lowest ROI. Done through GUI, operating on the presentation layer. More expensive to write, more brittle and need more maintenance.

The Test Automation Pyramid
  • Any tedious or repetitive task involved in developing software is a candidate for automation.
  • AN automated deployment process is imperative – getting automated build emails listing every change made is a big help to testers. It speeds up testing & reduces errors.
  • A fast running continuous integration and build process gives the greatest ROI of any automation effort.
  • Another useful area for automation is data creation or setup. Cleaning up test data is as important as generating it. You data creation toolkit should include ways to tear down the test data so it doesn’t affect a different test or prevent rerunning the same test.

What we shouldn’t automate

  • Usability testing
  • Exploratory testing
  • Tests that will never fail
  • One-Off tests
  • Plan-in plenty of time for evaluating tools, setting up build processes, and experimenting with different test approaches in the initial iterations.
  • If management is reluctant to give the team time to implement automation, explain the trade-offs clearly. Work towards a compromise.
  • We will always have deadlines, and we always feel pressed for time. There is never enough time to go back and fix things. During your next planning meeting, budget time to make meaningful progress on your automation efforts.
  • Good test management ensures that tests can provide effective documentation of the system and of the development progress

Read Along- ‘Agile Testing’ Chapter-9

Nishi Grover Garg1 Comment

“Toolkit for Business-Facing Tests that Support the Team”

  • As agile development has gained in popularity, we have more and more tools to help us capture and use them to write executable tests.
  • Your strategy for selecting the tools you need should be based on your team’s skill set, the technology your application uses, your team’s automation priorities, time, and budget constraints. Your strategy should NOT be based on the latest and coolest tool in the market.
  • In agile, simple solutions are usually best.
    • Some tools that can help us illustrate desired behavior with examples, brainstorm potential implementations and ripple effects and create requirements we can turn into tests are—
      • Checklists
      • Mind maps
      • Spreadsheets
      • Mockups
      • Flow diagrams
      • Software based tools
  • A picture is worth a thousand words, even in agile teams. Mock-ups show the customer’s desires more clearly than a narrative possibly could. They provide a good focal point to discussing the desired code behavior.
    • Visuals such as flow diagrams and mind maps are good ways to describe an overview of a story’s implementation, especially if it is created by a group of customers, programmers, and testers.
    • Tools such as Fit (Framework for Integrated Tests) and FitNesse were designed to facilitate collaboration and communication between the customer and development teams.
    • Finding the right electronic tools is particularly vital for distributed teams (chat, screensharing, video conferencing, calling, task boards etc.)
    • Selenium, Watir and WebTest are some examples of many open source tools available for GUI testing.
  • Home-Brewed Test Automation Tools
    • Bret Pettichord (2004) coined the term ‘home-brewed’ for tools agile teams create to meet their own unique testing needs. This allows even more customisation than an open source tool. They provide a way for non technical customer team members to write tests that are actually executable by the automated tool. Home-brewed tools are tailored to their needs, designed to minimize the total cost of ownership and often built on top of existing open source tools.

The best tools in the world won’t help if you don’t use them wisely. Test tools might make it very easy to specify tests, but whether you are specifying the right tests at the right time is up to you.

Writing detailed test cases that communicate desired behavior is both art and science.

Whenever a test fails in Continuous Integration (CI) and build process, the team’s highest priority should be to get the build passing again. Everyone should stop what they are doing and make sure that the build goes ‘green’ again. Determine if a bug has been introduced, or if the test simply needs to be updated to accommodate intentionally changed behavior. Fix the problem, check it in, and make sure all tests pass!

Experiment – so that you can find the right level of detail and the right test design for each story.

  • Keep your tests current and maintainable through refactoring.
  • Not all code is testable using automation but work with programmers to find alternative solutions to your problems.
  • Manual test scenarios can also drive programming if you share them with the programmers early. The earlier you turn them into automated tests, the faster you will realise the benefit.

Start with a simple approach, see how it works, and build on it. The important thing is to get going writing business-facing tests to support the team as you develop your product.

Read Along- ‘Agile Testing’ Chapter-2

Nishi Grover Garg1 Comment

“The Principles for agile testers”

Points to remember and Quotable Quotes

Definition of Agile Tester-

“A professional tester who embraces change, collaborates well with both technical and businesspeople, and understands the concept of using tests to document requirements and drive development.”

  • Skills are important, but attitude counts more
  • An agile tester does not see herself as a quality police officer, protecting her customers from inadequate code.
  • Agile testers don’t limit themselves to solving only testing issues.
  • Creativity, openness to ideas, willingness to take on any task or role, focus on the customer and a constant view of the big picture – are some components of the agile testing mindset.
  • A team that guides itself with agile values and principles will have higher team morale and better velocity than a poorly functioning team of talented individuals.
  • The principles important for agile testers are –
    • Provide continuous feedback
    • Deliver value to customer
    • Enable face-to-face communication
    • Have courage
    • Keep it Simple
    • Practice continuous improvement
    • Respond to change
    • Self-organize
    • Focus on people
    • Enjoy
  • AATD “Agile Attention Deficit Disorder” – Anything not learned quickly might be deemed useless!
  • Automating tests is hard, but it is much easier when you have the whole team working together.
  • Agile development rewards the agile tester’s passion for her work!

I had written an article about differences between Agile and Traditional testing approaches a few years back. Though I had not read this book at the time, I now feel how many of the points were similar and resonate the same even now. You can read my article here – https://testwithnishi.com/2016/10/20/5-ways-agile-testing-is-different-from-traditional-testing/

***Update **About face-to-face communication** during Covid-19 ***

As I am reading this book during this bizarre time of social-distancing, working remotely and entire nations on lockdown, the part about ‘face-to-face’ communication has a new meaning now. As Janet Gregory also pointed out in response to this article, our definition of face-to-face has changed over the last few weeks over the entire world! We are lucky to have technology that helps us continue effective communication within our teams, have conversations, video calls, screen shares, continue learning over webinars and continue working, feeling useful and being productive.

Hoping things change soon and we can go back to having fun, productive discussions with our team mates over coffee. Until then — Happy social distancing!

*************