Agile Testing/Specification Practices

We’ve gained tremendous traction in understanding that there is a place for testers in agile teams. Yes, programmers write tests in agile development, but the effort doesn’t stop there. Quality and testing professionals bring tremendous experience, value, and are simply required in many business domains and agile contexts.

What we struggle with today is the HOW of effective agile testing. There are many challenges. For example, testing in regulated environments, integrating effective test automation across teams, testing “at-scale” in larger teams / environments and in distributed teams, designing multi-sourced automation integrated with CI, effectively converging traditional & agile testing techniques, and simply figuring out how to influence quality are some of the common challenges we face daily.

The Testing & Specification Stage provides a venue for participants with challenges like these, and presenters with the experience to provide guidance, if not answers. We’re seeking submissions that help testers and agile teams succeed in defining and delivering high quality software. As test-driven development at the unit level is more focused on design than testing, this stage will focus on types of testing beyond developer tests, such as acceptance, functional, system, end-to-end, usability and other ‘ilities’, performance, stress, load and other business- and technology-facing tests. We also focus topics surrounding how to champion quality both at a team and organizational level.


Dance of the Tester, An Iteration-Length Performance

Ever wonder what a tester does on an agile team? It can be confusing for everyone on the team trying to understand when there isn't a test phase or any formal documented requirements. In this tutorial, we follow an agile tester. We start with how testers contribute during release and iteration planning. Then we follow a tester through a typical two-week iteration, from the start through to the end, to see what activities he does and how he adds value. Like a dance, everyone has a role in the finale, so we look at the agile tester’s role in a successful release, including the end game.

Presenter(s): Janet Gregory
Day and Time: Monday, 09 August 2010, 09:00 - 12:30   Add to Calendar
Location: Asia 2
Level: Introductory
Presentation: Download Slides

Better Story Testing through Programmer-Tester Pairing

You know how "Agile" works: programmers test drive their code via (A)TDD with testers automating much of the story tests. But how does it **really** work? Do testers and programmers work together (YES!)? What does this interaction look like? In this hands-on demonstration, we'll walk you through how to drive quality on your projects by pairing testers and programmers. We'll use FitNesse to create effective story tests and keep them passing as the software evolves with each iteration. Bring a laptop and spend some time as a paired dev/test team!

Presenter(s): Abby Fichtner , Dawn Cannan
Day and Time: Monday, 09 August 2010, 13:30 - 17:00   Add to Calendar
Location: Asia 3
Level: Practicing

BDD for the SmartGrid

Developing applications for the Smart Grid presents challenges to the agile team in this demanding and emergent field. The technology is changing very rapidly as the Smart Grid emerges. In addition this is a mission critical area where failure can have disastrous effects. This seminar will demonstrate how the combination of a 'layered approach' to testing including Behavior Driven Design (BDD) using tools like Cucumber, combined with physical Smart Grid device testing that supports an agile, iterative development methodology that is rigid enough for utility company and consumers that need it.

Presenter(s): Tim Walker
Day and Time: Tuesday, 10 August 2010, 11:00 - 12:00   Add to Calendar
Location: E-1
Level: Practicing

How Low Can You Go: Doing the Defect Management Limbo

In the party game Limbo, you set a bar lower and lower. Players must dance under the bar without touching the floor. When it comes to bugs, we also want to set the bar lower – fewer bugs are better. How do we do that, and what about our huge defect queue? Lean development tells us queues are waste, but don't we need defect tracking systems (DTS)? We’ll discuss different approaches to bugs, from “fix and forget” to lightweight DTS. We’ll look what we can learn from bugs, including Antony Marcano’s “hidden backlog” concept. We’ll explore agile ways to prevent bugs.

Presenter(s): Lisa Crispin
Day and Time: Tuesday, 10 August 2010, 13:30 - 15:00   Add to Calendar
Location: E-1
Level: Practicing

Testing When You're Not Automated (Yet)

Ideally, as an Agile tester you would enjoy full participation of customers and programmers in creating automated acceptance tests for every feature before it’s coded, and manual regression testing would be a thing of the past. For many reasons, this is not often the case. How do you balance releasing rapidly with adequate testing, especially when you’re dealing with an existing product with few or no automated tests? In this tutorial you'll practice simple, proven techniques for quickly getting control of manual testing on an Agile project, while making time for learning and improvements.

Presenter(s): Kay Johansen , Zhon Johansen
Day and Time: Tuesday, 10 August 2010, 15:30 - 17:00   Add to Calendar
Location: E-1
Level: Introductory

Ten tips every agile team should know about Performance testing

This session covers 10 tips successful agile teams have used to ensure their success. Learn performance anti-patterns like "Too green for his own good" and "Scrooge" and how to spot them before it is too late. Learn how to prevent problems in the first place using techniques like "Test early, test often" and "Listen to your users" (Yeah, that one is obvious). You will even get to play a fun game that will teach you spot some performance problems like a pro.

Presenter(s): Jeff Norris
Day and Time: Wednesday, 11 August 2010, 09:00 - 10:30   Add to Calendar
Location: E-1
Level: Practicing

Experiences on test planning practices in Agile mode of operation

The presentation describes how the test planning practices have evolved in our large scale organization when moving from the waterfall style software development towards Agile ways of working. It discusses the different aspects of the test planning: Which activities are required in the high level release vs. detailed sprint planning? What is the difference between the team level planning vs. planning required across the teams in a large organization? Examples of useful practices are presented as well as experiences on things which have not worked so well.

Presenter(s): Eveliina Vuolli
Day and Time: Wednesday, 11 August 2010, 11:00 - 11:30   Add to Calendar
Location: E-1
Level: Practicing

Turning mountains into molehills: A story of QA

Dave Haeffner had just changed jobs within his company. Completely shifting his career paradigm from Systems Administration to Quality Assurance. If only he knew the challenges that faced him in the year ahead. He might get excited, or maybe, he would have thought twice. There was very little he knew about his new role but that didn't worry him. The mountainous challenges that faced QA is what kept him up at night. Join him as he retraces his steps, sharing lessons learned, how he helped change QA from the bottom up, and how he turned those mountainous challenges into molehills.

Presenter(s): Dave Haeffner
Day and Time: Wednesday, 11 August 2010, 11:30 - 12:00   Add to Calendar
Location: E-1
Level: Practicing

Testing Olympics! Teams Compete to Solve Agile Testing Challenges

Join us for team-based games and compete to solve the agile testing challenges we all face. Do you still have separate “dev” and “test teams”? Mired by mini-waterfalls? Testing at the end of the release? Buried by “manual monkey scripts?” We’ll fearlessly tackle these and more in a fun and humorous series of improv sketches, root-cause roundtables, and “what if” scenarios. We’ll learn from each other in a friendly competitive environment as teams vote for the best ideas. You’ll leave with fresh thinking to resolve or prevent these testing dysfunctions on your agile teams.

Presenter(s): Nate Oster
Day and Time: Wednesday, 11 August 2010, 13:30 - 15:00   Add to Calendar
Location: E-1
Level: Practicing

Why Your Selenium Tests are so Dang Brittle, and What to Do About It

If you are writing automated through-the-GUI tests for a web application, you are in danger of creating tests that are more expensive to maintain than they are worth. With well-factored Selenium RC tests running in Junit or TestNG, you can keep your abstraction layers or "Lingos" -- small bounded bits of slang for discrete parts of the object model -- separate, thereby reducing the maintenance costs of your tests, and improving your sanity. Prerequisites include experience with Java or C#, and ideally some *basic* OOD familiarity (inheritance, composition, encapsulation, polymorphism).

Presenter(s): Patrick Wilson-Welsh , Dawn Cannan
Day and Time: Wednesday, 11 August 2010, 15:30 - 17:00   Add to Calendar
Location: E-1
Level: Introductory

Executable Specifications and Domain Specific Languages for Software Teams

Many agile projects strive to automate their acceptance tests, but rarely achieve the automation they desire. Recent advances in the use of Domain Specific Languages (DSL), testing frameworks like Cucumber, Fitnesse, RSpec and languages like Ruby and Scala provide a rich set of tools to effectively automate customer acceptance tests. This tutorial will leverage actual project examples on how to effectiveley to use Cucumber, Fitnesse, RSpec, Selenium, Ruby and Scala to create human readable, executable user story specifications.

Presenter(s): John Goodsen
Day and Time: Thursday, 12 August 2010, 09:00 - 10:30   Add to Calendar
Location: E-1
Level: Practicing

Story Testing and the 3 Amigos – an experience report

We are actively writing story tests first as 3 amigos (business, dev, & qa). The team was struggling with some “accordian effect” of a batch of stories in building and then a week later a batch in verify. Defects were being found late and often due to misinterpretation of requirements. And we had features that were going to be difficult for GUI automation. We will talk about how the 3 amigos were done and how they helped. We will talk about the specifics of the tests written and their impact on design. And we’ll also discuss hiccups along the way and things to still work on.

Presenter(s): Rob Park
Day and Time: Thursday, 12 August 2010, 11:00 - 11:30   Add to Calendar
Location: E-1
Level: Practicing
Presentation: Dowload Slides

Iterative Performance Testing

Performance testing can be a challenge in Agile development. On a large scale Gap program, we applied some strategies to ensure high availability and performance that exceeds the business expectation. We used an iterative approach, starting with a basic test of the first working code base. That became the baseline that we built upon, by adding more complex and realistic test scenarios as new features were built. In addition we included soak and load tests in the baseline suite. Another iterative approach we applied is to find the breaking point for the system and how it changes over time.

Presenter(s): Michael Elbaz , Alex Kwan
Day and Time: Thursday, 12 August 2010, 11:30 - 12:00   Add to Calendar
Location: E-1
Level: Practicing

Agile Test Case Management

'...over comprehensive documentation' is sometimes interpreted as 'no documentation' but that can be somewhat reckless. There are good reasons for documenting your test cases and their execution. This session looks at some lightweight, dare I say, Agile ways of managing your test cases including mindmaps, checklists and wikis.

Presenter(s): Adam Goucher
Day and Time: Thursday, 12 August 2010, 13:30 - 15:00   Add to Calendar
Location: E-1
Level: Introductory

Non-Functional Requirements, Agile Style

Agile teams typically apply user stories to capture functional requirements - the “what” the system will do. However, agile literature and practice provides little or no guidance on establishing “how well”, in aggregate, the system performs those functions. This tutorial introduces simple, proven practices for defining and testing nonfunctional requirements (aka system qualities) including integration into your agile processes. You will learn how to define and quantify the right system qualities so everyone understands the system's expected performance.

Presenter(s): Ryan Shriver , Dean Leffingwell
Day and Time: Thursday, 12 August 2010, 15:30 - 17:00   Add to Calendar
Location: E-1
Level: Introductory

Telling Your Exploratory Story

Exploratory testing is an approach emphasizing freedom and creativity. For projects that use Agile values and principles, there are two areas where exploration might be particularly useful -- story creation and feature integration. The first may involve a brainstorm using heuristics that trigger ideas about structure, functions, data, platform, operations, and time (to name a few). Feature integration can benefit from chartered, time-boxed sessions where structured exploration exposes new risks and vulnerabilities. This talk is about methods to describe the thoughtful testing of those stories.

Presenter(s): Jon Bach
Day and Time: Thursday, 12 August 2010, 15:30 - 17:00   Add to Calendar
Location: Southern Hemisphere III
Level: Practicing
Presentation: Download Slides

Stage Sponsor

Your Logo Here!
Please contact Phil Brock to sponsor this stage.

Stage Producer

  • Producer: Bob Galen

  • Co-Producer: Lisa Crispin

Contact us