Tom Grant has started an interesting series of posts entitled Against a Grand Theory of Product Management. The articles are interesting reading, but make sure you have your thinking cap on when you start, because Tom is discussing an important but rather abstract topic.
He pulls in references ranging from Middle Range Theory (something I’d never heard of before) to Darwin’s theories (something I think we’ve all heard of but probably don’t adequately understand) to help convey his points. I had to read the posts a couple of times each to better grasp the specifics of his arguments.
In Part 2 of his series, Tom asks:
If someone can figure out why even the most meticulously written and reviewed requirements don’t stop some tech companies from making products that their users don’t like or can’t understand, that’s a big contribution to our little field of study. Best to have more middle-range theory before even thinking about the GToE [Grand Theory of Everything].
This is a great question. But before I answer it, I want you to watch the following video. It is from a TED Conference talk given in February 2008 by Robert Lang. Not only is this a fascinating video, but as you’re watching it, keep Tom’s question in mind. Don’t read on though until you watch the video.
[BTW, if you are impatient and read ahead, the important stuff starts at about 2:30 in the video.]
Lang talks about the evolution of origami, that took it from a traditional Japanese art form that most of us associate with creating things like this:
and turned it into an art (and science) form that allows people to create things like this:
And what caused that evolution? In Lang’s words, the answer is “mathematics”, or more specifically, the creation and utilization of a set of rules that provide a language for defining what can and can’t be done in origami.
The rules define the crease patterns — the lines along which folds are made — in the paper. And there are 4 rules:
- 2-colorability — any valid crease pattern can always be coloured with only 2 colours and will not have the same colour in two adjacent areas.
- modulus (M-V) = +2 or -2 — at any interior vertex, the number of mountain folds and the number of valley folds will always differ by 2
- For any vertex, the sum of alternate angles around that vertex will always be 180 degrees. e.g. a1+a3+a5 … = 180 degrees & a2+a4+a6… = 180 degrees.
- No self-intersection at overlaps – a sheet when folded cannot penetrate itself
[Note: if you don't understand these rules, watch the video. ]
Now these 4 rules define the properties of valid crease patterns, but there’s still something missing. How can those rules be applied to create sophisticated origami? In short, what goes in the box? (see 4:40 of the video)
Lang discusses that as well, and provides this diagram:
In short, the physical subject is reduced to a tree figure defining the key components (“flaps” in Lang’s terminology) of the subject. In this case, those are the legs, antennae, horns etc. of the beetle. That’s fairly easy.
Then some process must be used to take that tree-figure and create a base form for the final origami. He calls that the hard step.
And finally the base form can be refined to create the finished model. That’s fairly straight forward.
The “hard step” is accomplished using the rules defined above and the language for applying those rules. Given those rules are mathematical in nature, they can be written precisely and unambiguously and then executed to create the final model.
What does this have to do with product requirements and Tom’s question?
When looking at product requirements, there are analogies to Subject-Tree-Base-Model example given above.
- Product Managers investigate real world problems, needs, scenarios etc. (Subject).
- They then take their learnings and create abstracted representations of them (requirements) using artifacts such as problem statements, personas, use cases and user stories (Tree)
- These artifacts are then used by engineering teams to create prototypes and mockups etc. to ensure that the requirements were understood and addressed in the product. (Base)
- The final product is built, tested, tweeked etc. with the appropriate “fit and finish” before being released. (Model).
Sounds pretty good so far right?
But herein lie the problems, because that “hard” step in origami, is REALLY hard in product development.
- There currently is no language for requirements like the one defined for origami, that can precisely and unambiguously convey what is needed and define that in a way that ensures it can be built.
- Requirements should be implementation neutral, but as we all know in technology, the ability to fulfill a requirement can often be limited by technology choices and decisions that were made well before the requirement existed.
- Other constraints such as time, resources, knowledge, legalities, finances etc. all factor into how well a requirement can be met, or perhaps if it can be met or not.
- In many cases requirements contain unknowns or ambiguities that are filled in by assumptions during the development process. This is a reality of developing products in a business environment. In the origami situation, this would never happen. A model (like the stag beetle) can only be built when the full crease pattern is defined.
- There is no concept of people “liking” or “understanding” the origami in Robert Lang’s rules. i.e. Tom Grant asks about why companies build product their customers don’t like or understand.
This last point is key and deserves a little more discussion. What people like and understand is complex and is not static. In general, what people like is based on overall experience and emotion. It is not something that (currently) can be defined in a set of requirements.
i.e. users of this product must feel giddy with excitement the first time they use this software
So, can origami teach us something about product requirements?
Absolutely. The origami path from Subject->Tree->Base->Model forms series of transformations that is akin to the requirements gathering, communication and development process used when creating products.
Once a set of clear foundational rules for origami were defined and understood, not only did they open up new possibilities for forms never thought possible, but those rules formed the grammar for a language that makes precise and unambiguous communication also possible.
There is almost certainly a set of rules and language for precise definition and communication of requirements, but it has not yet been clearly formalized. That is likely a necessary stepping stone in the maturity cycle of product development.
But even with that requirements language, changing market landscapes, customer preferences and needs, technological, resource and time constraints will all work together to make product success a “grey box”, where those with great vision, insight and execution are likely to succeed but never guaranteed that success.
- Open Question: How and When do you define usability requirements?
- Guest Post: What can Tacos Teach Product Managers about Social Product Development?
- In Defence of the Big Freaking Requirements Document
- Agile/Scrum Software Development and Product Management part 2
- Towards a Product Management Manifesto (part 1)