Decisions Do Not Commute

Organizations make decisions constantly. They approve technologies, select suppliers, establish schedules, allocate budgets, define interfaces, reorganize teams, reduce staffing, adopt processes, freeze requirements, and commit to delivery dates.

These decisions are often treated as if they were items on a list

$D_1, D_2, D_3, \dots, D_n$

Once the necessary decisions have been identified, the apparent task is to complete them as efficiently as possible. The sequence may then be determined by whichever issue is most urgent, which executive is available, which contract must be signed, which team has completed its analysis, or which decision can most easily be moved through the approval process.

This treatment assumes something rarely stated

The order of architectural decisions does not materially alter the result.

That assumption is usually false.

For many consequential decisions,

$D_i D_j \ne D_j D_i$

The decisions do not commute.

Making decision $D_i$ and then decision $D_j$ may produce a different architecture from making $D_j$ and then $D_i$ , even when the two decisions appear individually unchanged. The first decision modifies the conditions under which the second is made. It changes the available evidence, feasible alternatives, organizational commitments, bargaining positions, technical constraints, and costs of reversal.

Decision order is therefore not merely a matter of project management. It is part of the architecture.

Architecture Has a History

An architecture is often defined and represented as a structure: a collection of components, interfaces, functions, behaviors, standards, and relationships. That representation can hide how the structure came to exist.

Consider an architecture in state $A_0$ . A decision $D_i$ transforms that state

$D_i :\, A_0 \to A_i$

A later decision $D_j$ does not act on the original architecture. It acts on the architecture already changed by $D_i$

$D_j:\, A_i \to A_{ij}$

Reversing the order gives

$D_j:\, A_0 \to A_j$

followed by

$D_i:\, A_j \to A_{ji}$

There is no general reason to expect

$A_{ij} = A_{ji}$

The difference

$[D_i,\,D_j] A_0 = (D_i D_j - D_j D_i) A_0$

is the architectural effect of decision order. The expression need not be interpreted as a literal linear operator in every application. The commutator provides a compact way to express a more general fact that that two decisions may alter one another’s consequences because each changes the state upon which the other acts.

Architecture is therefore not only structural. It is historical. The present system carries the residue of earlier commitments, abandoned alternatives, local optimizations, contract boundaries, staffing choices, technical assumptions, and timing decisions.

Research on path dependence likewise emphasizes that present outcomes may depend upon the sequence of prior events rather than only upon current optimization conditions [Dav85, Art89, SSK09]. In engineering design, contextual and temporal dependencies similarly affect which tradeoffs become visible and which earlier choices can still be revisited [NDHL24].

A Simple Example

Suppose an organization must make two decisions

$D_P \, =$ select the processing platform,

and

$D_S \, =$ define the software partitioning strategy.

The organization could choose the processing platform first

$A_0 \xrightarrow{D_P} A_P \xrightarrow{D_S} A_{PS}$

Once the platform is selected, the software architecture will be developed within that platform’s processor topology, memory model, operating-system support, communication mechanisms, certification evidence, supplier constraints, and toolchain.

Alternatively, the organization could first establish the partitioning needed for isolation, timing, safety, security, deployment, and future growth

$A_0 \xrightarrow{D_S} A_S \xrightarrow{D_P} A_{SP}$

The platform would then be evaluated against an already articulated set of architectural obligations.

Both sequences contain the same nominal decisions

Choose a platform
Define software partitioning

But they are not equivalent.

In the first sequence, the platform constrains the meaning of acceptable partitioning. In the second, the required partitioning constrains the platform choice. Thus,

$D_S D_P(A_0) \ne D_P D_S(A_0)$

The organization may still produce a functioning system in either case. It will not necessarily produce the same system, incur the same technical debt, preserve the same options, or face the same verification burden. Architecture-decision literature has long emphasized that architecture is materially constituted by decisions and their rationale, not only by the structures eventually documented [TA05, JHS+16]. The missing extension is that the order among those decisions is itself architecturally consequential.

Organizations Often Decide in Accidental Order

Few organizations would explicitly declare

We make important architectural decisions randomly.

Yet many effectively do. Decision order may be driven by such external factors such as

Procurement lead times
Annual budgeting cycles
Contract award dates
Executive attention
Organizational jurisdiction
Staffing availability
Supplier pressure
Quarterly commitments
Perceived schedule urgency
Ease of approval
Which problem has become visible first

Each of these may be locally reasonable. However, none guarantees a causally coherent architectural sequence.

A long-lead component is purchased before the system behavior is sufficiently understood
A delivery date is committed before uncertainty in the architecture has been characterized
An organizational restructuring fixes ownership boundaries before the coupling among functions is known
A supplier is selected before the interfaces and evidence obligations are mature
A software framework is mandated before the relevant quality attributes have been translated into architectural constraints

The later decisions are then called “design decisions,” but they are no longer being made over the original option space. They are attempts to construct a viable architecture inside the future cone created by the earlier commitments.

Every Decision Changes the Future Cone

Let the future cone of architectural state $A$ be

$\mathcal{F}^{+}(A)$

which is read as “the set of future states causally reachable from $A$ under admissible decisions and constraints.”

A decision transforms not only the current state but also its reachable future

$D_i : \, \mathcal{F}^{+}(A_0) \rightarrow \mathcal{F}^{+}(A_i)$

Some options become easier. Others become more expensive, implausible, or impossible. New dependencies arise. Evidence becomes stale. Existing assumptions may become obligations. Local decisions may acquire cross-layer consequences.

Typically,

$\mathcal{F}^{+}(A_i) \ne \mathcal{F}^{+}(A_0)$

The next decision is therefore selected from a changed, possibly more limited, space. This is why the statement “We can decide that later” is often misleading. The later decision may retain the same name while losing much of its original freedom. Research on technological lock-in shows how early events and increasing returns can constrain later selection [Art89]. While work on engineering flexibility makes the complementary point that options must be deliberately designed and preserved if they are to remain usable under uncertainty [dNS11, Gil07].

The organization may believe it has deferred a decision when it has actually allowed earlier decisions to make that decision implicitly.

Deferred Is Not the Same as Preserved

A decision remains genuinely deferred only when the options needed to make it later have been preserved.

Suppose the current alternatives form a set

$\Omega(A_0) = \{ \omega_1, \omega_2, \dots, \omega_n\}$

After decision $D_i$ , the alternatives available to decision $D_j$ may become

$\Omega_j (A_i) \not\subseteq \Omega_j(A_0)$

The organization can still conduct a trade study. It can still assign weights and scores. It can still document several candidates. But if earlier commitments have already eliminated or penalized important alternatives, the apparent choice may be largely ceremonial.

This is a common form of architectural misrepresentation

A decision is presented as open because no formal approval has occurred, even though the causal architecture has already closed most of the relevant alternatives.

Formal decision authority and causal decision freedom are not the same thing.

Non-commutativity Can Be Local or Large

Not every pair of decisions has a large order effect. Some decisions may approximately commute

$D_i D_j (A) \approx D_j D_i (A)$

For example, two well-isolated choices concerning replaceable components may have little influence on one another. The two ordering produce the states

$A_{ij} = D_i D_j (A) \quad \text{and} \quad A_{ji} = D_j D_i (A)$

Their order effect is the contrast between these two outcomes. When the architectural state space and the decision transformations admit subtraction, this contrast can be written as a commutator or

$[D_i, D_j] A = D_i D_j (A) - D_j D_i (A)$

The commutator is therefore not an architectural distance. It simply identifies the difference produced by reversing the decisions. A norm could be applied to this difference in a suitably structured mathematical model, but architecture does not generally provide a single natural norm, and the state transformations need not be linear.

A more general formulation is an order comparison relative to the architectural claim or claims we are making (claim-relative)

$C_{ij}^{(Q,\rho)} (A) = \mathcal{E}_{Q,\rho}(A_{ij},A_{ji})$

where $Q$ is the architectural claim being examined, $\rho$ is the relevant resolution, and $\mathcal{E}_{Q,\rho}$ is an evaluation appropriate to that claim. Depending on the questions, the evaluation may be a scalar difference, a vector of changes, a partial-order comparison, a change in reachable options, or a qualitative contrast supported by evidence.

The relevant order effect is therefore not necessarily a single magnitude. The two sequences may be nearly equivalent with respect to one claim and very different with respect to another. For example,

$C_{ij}^{(\text{acquisition cost},\rho)}(A) \approx 0$

while

$C_{ij}^{(\text{verification burden},\rho)}(A)$

indicates a substantial difference. A sequence that appears economically equivalent may therefore create radically different assurance obligations.

The architecture does not have one number, and neither does a decision-order effect. What matters is whether reversing the decisions changes the architectural properties relevant to the claim under examination.

The First Decision Can Rewrite the Second

Decision order matters for more than option elimination. The first decision can change the semantic content of the second.

Suppose an organization decides to adopt a commercial platform and later decides what “modular” means. The modularity decision is now interpreted within

The platform’s extension points
Licensing model
Deployment mechanisms
Data ownership
Supplier APIs
Supported operating environments
Available test infrastructure

Had modularity been defined first as an architectural obligation involving independent evolution, replaceability, fault containment, evidence separation, and data portability, the platform decision might have been different.

The second decision has not merely been constrained. It has been redefined. Thus the composition

$D_{\text{modularity}} D_{\text{platform}}$

does not contain the same effective modularity decision as

$D_{\text{platform}} D_{\text{modularity}}$

The label survives but the architectural meaning changes.

Decisions Also Change the Evidence

A decision can alter what the organization knows.

It may produce new information through prototyping, testing, contracting, simulation, or operational use. It may also destroy or obscure information by terminating alternatives, dissolving teams, changing suppliers, replacing tools, or making prior evidence inapplicable.

Let the architectural state include decision memory and evidence

$A_t = (C_t, M_t, E_t, \dots)$

where $C_t$ represents active constraints, $M_t$ decision memory, and $E_t$ available evidence. Then,

$D_i(A_t) = (C_{t+1}, M_{t+1}, E_{t+1}, \dots)$

A later decision is not merely made under different constraints. It is made with a different epistemic state.

This can make decision order valuable when the first decision is deliberately chosen to produce information while preserving alternatives. A prototype, experiment, active probe, or limited commitment may be architecturally useful because it reshapes the evidence before an irreversible commitment is made.

Conversely, a premature commitment may force later analysis to justify a decision already embedded in the architecture and likely costly to change.

Decision Sequences Can Learn, or Merely Commit

Consider two kinds of early action.

The first is an information-producing probe

$P: A_0 \rightarrow A_P$

The probe is designed to increase relevant evidence while minimizing irreversible constraint

$\Delta E(P) > 0, \quad \Delta \Omega(P) \approx 0$

The second is a commitment

$C: A_0 \rightarrow A_C$

which may reduce uncertainty only by eliminating alternatives

$\Delta \Omega(C) < 0$

Both may make the project appear to progress. However, their architectural effects differ.

A useful early decision often does not answer the largest question. It changes the state so that the next important decision can be made with better evidence and without excessive option loss. This is compatible with engineering-flexibility and real-options reasoning, in which staged commitments and intentionally preserved alternatives create value under uncertainty [dNS11, Gil07, FO06].

Decision sequencing should therefore be evaluated through at least three quantities

Information gained
Options lost
Obligations created

Schedule progress alone does not reveal whether the sequence is improving architectural knowledge or merely accumulating commitments.

Irreversibility Makes Order More Important

Non-commutativity is especially consequential when decisions are expensive or impossible to reverse.

Let the reversal cost of decision $D_i$ in state $A$ be

$R(D_i, A)$

As irreversible commitments accumulate,

$R(D_i, A_t)$

may increase because later decisions have been built upon the earlier one.

A platform decision that could have been changed during concept development becomes effectively irreversible after software development, supplier qualification, safety analysis, tooling, training, and field deployment depend upon it.

This is architectural lock-in.

Real-options research emphasizes that uncertainty and irreversibility give timing itself economic value: preserving the option to defer or alter a commitment can be valuable because future information may change the preferred action [FO06, dNS11]. The same insight applies more broadly to architecture.

The value of an option may concern

Alternative system boundaries
Different safety concepts
Changes in mission
Supplier replacement
Technology migration
Organizational adaptation
Testability
Deployment strategy
Future certification

A decision that destroys those options imposes an architectural cost even when the immediate budget appears unchanged. That architectural cost can be later reflected as negative changes in earned value metrics.

Dependencies Are Not the Same as Sequence

Organizations frequently use dependency diagrams, integrated master schedules, critical paths, and design structure matrices to identify ordering constraints. Design structure matrix methods explicitly represent system elements and interactions and can support the organization of complex product-development tasks [EWSG94, EB12].

These tools are valuable, but dependency is only one reason decision order matters.

A dependency might state that

$D_j \, \text{requires output from } D_i$

Non-commutativity gives us something stronger

$D_i \text{ changes what } D_j \text{ means or can produce}$

Two decisions may have no formal input-output dependency and still be strongly non-commutative.

A staffing reduction may not appear as a technical predecessor to an architecture review. Yet it may remove the expertise needed to distinguish architectural alternatives, causing several causally distinct options to collapse into one coarse representation.
A contract award may not formally precede interface definition. Yet once a supplier has contractual leverage, interface negotiations occur in a different decision state.
A public delivery commitment may not technically precede verification planning. Yet it changes the organization’s tolerance for evidence that threatens the schedule.

These are causal effects of sequence that conventional scheduling may not capture or represent.

Organizational Layers Create Hidden Order Effects

Decision order is often distributed across architectural layers

$\text{strategy} \to \text{business} \to \text{program} \to \text{architecture} \to \text{engineering} \to \text{implementation}$

But the actual sequence may not follow that direction.

A procurement organization may create a supplier constraint before the architecture team defines the relevant interfaces
A business unit may establish a market date before engineering characterizes feasibility
A software team may select infrastructure before the operational concept stabilizes
A governance board may impose a cost target that changes the set of admissible safety arguments

These decisions are in likelihood made by different authorities, with different time horizons, using different representations. No single actor necessarily sees the full sequence.

The organization therefore experiences an emergent ordering

$D_{\sigma(1)}, D_{\sigma(2)}, \dots, D_{\sigma(n)}$

where the permutation $\sigma$ is produced by local urgency and organizational timing rather than architectural intent.

This is one reason organizations can make individually rational decisions and still construct an incoherent architecture.

Local Rationality Does Not Guarantee Sequence Rationality

Suppose each decision $D_i$ is locally justified in the state where it is made

$D_i = \arg \max\limits_{d \in \Omega_i(A_t)} U_i(d \vert A_t)$

Every decision may therefore be defensible when reviewed independently. Yet the sequence may still be poor

$U_{\text{global}}(D_n \cdots D_2 D_1 (A_0)) \ll U_{\text{global}}\left( D_{\tau(n)} \cdots D_{\tau(2)} D_{\tau(1)} (A_0) \right)$

The organization optimized each move within the state created by earlier moves, without examining whether a different order would have produced a better reachable architecture.

This is not necessarily incompetence. It may be a consequence of fragmented authority, incomplete knowledge, mismatched time horizons, weak decision memory, or the absence of a role responsible for cross-layer sequence (a key role for systems engineering).

Regardless, the effect remains.

The organization mistakes a sequence of justified decisions for a justified decision sequence.

The Cost of a Decision Includes What It Makes Happen Next

Traditional decision records often describe the

Issue
Alternatives
Evaluation criteria
Selected option
Immediate rationale

A stronger record should also ask

Which future decisions will this constrain?
Which alternatives will become unavailable?
Which assumptions will become embedded?
What evidence will become stale?
Which organizational actors will acquire leverage?
Which obligations will become harder to satisfy?
What reversal paths remain?
Which decisions must occur before this one?
Which decisions should be delayed until after it?
What probes could reduce uncertainty without closing the option space?

The full consequence of a decision is not contained in its immediate outcome. It includes the deformation of the future cone (the space of causally available future decisions from the current decision)

$\Delta \mathcal{F}^{+}(D_i,A) = \mathcal{F}^{+}(D_i(A)) - \mathcal{F}^{+}(A)$

This deformation may be more architecturally significant than the local benefit used to approve the decision.

Decision-Order Analysis

Before making a consequential decision, organizations should not merely ask whether it is good. They should ask whether it is good now, relative to the decisions that could precede or follow it.

For a proposed pair $D_i, D_j$ , the minimum analysis is

$D_i D_j (A) \text{ versus } D_j D_i (A)$

The comparison should consider multiple architectural dimensions

Feasible future states
Option entropy
Total technical-debt burden
Verification burden
Assumption creation
Evidence gained or lost
Reversal cost
Cross-layer fidelity
Organizational commitments

For larger decision sets, exhaustive permutation analysis may be impossible because the sequences grow rapidly, usually as $n!$ . But organizations rarely need to examine every possible ordering. They do, however, need to identify decisions with

High irreversibility
Broad cross-layer effects
Strong option-closing power
High uncertainty
Substantial evidence dependencies
Large potential commutators with other decisions

Those decisions deserve explicit sequence analysis.

A Decision-Sequence Map

A practical representation could treat decisions as nodes in a directed structure.

An edge

$D_i \to D_j$

would not mean only that $D_i$ supplies information to $D_j$ . It could indicate that $D_i$

Changes the alternatives available to $D_j$
Changes the cost of $D_j$
Changes the meaning of $D_j$
Changes the evidence relevant to $D_j$
Changes the authority under which $D_j$ will be made
Increases the reversal cost of $D_j$
Should be preceded by $D_j$ if option loss is to be avoided

The map would therefore represent architectural causality among decisions, not merely workflow.

Cycles are also meaningful. If

$D_i \to D_j \text{ and } D_j \to D_i$

the decisions may require iteration, provisional commitment, joint resolution, or an active probe that changes the state before either is finalized.

The answer is not always to impose a rigid order. Sometimes the correct architecture of decision-making is deliberately iterative. DSM methods explicitly recognize coupled tasks and iteration, but the proposed map extends that idea from information dependency to causal deformation of later decisions [EWSG94, EB12].

Decision Edges as Transformations of Decision Context

Each of the seven effects listed in the preceding section, can be understood as a form of information flow, provided that the term “information” is interpreted broadly. The information passed from one decision to another is not limited to facts, data, or explicit requirements. A prior decision may alter the entire context in which a later decision is made.

This interpretation begins with, but goes beyond, Shannon’s mathematical theory of communication. Shannon’s framework provides a foundation for treating a directed relation as an information-bearing channel and for characterizing information in terms of uncertainty and selection among alternatives [Sha48]. However, note that it deliberately abstracts from the meaning of the transmitted symbols. Weaver subsequently distinguished among the technical problem of transmitting symbols, the semantic problem of conveying meaning, and the effectiveness problem of influencing conduct [Wea49]. The decision relations considered here may operate at all three of those levels.

Let the context of a decision ( $D_j$ ) be represented by

$\Gamma_j\left( \mathcal{O}_j, C_j, M_j, E_j, A_j, R_j, P_j \right)$

where ( $\mathcal{O}_j$ ) denotes the available alternatives, ( $C_j$ ) the relevant cost structure, ( $M_j$ ) the meaning of the decision, ( $E_j$ ) the available evidence, ( $A_j$ ) the authority under which it is made, ( $R_j$ ) its reversal burden, and ( $P_j$ ) its precedence constraints.

An edge

$D_i \to D_j$

can then be interpreted as a transformation from one context to another context or

$T_{ij}: \Gamma_j^{-} \longrightarrow \Gamma_j^{+}$

The decision ( $D_i$ ) does not merely provide an input to ( $D_j$ ). It changes the state in which ( $D_j$ ) will be interpreted, evaluated, authorized, and executed. Influence diagrams provide an established precedent for representing informational and decision relationships in a directed graphical structure [HM05]. The relation proposed here is broader, though, because the edge may transform not only the information available to a decision but also its alternatives, semantics, authority, costs, precedence conditions, and reversibility.

This also clarifies why decision ordering is generally non-commutative. If ( $D_i$ ) changes the context of ( $D_j$ ), then reversing their order need not produce the same result

$T_i T_j(\Gamma) \ne T_j T_i(\Gamma)$

The difference may appear as lost alternatives, changed costs, altered evidence, different authority, or increased reversal burden. In path-dependent processes, early selections can change the attractiveness and feasibility of later alternatives, reinforce the selected path, and make reversal increasingly costly [Art89]. The consequences of the decision therefore depend not only on which decisions occur, but also on the order in which they occur.

The final item in the list is especially important. If ( $D_i$ ) causes option loss for ( $D_j$ ), while analysis shows that ( $D_j$ ) should have preceded ( $D_i$ ), then the edge records more than a forward causal effect. It also reveals information about the suitability of the ordering itself. The realized order may be

$D_i \prec D_j$

while the preferred order under an option-preservation criterion is

$D_j \prec^{*} D_i$

The architecture must therefore represent both what happened and what the consequences reveal about what should have happened.

Feedback Without Causal Cycles

Decision processes may also contain feedback. A downstream decision can produce evidence that changes the interpretation, authority, cost, or continuing consequences of an earlier decision. This is consistent with the cybernetic conception of feedback, in which information concerning the consequences of an action returns to influence subsequent action [Wie48].

At first glance, this may appear to create a causal cycle

$D_i \to D_j \to D_i$

But the original decision event cannot ordinarily be changed after it has occurred. What changes is the architectural state inherited from that decision event or the context of a later recurrence, reconsideration, or refinement of the same decision type.

The event-level structure is therefore better represented as

$D_i^{(k)} \to D_j^{(k)} \to D_{\ell}^{(k)} \to D_i^{(k+1)}$

The causal order remains directed and acyclic. The apparent cycle appears only when distinct decision events are projected onto recurring decision roles

$[D_i] \to [D_j] \to [D_{\ell}] \to [D_i]$

What returns through the loop may include revised evidence, changed assumptions, newly discovered costs, altered authority, increased reversal burden, or reopened alternatives. The feedback does not rewrite the historical decision. It changes the decision memory, inherited obligations, and future context associated with it.

The existence of a feedback path does not by itself guarantee that the distinctions needed for effective reconsideration survive the path. Ashby’s treatment of regulation emphasizes that effective control requires sufficient variety in the regulator relative to the disturbances and states that must be distinguished [Ash56]. Applied here, downstream information may be returned but possible compressed, filtered, or coarse-grained below the resolution required by the recurring decision. The loop then exists structurally while failing in the informational sense.

This distinction matters because recurring decision processes should not automatically be considered learning processes. Learning occurs only when information generated downstream survives and is incorporated into the next decision context. Otherwise, an organization may repeat the same nominal cycle while discarding the evidence produced by previous iterations.

That failure may be described as decision-loop memory failure or recurrence without learning.

Decision ordering is therefore an information-transforming causal process. Decisions do not merely consume information. They change the informational, semantic, economic, and governance conditions under which subsequent, and sometimes recurring, decisions are made.

Good Governance Preserves the Right Order

Governance is often treated as a mechanism for approving decisions. Its deeper architectural function should include protecting the sequence in which decisions become binding.

This requires someone to recognize when

A downstream commitment is about to preempt an upstream architectural question
A local optimization will close a system-level option
A contract will redefine a technical decision
A schedule promise will distort evidence
A representation is too coarse to support the next commitment
The organization is attempting to make an irreversible decision before it has performed the necessary learning

Governance should not merely ask

Has the decision been justified?

It should also ask

Has the architecture reached a state in which this decision can responsibly be made?

This is a different question with very different implications.

The Non-Commutative Decision Principle

The argument can be summarized as follows

Architectural decisions are generally non-commutative: changing their order can change the resulting architecture, the available evidence, the obligations incurred, the options preserved, and the future states that remain reachable.

Decision sequence is therefore part of the architecture and should be designed, analyzed, and governed as such rather than left to organizational accident.

This principle does not imply that every decision order must be optimized globally before action can occur. Complete knowledge is unavailable, and the consequences of every sequence cannot be predicted.

It does, however, mean that order effects should be treated as real architectural phenomena rather than be ignored by assumption.

The objective is not perfect foresight. It is deliberate sequencing under uncertainty.

Architecture Is Also the Order of Commitment

Organizations often believe that architecture is created by the decisions they make. That is only partly true.

Architecture is also created by

Which decisions are made first
Which decisions are allowed to remain open
Which experiments are performed before commitment
Which assumptions become constraints
Which options are eliminated without being noticed
Which local authorities act before cross-layer consequences are visible
Which choices become irreversible before their meaning is understood

Two organizations can begin with the same purpose, the same candidate technologies, the same budget, and the same set of nominal decisions. In all likelihood, they will still produce very different systems because they make those decisions in different orders.

The sequence is not administrative detail.

The sequence is causal structure and the decisions do not commute.

References

[Art89] W. Brian Arthur. Competing Technologies, Increasing Returns, and Lock-In by Historical Events. The Economic Journal, 99(394):116–131, 1989.

[Ash56] W. Ross Ashby, An Introduction to Cybernetics. Chapman & Hall, London, 1956.

[Dav85] Paul A. David. Clio and the economics of QWERTY. The American Economic Review, 75(2):332–337, 1985.

[dNS11] Richard de Neufville and Stefan Scholtes. Flexibility in Engineering Design. MIT Press, Cambridge, MA, 2011.

[EB12] Steven D. Eppinger and Tyson R. Browning. Design Structure Matrix Methods and Applications. MIT Press, Cambridge, MA, 2012.

[EWSG94] Steven D. Eppinger, Daniel E. Whitney, Robert P. Smith, and David A. Gebala. A model-based method for organizing tasks in product development. Research in Engineering Design, 6(1):1–13, 1994.

[FO06] Timothy B. Folta and Jonathan P. O’Brien. Uncertainty, irreversibility, and the likelihood of entry: An empirical assessment of the option to defer. Journal of Economic Behavior & Organization, 61(3):432–452, 2006.

[Gil07] Nuno Gil. On the value of project safeguards: Embedding real options in complex products and systems. Research Policy, 36(7):980–999, 2007.

[HM05] Ronald A. Howard and James E. Matheson. Influence Diagrams. Decision Analysis, 2(3):127-143, 2005. Originally published in 1984.

[JHS+16] Marija Jankovic, and Claudia Eckert. Architecture decisions in different product classes for complex products. AI EDAM, 30(3):217–234, 2016.

[NDHL24] Julia Nickel, P. Robert Duimering, Ada Hurst, and Julie Linsey. Contextual influences on trade-offs in engineering design: A qualitative study. Design Science, 10:e12, 2024.

[Sha48] Claude E. Shannon. A mathematical theory of communication. Bell System Technical Journal, 27(3-4):379-423, 623-656, 1948.

[SSK09] Jörg Sydow, Georg Schreyögg, and Jochen Koch. Organizational path dependence: Opening the black box. Academy of Management Review, 34(4):689–709, 2009.

[TA05] Jeff Tyree and Art Akerman. Architecture decisions: Demystifying architecture. IEEE Software, 22(2):19–27, 2005.

[Wea49] Warren Weaver. Recent contributions to the the mathematical theory of communication. In Claude E. Shannon and Warren Weaver, editors, The Mathematical Theory of Communication. University of Illinois Press, Urbana, Illinois, 1949.

[Wie48] Norbert Wiener, Cybernetics: Or Control and Communication in the Animal and the Machine. John Wiley & Sons, New York, 1948,