In agile, all code is tested code.

If you can’t keep up with test, then you either have a) too many developers, or b) too many developers who are unwilling to test.

Developers & Testers Abstract

Developers & testers make up the majority of an Agile DBT team (7+/- 2 members). Developers write the code for the User Stories and conduct research, design, and prototyping with Spike or Refactor stories. They work collaboratively and may pair program with another developer or may pair with a tester. The developer’s responsibilities include collaborating with the Product Owner and testers to make sure the right code is being developed; writing the code, unit tests, and automated acceptance tests; and checking new code into the shared repository every day.

Testers work in parallel with developers to write acceptance test cases (also automated wherever possible) while the code is being written; interface with the product owner and developers to confirm that the code and acceptance tests reflect the desired functionality; execute acceptance tests; and maintain the test cases in a shared repository.

- Everybody tests. Everybody codes. -

Details

Sharing Quality Responsibilities Enhances Value Creation

Traditionally, the developer and tester roles have been strongly differentiated, often with each role reporting into a different management structure. Now, however, since both are required for the creation of value and everything that enables value – the roles blend and they are each part of the same team. For example, Cohn ([1] Chapter 8) no longer distinguishes the roles and just calls everyone “Developers”, because both are necessary to create value.

In addition, in Agile, all code is tested code. Teams get no credit for anything else. To achieve this

Developers test: they take pride in ensuring code correctness themselves
Testers develop test scripts (code) and go further in actively critiquing the behavior of the code
Developers and testers work together daily (hourly) to ensure that each story satisfies the Definition of Done
Developers and testers avoid formalities, hand-offs, and sign-offs. Rather, they simply work together from day one until the story is accepted by the product owner
Developers often assist testers in creating fixtures and automated acceptance tests
Testers help developers understand edge cases and efficient data sets to more thoroughly test the code.

In this way, Agile encourages multi-specialization of team members to foster collaboration and innovation, and to eliminate bottlenecks to velocity.

Design for Testability

Agile developers consciously evolve the system design to support testability. In practice design for testability and good design are synonymous and imply modularity, low coupling and high cohesion of layers, components, and classes (see more on Designing for Testability). In turn, Designing for ‘Testability supports the testability of any separate fragment of logic as well as the ability to create higher, system-level, integration tests.

Collaboration and Knowledge Sharing

In Agile, colocation of developers and testers optimizes delivery velocity and quality, as do small teams that can deliver value quickly. This is the “yin” that creates empowered Agile teams. The “yang”, however, is that developers no longer operate collectively from a pool, where one could argue that it was easier to learn, share and advance collective competencies. To address this, the Agile enterprise must consciously create an environment where best practices and knowledge, including the new found Agile skills such as continuous integration, collective code ownership, automated unit- and acceptance testing, are easily shared across teams.

This is often facilitated by Communities of Practice (CoP)—informal working groups designed specifically for efficient knowledge sharing and exploration across teams and groups of professionals as shown in the Figure. For example, an Automated Testing CoP may be comprised of test engineers and developers that are interested in advancing these skills. Still others may be formed around Continuous Integration, Continuous Delivery, coding standards and other new practices and processes.

Community of Practice. Members normally work in their Agile teams but also regularly share best practices.

Developers and testers are at the heart of Agile development – they work in small, cross-functional teams and can thereby quickly create working tested code that delivers value. The line between development and test is blurred. Developers test and testers code test scripts. Cross team and Community of Practice collaboration is also critical as there are new languages, frameworks, processes and tools that must be mastered for them to efficiently build complex solutions while continuously increasing their individual, professional expertise.

Learn More

References
[1] Cohn, Mike. Succeeding with Agile: Software Development Using Scrum. 2009.

Leffingwell, Dean. Agile Software Requirements: Lean Requirements Practices for Teams, Programs, and the Enterprise,Addison-Wesley, 2011. chap. 4.

Larman, Craig, Vodde, Bas. Practices for Scaling Lean & Agile Development: Large, Multisite and Offshore Product Development with Large-Scale Scrum, Addison-Wesley, 2010, chap. 3.

Last update 15 January, 2013