Category Archives: innovation

revolutionary in an evolutionary world

This is a follow-up to cost-value entanglement.

Product management is notorious for being risk averse. This often comes from a history of dealing with frequent failures to deliver on time and with quality due to chronic cost-value entanglement. This initial architectural failure cripples a product forever, unless the root cause of the problem is recognized and corrected. Risk aversion grows as the product becomes brittle, and development becomes unwieldy due to ever-increasing code complexity.

Architecture is often thought of as a design function, but this is far from accurate. Use case and requirements analysis are specification activities, which are central to product architecture. It is most important to identify how its users interact with the system and what functions a system performs. These aspects of the system should be encapsulated by its facade, the boundary between the externally visible behavior (interfaces) and its internal implementation. Poor product specification and poor separation between interface and implementation are the architectural manifestations of cost-value entanglement.

This leads to product management demanding a meticulous “evolutionary” approach to development, meaning only small patchwork enhancements are permitted. Significant redesign and technological improvements are impossible, because internal changes will disrupt the externally visible behavior, breaking things for the installed base of users. Such unreasonable constraints can be alleviated by disentangling the facade from the internals. Clearly identify the externally visible concepts in a precise model to support human understanding and interfaces for programmatic access. This enables evolving the facade independently of radical redesigns to the internal implementation. Without this flexibility, revolutionary change is impossible, if quality and time to market are to be maintained.

leaders and followers

I have noticed that there are those who blaze the trail, and lead the world kicking and screaming into the frontier. Then, there are those who are willing to follow, but have little to blaze for themselves. Finally, there are those who refuse to follow, but have no skills to lead either.

What do we do, when we want to learn something? Research what others have done before. The vast majority of things can be accomplished without a deep understanding of the problem or solution; it just requires emulating success. Someone else did the hard work of understanding, and documented a procedure and a simplified explanation that others could absorb and reproduce. That is how humans work. To become a successful trailblazer requires a deep understanding for oneself, but also the ability to distill that into simple explanations and instructions that ordinary people can absorb. The sophisticated knowledge will probably be taken to the grave, but it is the idiot’s guide that will endure the ages.

Ordinary men need traditions and procedures to emulate. Otherwise, they wouldn’t be able to even feed themselves. Imagine the vast knowledge and investment in thought that was required to invent the cooking recipes that we know today. Many people would starve today if they were responsible for acquiring that knowledge themselves through creative thinking, rather than by emulation. Traditions, rituals, and procedures bring comfort to us, because it relieves our burden to think. Most people are incapable of advanced contemplation; emulation is their only recourse. It also instills a common denominator in a society’s culture, and it binds them together psychologically.

We grow up emulating our parents and neighbors by decorating a tree, putting up lights, singing songs, exchanging gifts, and gathering with loved ones. There is comfort in these mindless activities, because they are familiar and safe. This manner of blind emulation leaves us vulnerable to less benign inclinations, like smoking or religion. Ritualistic activities give me no comfort at all. Tis the season to celebrate the most basic survival technique: mindless emulation.

cost-value entanglement

With software, the value is in the concepts (model), brand (reputation), people (experience), and customers (installed base). Not so much the design or implementation artifacts. Often we place too much focus on the code, because it is the most tangible manifestation of our investment. This is a grave error. The code is the result of the sunk cost, but it is not the true value of a software product. The value lies in the capabilities enabled by the software. The software is the means, not the ends. The code must be free to evolve rapidly and radically. If it is not, it will not be able to survive in this ever-changing business environment.

Software organizations that are code-centric have long product release cycles, slow response times to changing requirements, and poor agility to scale the business to expand its market. Code-centric organizations rely heavily upon a skilled development team’s intimate and long-standing relationship to the code. This leaves them vulnerable to competition and employee turnover.

We must be value-centric, not cost-centric in identifying goals. The value is the ends, whereas the costs are the means. The costs (code) must be very flexible, adjusting with agility to the times. The value must be durable. The value must be identified, disentangled from the costs, represented tangibly and separately, and communicated widely. Cost reduction implies discounting investment in code. Decoupling value from code as much as possible allows costs to be reduced without impacting the value.

Complexity grows with code size. Costs grow nonlinearly with code complexity. When you suffer from cost-value entanglement, then code complexity will sink your entire product in time. Entanglement takes away the ability to significantly redesign and reorganize the code, because it puts the value at tremendous risk. Without the freedom to significantly redesign, eventually the product will collapse under the ever-growing weight of its code complexity.