This article is a part of the systemic-ts series.

Inherent Complexity

Complex vs Complicated vs Hard

People often dismiss something difficult as complex. That word is many programmers' black sheep; the opposite simplicity naturally became overrated, ambiguous, and misplaced.

Look into these topics:

  • Following a recipe written not straightforwardly.
  • Understanding how time dilation relates to the speed of light.

Both are hard, but the former can be improved while the latter cannot because the idea of relativity is inherent, fundamental.

I thus name the former complication (or unnecessary complexity) and the latter complexity (or inherent complexity).

Complexity Shift

How would a librarian organize books? Is it by genre, author, color, size, name, publication date?

Categorizing is the most common form of organization. Organization, however, needs a dimension.

The multilemma of the strategy to organize books comes from the lack of dimension. More concretely, a book has many properties---genre, author, color, etc. However, since the librarian needs to organize books within the space which only has three dimensions, the librarian needs to choose one property out of many.

The number of properties maps to complexity, while the discrepancy between the number of properties and the limited number of dimensions is the source of complication. In other words, complication can be perceived as two properties conflicting because they reside in the same dimension. In systems, it can manifest as two components clashing with each other.

To fit more properties within a limited dimension, some strategies can be applied. One simple example is the index in books, which contains the important words and on which page to find them. In software development, a lot of strategies take a similar form to that of the index.

As features are added to a program, complexity grows. Proper organization must be conducted to suppress complications. It is a continuous process, hence there is the term continuous refactoring in software development.

In other words, complication exists not because of complexity itself but because of unorganized complexity shifts and this is the exact phenomenon that arises when a program turns from scriptic to systemic.