Developers, I know this might hurt, but it has to be said. Code that feels beautiful and logical to developers doesn’t magically produce software that feels beautiful and logical to users.
The sad state of most software is largely a result of ignorance of this distinction, leading to development practices that privilege the concerns of developers above those of users.
I found a striking example of this in Eric Evans’ well-regarded book, Domain-Driven Design. The needs of users appear as only a shadow amidst discussion about the design of data and logic.
This is the design process that Evans recommends:
- Developers extract and clarify domain knowledge through conversations with domain experts (who may not be the actual users of the software).
- Through great intellectual effort, developers and domain experts work out a model and a shared language for it.
- Back-and-forth dialogue and experience with the code help them refine the model.
- Within each part of the system, developers build the software around the model created with the domain experts.
The deficiency of this approach for building human-facing systems is illustrated by an example provided by Evans himself. In the example, he tries to show the dangers of "superimposing" a UI model that differs from the underlying business/development model.
A user of Internet Explorer thinks of "Favorites" as a list of names of Web sites that persist from session to session. But the implementation treats a Favorite as a file containing a URL, and whose filename is put in the Favorites list. That's a problem if the Web page title contains characters that are illegal in Windows filenames. Suppose a user tries to store a Favorite and types the following name for it: "Laziness: The Secret to Happiness". An error message will say: "A filename cannot contain any of the following characters: \ / : * ? " < > | ".
In Evans’ opinion, silently removing illegal characters may be benign in this case, but silently changing data is unacceptable in most applications. He offers two possible fixes:
- Expose the underlying filesystem to the user and have them deal with Favorites as they would any other file.
- Change the way Favorites are stored to eliminate the problem of illegal characters.
Both options give Evans a consistent model. Exposing Favorites as files lets users organize them in File Explorer, but it shifts the burden of dealing with Windows filename rules onto anyone who just wants to save a bookmark. Changing how Favorites are stored removes that burden and keeps the simplicity of the Favorites model.
The needs and goals of users must take precedence over the desire of developers to write beautifully architected code. If the purity of the code would suffer from a change that enhances the experience of users, then the code should suffer.
The design process that Evans endorses is a fine way to handle the collection and analysis of business requirements. But this must be paired with a design process that focuses explicitly on the human-facing parts of the system. Agreement between customers and developers does not ensure the soundness of a design. Users don't really know what they want, nor do they understand the complexities of software well enough to drive the design process. The specific skills and methods of designers (interaction, user experience, whatever they happen to call themselves) are needed to distill the real needs of users. Even then, a designer must continually evaluate his or her work through direct observation of users in front of running software.
The contrast between these different approaches can be seen in a classic debate between Alan Cooper and Kent Beck, appropriately titled Extreme Programming vs. Interaction Design.
In the years since this discussion, Cooper has engaged with the agile community, including as the opening keynote speaker at Agile 2008. However, while the value of design for software has become more apparent, my own experience with developers is that many still do not grasp the real consequences of designing software from the perspective of users, not themselves.