The ultimate value of software design
The value of software design lies in its adaptability, balancing current functionality with a structure for future growth. Effective design manages complexity, reduces costs, and ensures software evolves with changing needs, making it a strategic asset in unpredictable environments.
Software is a medium for storing executable knowledge, like a digital book with the power to act. While books are valuable for sharing knowledge, software goes further by actively solving user problems. It offers stakeholders structure and behavior (Martin, 2017).
Behavior represents what software accomplishes today, delivering immediate value by automating tasks, saving time, and reducing effort. Structure defines what software can achieve tomorrow, enabling adaptation and growth (Beck, 2024).
The economics of software development focus largely on human labor and machine costs, with a significant portion devoted to debugging and maintenance, as errors significantly drive up expenses (Yourdon & Constantine, 1979). Simply put, the cost of software is the cost of change (Beck, 2024). As complexity increases, so do the likelihood of errors and development costs due to our cognitive limitations—attention, short-term memory, and willpower (Ahrens, 2017)—alongside perceptual illusions, cognitive biases, and memory distortions. These factors can lead to misjudgments and suboptimal decisions (Brown, Roediger, & McDaniel, 2014).
The strategic value of software lies in its structure, enabling developers to manage complexity by working at higher levels of abstraction (Freeman & Pryce, 2009). Software that doesn't yet work but is easy to modify can be fixed; software that works but is hard or impossible to modify stops working as soon as requirements change (Martin, 2017).
In Residues: Time, Change, and Uncertainty in Software Architecture, Barry O’Reilly introduces hyperliminality to describe ordered systems operating in disordered contexts. Hyperliminal systems are exposed to constant unpredictable changes and risk failure if they cannot adapt quickly. Software is hyperliminal by nature, given that the business environments it operates in are inherently unordered and shaped by social systems (O’Reilly, 2024).
In short, software exists in a state of continuous and unpredictable change. Its structure must be designed for adaptability; otherwise, it risks becoming obsolete.
However, software providers often prioritize behavior over structure, resulting in technical debt and increased long-term costs while overlooking strategic value, especially in volatile conditions.
Structure in software aligns with design and includes two key aspects: meaning and responsibility.
Semantic structure defines the meaning and relationships between concepts in code, providing context and clarity. It serves as the conceptual model for organizing knowledge within a domain. In Domain-Driven Design (DDD), the semantic structure is the domain model, capturing these meanings and relationships to reflect a shared understanding between domain experts and developers, expressed through the Ubiquitous Language. Essentially, this is the Information Architecture (IA). This structure is known as ontology in Knowledge Management and Artificial Intelligence (AI). Semantic structure enables and supports learning, which is crucial because Software development is about capturing and encoding knowledge—a process rooted in learning.
The responsibility structure organizes software by defining roles, ownership, and boundaries, promoting maintainability and scalability. It’s outlined through design principles, patterns, and architectures. In DDD, responsibility structure is defined by Aggregates and Bounded Contexts. Think Functional Decomposition in Systems Engineering. Responsibility structure enables developers to manage complexity by avoiding it.
Ultimately, the value of software design is its capacity to anticipate change by building for it. And since software is its design, unlike physical objects such as cars or buildings, its value is directly tied to adaptability.
References
Ahrens, S. (2017). How to take smart notes: One simple technique to boost writing, learning and thinking – for students, academics, and nonfiction book writers (Kindle ed.). Unknown.
Beck, K. (2024). Tidy first?. O’Reilly Media, Inc.
Brown, P. C., Roediger, H. L., III, & McDaniel, M. A. (2014). Make it stick: The science of successful learning. Harvard University Press. (Kindle Edition).
Freeman, S., & Pryce, N. (2009). Growing object-oriented software, guided by tests. Addison-Wesley Professional.
Martin, R. C. (2017). Clean architecture: A craftsman’s guide to software structure and design. Pearson.
O’Reilly, B. M. (2024). Residues: Time, Change, and Uncertainty in Software Architecture. Leanpub.
Yourdon, E., & Constantine, L. L. (1979). Structured design. Prentice Hall.
