From the Book:
“Clean code that works” is Ron Jeffries’ pithy phrase. The goal is clean code that works, and for a whole bunch of reasons:
Clean code that works is a predictable way to develop. You know when you are finished, without having to worry about a long bug trail.Clean code that works gives you a chance to learn all the lessons that the code has to teach you. If you only ever slap together the first thing you think of, you never have time to think of a second, better, thing. Clean code that works improves the lives of users of our software.Clean code that works lets your teammates count on you, and you on them.Writing clean code that works feels good.But how do you get to clean code that works? Many forces drive you away from clean code, and even code that works. Without taking too much counsel of our fears, here’s what we do—drive development with automated tests, a style of development called “Test-Driven Development” (TDD for short). 
In Test-Driven Development, you:
Write new code only if you first have a failing automated test.Eliminate duplication.

Two simple rules, but they generate complex individual and group behavior. Some of the technical implications are:You must design organically, with running code providing feedback between decisionsYou must write your own tests, since you can’t wait twenty times a day for someone else to write a testYour development environment must provide rapid response to small changesYour designs must consist of many highly cohesive, loosely coupled components, just to make testing easy

The two rules imply an order to the tasks ofprogramming:
1. Red—write a little test that doesn’t work, perhaps doesn’t even compile at first
2. Green—make the test work quickly, committing whatever sins necessary in the process
3. Refactor—eliminate all the duplication created in just getting the test to work


Red/green/refactor. The TDD’s mantra.

Assuming for the moment that such a style is possible, it might be possible to dramatically reduce the defect density of code and make the subject of work crystal clear to all involved. If so, writing only code demanded by failing tests also has social implications:
If the defect density can be reduced enough, QA can shift from reactive to pro-active workIf the number of nasty surprises can be reduced enough, project managers can estimate accurately enough to involve real customers in daily developmentIf the topics of technical conversations can be made clear enough, programmers can work in minute-by-minute collaboration instead of daily or weekly collaborationAgain, if the defect density can be reduced enough, we can have shippable software with new functionality every day, leading to new business relationships with customers


So, the concept is simple, but what’s my motivation? Why would a programmer take on the additional work of writing automated tests? Why would a programmer work in tiny little steps when their mind is capable of great soaring swoops of design? Courage.
Courage
Test-driven development is a way of managing fear during programming. I don’t mean fear in a bad way, pow widdle prwogwammew needs a pacifiew, but fear in the legitimate, this-is-a-hard-problem-and-I-can’t-see-the-end-from-the-beginning sense. If pain is nature’s way of saying “Stop!”, fear is nature’s way of saying “Be careful.” Being careful is good, but fear has a host of other effects:
Makes you tentativeMakes you want to communicate lessMakes you shy from feedbackMakes you grumpy

None of these effects are helpful when programming, especially when programming something hard. So, how can you face a difficult situation and:
Instead of being tentative, begin learning concretely as quickly as possible.Instead of clamming up, communicate more clearly.Instead of avoiding feedback, search out helpful, concrete feedback.(You’ll have to work on grumpiness on your own.) 

Imagine programming as turning a crank to pull a bucket of water from a well. When the bucket is small, a free-spinning crank is fine. When the bucket is big and full of water, you’re going to get tired before the bucket is all the way up. You need a ratchet mechanism to enable you to rest between bouts of cranking. The heavier the bucket, the closer the teeth need to be on the ratchet.

The tests in test-driven development are the teeth of the ratchet. Once you get one test working, you know it is working, now and forever. You are one step closer to having everything working than you were when the test was broken. Now get the next one working, and the next, and the next. By analogy, the tougher the programming problem, the less ground should be covered by each test.

Readers of Extreme Programming Explained will notice a difference in tone between XP and TDD. TDD isn’t an absolute like Extreme Programming. XP says, “Here are things you must be able to do to be prepared to evolve further.” TDD is a little fuzzier. TDD is an awareness of the gap between decision and feedback during programming, and techniques to control that gap. “What if I do a paper design for a week, then test-drive the code? Is that TDD?” Sure, it’s TDD. You were aware of the gap between decision and feedback and you controlled the gap deliberately.

That said, most people who learn TDD find their programming practice changed for good. “Test Infected” is the phrase Erich Gamma coined to describe this shift. You might find yourself writing more tests earlier, and working in smaller steps than you ever dreamed would be sensible. On the other hand, some programmers learn TDD and go back to their earlier practices, reserving TDD for special occasions when ordinary programming isn’t making progress.

There are certainly programming tasks that can’t be driven solely by tests (or at least, not yet). Security software and concurrency, for example, are two topics where TDD is not sufficient to mechanically demonstrate that the goals of the software have been met. Security relies on essentially defect-free code, true, but also on human judgement about the methods used to secure the software. Subtle concurrency problems can’t be reliably duplicated by running the code.

Once you are finished reading this book, you should be ready to:
Start simplyWrite automated testsRefactor to add design decisions one at a time

This book is organized into three sections.
An example of writing typical model code using TDD. The example is one I got from Ward Cunningham years ago, and have used many times since, multi-currency arithmetic. In it you will learn to write tests before code and grow a design organically.An example of testing more complicated logic, including reflection and exceptions, by developing a framework for automated testing. This example also serves to introduce you to the xUnit architecture that is at the heart of many programmer-oriented testing tools. In the second example you will learn to work in even smaller steps than in the first example, including the kind of self-referential hooha beloved of computer scientists.Patterns for TDD. Included are patterns for the deciding what tests to write, how to write tests using xUnit, and a greatest hits selection of the design patterns and refactorings used in the examples.

I wrote the examples imagining a pair programming session. If you like looking at the map before wandering around, you may want to go straight to the patterns in Section 3 and use the examples as illustrations. If you prefer just wandering around and then looking at the map to see where you’ve been, try reading the examples through and refering to the patterns when you want more detail about a technique, then using the patterns as a reference.

Several reviewers have commented they got the most out of the examples when they started up a programming environment and entered the code and ran the tests as they read.

A note about the examples. Both examples, multi-currency calculation and a testing framework, appear simple. There are (and I have seen) complicated, ugly, messy ways of solving the same problems. I could have chosen one of those complicated, ugly, messy solutions to give the book an air of “reality.” However, my goal, and I hope your goal, is to write clean code that works. Before teeing off on the examples as being too simple, spend 15 seconds imagining a programming world in which all code was this clear and direct, where there were no complicated solutions, only apparently complicated problems begging for careful thought. TDD is a practice that can help you lead yourself to exactly that careful thought.

Test Driven Development: By Example

This paper presents the results of a systematic review of existing literature on the integration of agile software development with user-centered design approaches. It shows that a common process model underlies such approaches and discusses which artifacts are used to support the collaboration between designers and developers.

/pdf/user-centered-design-and-agile-methods-a-systematic-review-4g6r8hblnw.pdf

User-Centered Design and Agile Methods: A Systematic Review

ContextIn the last decade, software development has been characterized by two major approaches: agile software development, which aims to achieve increased velocity and flexibility during the development process, and user-centered design, which places the goals and needs of the system's end-users at the center of software development in order to deliver software with appropriate usability. Hybrid development models, referred to as user-centered agile software development (UCASD) in this article, propose to combine the merits of both approaches in order to design software that is both useful and usable. ObjectiveThis paper aims to capture the current state of the art in UCASD approaches and to derive generic principles from these approaches. More specifically, we investigate the following research question: Which principles constitute a user-centered agile software development approach? MethodWe conduct a systematic review of the literature on UCASD. Identified works are analyzed using a coding scheme that differentiates four levels of UCASD: the process, practices, people/social and technology dimensions. Through subsequent synthesis, we derive generic principles of UCASD. ResultsWe identified and analyzed 83 relevant publications. The analysis resulted in a comprehensive coding system and five principles for UCASD: (1) separate product discovery and product creation, (2) iterative and incremental design and development, (3) parallel interwoven creation tracks, (4) continuous stakeholder involvement, and (5) artifact-mediated communication. ConclusionOur paper contributes to the software development body of knowledge by (1) providing a broad overview of existing works in the area of UCASD, (2) deriving an analysis framework (in form a coding system) for works in this area, going beyond former classifications, and (3) identifying generic principles of UCASD and associating them with specific practices and processes.

Exploring principles of user-centered agile software development

A core principle of agile development is to satisfy the customer by providing valuable software on an early and continuous basis. For a software application to be valuable it should have a user interface that is usable. Recently there has been some evidence that suggests using agile methods alone does not ensure that an applications UI is usable. As a result, there is currently interest in combining Agile methods with user-centered design (UCD) practices. To support existing empirical evidence that these methodologies co-exist effectively we have conducted a study with participants that have previously combined these two methodologies. Our findings, combined with existing work show that the existing model used for agile UCD integration can be broadened into a more common model. In this paper we describe three different approaches taken by our participants to achieve this integration. We term these approaches the generalist, specialist, and the hybrid approach.

http://ase.cpsc.ucalgary.ca/uploads/Publications/FoxAgile2008.pdf

Agile Methods and User-Centered Design: How These Two Methodologies are Being Successfully Integrated in Industry

The various agile software development methodologies have promoted since their inception and even demanded high degree to improve the quality of the software product. Usability engineering has made its way into the software mainstream and has caught the attention of software engineers and researchers worldwide due to rapidly growing and volatile internet software industry, despite their different perspectives on creating software both have a major role in making good software. Usability focuses on how the end users will work with the software and agile development focuses on how the software should be developed. The way these two perspectives are being combined in practice is still not well understood. This study is a preliminary literature review that describes the key question that how usability-engineering practices should be integrated with agile software development in order to make stronger and effective usable software system. This paper focuses on identifying the tensions between usability and agile methods. The research aim is to identify the common approach of agile methods and usability engineering by surveying extensive related work on integration of usability and agile methods.

Integrating usability engineering and agile software development: A literature review

Extreme Programming appears to be a solution for discovering and meeting requirements faster (through close customer collaboration) as well as creating quality software. In practice we found XP did deliver high quality software quickly, but the resulting product still failed to delight the customer. Although the finished product should have been an exact fit, the actual end-user still ended up slogging through the system to accomplish necessary day-to-day work. This paper describes using interaction design in an agile development process to resolve this issue. Using interaction design as a day-to-day practice throughout an iterative development process helps our team at Tomax Technologies deliver high quality software, while feeling confident the resulting software will more likely meet end-user expectations. The method of Interaction Design followed here is based on Constantine and Lockwood's Usage-Centered Design. Recommendations are provided on how to practice an agile form of U-CD and how to incorporate bits of Interaction Design thinking into every day development and product planning decisions.

Hitting the target: adding interaction design to agile software development

While the iterative development approaches found in Agile Software Development fulfill the promise of working software each iteration, the task of choosing which software to build first can be formidable.This experience report discusses my team's experience working with a large healthcare company writing software for use in their hospital's newborn intensive care unit (NICU). The very large scope of this project and the urgent need for delivery made project release planning difficult. Focusing on capturing feature details in XP style user stories led to confusion about priorities and release strategy. Making good use of User Centered Design user role models and task models gave us the big picture we needed to un-stick the release planning process and effectively choose the bit of project scope we needed to focus on for our first and subsequent releases.

Finding the forest in the trees

Agile development is being adopted by many leading software companies, such as those represented by this panel. Though many instructional resources exist to guide companies through a change to Agile Development, there are few resources available on the subject of Agile development and User Centered Design (UCD). As a result, user experience practitioners have had to develop their own tactics and strategies for maintaining sound UCD practices within their organizations when moving to Agile. This panel consists of six practitioners who actively work with development teams using Agile. Panel members will share the challenges and successes they face while championing UCD within their respective development organizations. Panelists will focus on adaptations to research methodology and strategy that make UCD possible to attain within Agile cultures.

Extreme usability: adapting research approaches for agile development

The importance of integrating software engineering and HCI methods has been recognised for many years. Agile development is a new approach to software engineering that explicitly champions an active role for the customer. Indeed, eXtreme Programming (XP), one of the most popular agile development methods, strives to include a real user(s) in the team who is located 'on-site' with software developers.In this panel we will debate whether or not agile software development provides an opportunity to integrate HCI and software engineering concerns. The panel members represent a wide cross-section of experiences in this area and will consider how agile development can help improve the current situation, consider specific example scenarios provided by the audience, and, with the audience's help, will decide whether agile development is an opportunity not to be missed, or just another fad that will pull the two communities further apart.

Jeff Patton

Papers

Hitting the target: adding interaction design to agile software development

Finding the forest in the trees

Extreme usability: adapting research approaches for agile development

Agile development: opportunity or fad?