See Part 1 of this article.
In Part 1, I looked at some of the conflicts and incompatibilities between experience design and agile development. To date, most formulae for a marriage of methods between these two have focused on how experience design can accommodate to agile development. In Part 2, I look at some things developers and development teams ought to consider in order to make the relationship work better.
What would be required for a better marriage between experience design and agile development? I think the main ingredients are straightforward:
These may seem like simplistic slogans borrowed from social work, but for each area, there are very specific things that can be done to make agile development better able to deliver highly usable systems through collaboration with experience design.
We are all professionals, yet developers too often look down on experience designers as muddle-headed, touchy-feely types drawing on soft-science impressions and unsupported opinion. To be honest, I have also known some designers who see developers as narrowly focused, socially inept techno-nerds stuck inside their code. In truth, programmers and designers alike need to learn to be better at acknowledging and deferring to each other’s expertise.
Programmers need to accept the expertise of user experience and interaction designers independent of whether it is based on informed judgment, professional experience, or new evidence. A programmer would never sit still for an experience designer telling them which programming language to use or which methods belong with which object classes. On the other hand, I have watched countless times as programmers argued with designers over the placement or operation of user interface widgets or over what would be the best way to offer a feature to users. Designers do not insist that programmers defend their algorithms or database architecture or demonstrate superiority with comparative testing of alternative code, yet interaction designers are often told to “prove it” with user testing results. I have even seen cases when user testing confirmed the judgment of the design team, but the developers, convinced that they knew better than both end users and experience designers, programmed the user interface the way they wanted to anyway.
Designers and developers need to be co-equals in the development process. I confess that I have personally come to believe that, for greatest success in most instances, experience design should drive the process and that, for the most part, user experience issues should trump implementation issues. If it comes down to the position and opinion of the developers on the one side and the designers on the other, most of the time, the outcome is better if the nod goes to the best design. However, in practice, a more workable compromise is to consider developers and their concerns and designers and theirs as equally important.
In cases of irreconcilable differences, rather than filing for divorce between the design team and the development team, the decision should go to binding arbitration. In most organizations, the product owner is probably the most appropriate arbiter, because the product owner is most likely to have the broad perspective on the varied and competing short- and long-term objectives for the product. In general, it is the product owner who bears the most direct responsibility for balancing conflicting forces to achieve product success.
Obviously, only major issues should be escalated to this level; we don’t want to involve management in every little disagreement. Mutual respect and equality means that sometimes ease of programming will trump ease of use or that features and characteristics that are recognized as absolutely essential for usability will be reluctantly deferred for later release. The operant word here is sometimes.
One of the most effective ways to build mutual respect and equality is through knowledge. We need to learn much more about each other’s skills and areas of expertise. In the Carnegie Mellon/University of Madeira dual-degree program in human-computer interaction in which I teach, all students, including artists and psychologists, are expected to acquire a basic knowledge and demonstrate elementary ability in software engineering and user interface programming. We do not expect everyone to become a software engineer or professional programmer; we do believe that to design user interfaces well requires knowledge of what goes on both in front of the screen and behind it.
Conversely, every programmer on the agile development team should have some training and background in usability and user interface design—at least enough so that he understands basic usability and design principles and has thoroughly accepted that his own personal preferences are not usually representative. (“We are not our users, and we are not like them.”) It’s not that hard. Training developers in interaction design is one of the ways Lucy Lockwood and I got into trouble with the human-computer interaction establishment, but thousands of developers around the world have learned the rudiments of designing software for use. Most of them will never become full-fledged interaction designers, but they will be better partners in the design and development process.
Another argument for spreading the skills is that even the most thorough presentation and interaction design will not and cannot cover everything down to the lowest detail, and will always fail to anticipate some interaction or presentation issues. In practice, programmers inevitably end up making many user interface design decisions on the fly—everything from whether or not to align certain visual components to creating unanticipated error messages to deciding whether column headers on a grid display should be active to sort on that column. Not only does knowing the fundamentals of interaction design contribute to better teamwork and more successful collaboration with designers, but it is also in keeping with the ethic of cross-training and fungible skills that permeates agile methods.
Any good marriage allows for independent thought and activity, which can be a problem for meshing the work of user experience designers and software developers. The impulse to launch immediately into productive work on day one is understandable and all but universal for both designers and developers. Designers start sketching screen layouts or product designs in first meetings, and programmers start writing little bits of code as soon as they can get their hands to the keyboard. And management makes the matter worse by pushing for visible deliverables from day one.
I recall one agile design project I worked on under a seemingly impossible deadline. On the third day of the project, a senior manager dropped into the design team’s situation room to see how we were doing and immediately asked to see some screen designs. While his anxiety escalated, we explained that we wanted to figure out what it was we were designing and what it should do before we began drawing pictures of the final product. What a radical idea! We chose to build a rich, detailed task model using essential use cases and to figure out from that what screens were needed and how they were interconnected before we even started sketching low-fidelity prototypes. It frustrated the manager, but enabled us to awe him later when we delivered a breakthrough prototype.
Alas, doing much in the way of upfront field study, modeling, and design conflicts with agile principles. One way to resolve—or at least reduce—this conflict is to decouple design and development. Many teams have devised variations on a one-sprint-ahead model, in which the user experience effort is chopped up into short segments running concurrently with development, with the user experience team staying one cycle ahead and delivering just-in-time input to user stories. Another proven approach that is more in keeping with the needs of experience design is to use an initial triage aimed at what engineers refer to as a separation of concerns.
Good experience design requires at least some initial field research in order to build a rich understanding and reliable insight into users and user needs. In most contexts, field work makes the most sense when it is done upfront and, although there are ways to streamline and accelerate field work, such as by model-driven inquiry, the activity can only be compressed or cut so far without markedly increasing the risk of building the wrong system for the wrong audience.
Instead of prolonging a so-called sprint zero or resorting to the silliness of sprints minus one to N, upfront user experience activities can be allowed to proceed at their own pace without delaying development if, early in the project, designers and developers engage in an explicit triage process. Based on what is known and understood at the time, the triage separates the anticipated features and functions, content, and capabilities of the product into three buckets:
The interface bucket includes those things that have a direct and substantial impact on user experience or for which a significant amount of design thinking may be required to get it right. Examples include most aspects of the so-called presentation layer, such as screen layout, information display, or menu structure, as well as workflow, navigation architecture, and the like.
The internals bucket includes those things that are largely independent of interaction design or with little or limited impact on user experience. More or less pure examples might include most things falling under the rubric of “model” in a model-view-controller architecture or such things as computation algorithms, database organization and implementation, and communications protocols.
The third catchall category, the interdependent bucket, includes anything that entails a substantial mix of interface and internal design issues or that is ambiguous or indeterminate given the state of knowledge at that point in the project.
The purpose of this triage is to enable the development team to begin iterative, incremental development of things from the internals bucket while the user experience team completes field work and devises an overall user interface architecture and high-level design and begins work on various things in the interface category. Of course, it is rarely possible to make a truly clean separation of interface, internal, and interdependent issues, but in my experience performing this triage allows a considerable amount of concurrent engineering of software along with design of user interaction while reducing risk and restricting later changes to a manageable minimum, even with an imperfect partitioning.
In sum, what I am proposing is a fairly simple formula for better relations with experience designers: Learn more about experience design, respect your design colleagues and their expertise, treat them as equal partners in the process, and facilitate independent but coordinated activity that allows for a deeper and broader initial design effort. I don’t believe these suggestions require radical reworking of most agile development, but they do demand that developers make more accommodations and meet their partners in the process half-way.
Now, may your union be a long and prosperous one!
Larry Constantine is an award-winning interaction designer, a pioneer in software engineering, and a novelist. Under his pen name, Lior Samson, his first novel, Bashert, has already been published and a second, The Dome, is slated for October release. Both are fast-paced political thrillers with technology twists—stories “to feed the inner nerd,” as one reviewer phrased it. They are available from Amazon and http://www.liorsamson.com. Constantine’s day job is as Institute Fellow at the Madeira Interactive Technologies Institute and as professor at the University of Madeira.