Self-Sustaining Systems Wiki

CausesOfComplexity

What Makes Systems Complex?

It seems like it may be a valuable exercise to try to identify the sources of the complexity that we see in modern (software) systems.

Inherent Complexity of the Problem

Software complexity arises in large part from the inherent complexity of the problems we are trying to solve. As we now are tackling much harder problems is it any wonder that the resulting systems are more complex?

One study found that a 25% increase in problem complexity caused a 100% increase in the complexity of the software solution. Scott N Woodfield, 1979. "An Experiment on Unit Increase in Problem Complexity." IEEE Transactions on Software Engineering, (March)

• I recently got hold of this paper and found that the description of it was overblown: the paper is about changes to toy programs (actually a single short function). So while what it found is true, I wouldn't extend the numbers to large software systems.

Level of Detail Required of the Solution

Going from problem requirements to system design there is an explosion of derived requirements (the requirements for a particular design solution) and the list of these implicit requirements can be 50 times longer than the original problem-focused requirements.

There's a lot of details that need to be filled in when translating "what to do" (describing the problem to be solved) into "how to do" (describing how the problem is to be solved). This includes translating the problem into computer terms, specifying the needed components, and (probably) the organization of the people developing the solution.

(This may be more what we might call complicated.)

Combinatorics in the Implementation

Another major factor is cross-talk where bugs or changes in one piece of code can affect quite distant, seemingly unrelated, other pieces of code.

• When testing software it is not sufficient to test all of the code. Even 100% test coverage cannot account for code interactions, e.g. an error manifests only when a particular combination of logic paths is executed.

• Hardware is generally more "robust" because it is more modular (and less state dependent). Where it relies on history/state information then hardware too is subject to more bugs (e.g. the Pentium).

So: complexity of solution = complexity of problem + complexity of implementation + complexity from cross-talk