The Architecture of Complexity

The following post is based on the chapter The Architecture of Complexity: Hierarchic Systems from the book The Sciences of Artificial by Herbert Simon.

The chapter excerpt that I was reading from is a scanned from the book. That made it really hard to read the words and it could have slightly affected my evaluation of the chapter which was based on a paper of a similar title. Anyway, I felt that this paper was a bit too slow moving and verbose. I do not enjoy interdisciplinary approaches when explaining things especially if the examples themselves are presented with too much detail. Being a book, it caters to a broader audience so including various examples might be more helpful to the reader. But, sometimes these examples masquerade the intentions of the author.

Nonetheless, the paper does have some interesting points. The gist of it is that complex systems are usually composed hierarchical components. These hierarchical components can stand alone (and indeed the author calls these stable intermediate forms) but they are more useful when combined into systems that interact. For instance, in Computer Science, we might combine the java.swing packages with the java.io packages when designing our program. By combining those hierarchical components, we actually create even more complex systems albeit in a piece-wise manner so that we can understand the evolution of the system.

This decomposition into hierarchical standalone components is a way to tackle the complexity. Once we have a hierarchical structure, it's easier to describe and analyze the underlying complexity. We can take a component and analyze it in isolation first. After that, we could combine components together in different configurations and reason about how they interact. We can continue doing so until we have achieve our objective. Having a way to describe a complex system in simpler terms makes reasoning about the system itself simpler.

In design, we strive to decompose components so that they have high cohesion internally and low coupling externally. Complex systems that exhibit this decomposition can be more easily understood by other developers.

Indeed, most of the architecture or design that we see in software today is based on some form of hierarchy. Inheritance in object-oriented languages is a form of hierarchy. Classes themselves are a form of components that can stand alone or interact with other classes. In conclusion, decomposing a system into hierarchical components is a useful approach to not only manage the evolving complexity but it is also an useful way to describe the system to someone else.

It is also important to realize that hierarchical decomposition is not the only way to handle complexity. It certainly is one of the more well-known methods but there could be other methods yet to be discovered.