Review

Daniel Jackson
Princeton University Press, 2021

While not a book about software architecture per se, The Essence of Software should nonetheless be required reading for all software architects. Also user experience designers. And also the product managers they work with.

This is a book about concepts and, as the subtitle explains, why concepts matter for great design. What is a concept? A concept is a logical construct that encapsulates information and behaviors. Borrowing an example, a restaurant reservation is a concept: it contains information (which restaurant, what time, how many diners) and behaviors (reservations can be made, canceled, and fulfilled.) As the example suggests, concepts are not a new, well, concept.

Nor is the relationship between concepts and design new. Arguably, one cannot really separate the two. And the relationship between design and conceptual models has certainly been discussed before in, for example, The Design of Everyday Things, by Donald Norman.

The Design of Everyday Things includes a wonderful example of what happens when the concept conveyed by a design doesn’t match the concept as implemented by the machine. The example is a refrigerator with two controls: one for the refrigerator temperature, and one for the freezer temperature. The controls suggest a single concept at play—​refrigeration—​and that it applies independently to the two compartments of the refrigerator. Confusingly, that is not the case. The actual concepts at play are refrigeration (there is just one compressor providing cooled air) and apportionment (how much air is directed to each compartment). The two controls, despite being labeled similarly, are inputs to two different concepts! The mismatch between these two points of view makes it much more difficult to adjust the settings than it would be if only the controls conveyed the actual behavior. Or, even better: if the actual behavior matched the controls.

Norman’s example is a refrigerator and there’s no software involved; it demonstrates that even in mechanical systems confusion over concepts can cause chaos. In software, the situation is much worse. While Jackson doesn’t make this explicit argument, the sheer flexibility of software makes it all too easy for software designers to screw this up. Concepts are too often complex, unclear, inconsistent—​or even dangerous. And as with Norman’s refrigerator, the concepts embodied in the user experience don’t always match those in the code. When that happens, the resulting application can be almost impossible to use.

Jackson explains and expands on concepts incrementally throughout the book. Along the way, he provides a delightful series of examples from familiar software—​Dropbox, Twitter, Photoshop, Word, Gmail—​illustrating how muddled concepts lead to muddled behaviors lead to—​sometimes—​utter disaster. If you’ve ever had a file synchronization application delete files that you thought were safely tucked away in the cloud, you’ve had some personal experience with just how bad that can be.

For a software architect, the simple takeaway from this book is that you want to be working from clean, simple concepts. But the larger message here is: that’s not enough. You need alignment on those concepts with your counterparts in product management, user experience design, and more. Only then do you have a fighting chance of delivering a design that embodies concepts that your users understand, too.