Issue No.05 - May (2004 vol.5)
Published by the IEEE Computer Society
Maarten van Steen , Vrije Universiteit Amsterdam
DOI Bookmark: http://doi.ieeecomputersociety.org/10.1109/MDSO.2004.4
Fed up with the overly complex designs of feature-rich systems? Read about mastering complexity through simplicity instead of concealing poor designs through packaging.
I don't know about you, but I'm fed up with the overly complex designs of feature-rich systems. Considering the effort that understanding a new system's essentials often takes, I'm not surprised when people refuse to adopt new stuff—you just don't know what you're getting yourself into. Trying to hide complexity by wrapping it up in something simple won't do. As Alfred Heijsberg, the designer of C#, nicely put it, this just leads to simplexity. As soon as something happens that doesn't fit the simple wrapping, you're in trouble, because you'll never understand what's going on. What you thought the system was all about by looking at the outside doesn't fit with what you now observe.
There's only one solution: go back to the drawing board and concentrate on bringing simplicity back to design. This isn't easy. In fact, it's generally harder than developing complex systems. For example, my field of research is large-scale distributed systems—think of computer systems that consist of millions of nodes, span the entire Internet, change continuously, and are managed by many different people and organizations. These types of systems have a natural habit of exhibiting exceedingly complex behavior, yet keeping their design simple is crucial.
Recently, various research groups started concentrating on computer systems that qualify as self-managing, self-organizing, self-healing, and so forth. Perhaps the most intriguing aspect of these self-* systems is that they're designed to exhibit behavior that hasn't been explicitly programmed. It's the emergent behavior that counts. For example, we designed an extremely simple and highly scalable protocol to construct a huge network containing millions of nodes that'll fall apart only if 80 percent of the nodes crash simultaneously. We've been using this type of network as the basis for large-scale information dissemination and gathering, failure detection, and computing aggregates (such as averages and extremal values).
The designers of these self-* systems are looking for simple principles that lead to useful emergent behavior. This behavior is often called complex—not because it's difficult to describe but because its relation to the underlying simple principles isn't well understood. We're suddenly playing a whole new game! Instead of concealing complexity through oversimplified wrapping, we're deliberately making the simple internals of systems visible to explain observed behavior.
Unfortunately, the emergent behavior might also show things that we'd like to see happen differently. For example, the simple protocol we've designed doesn't always spread information as fast as we'd like. The first thing that comes to mind is to tweak it to improve dissemination speed. However, this tweaking might easily affect desirable emergent-behavior aspects, such as resilience against massive node failures. Controlling the generated behavior (complexity, if you like) requires special attention. However, we might then find ourselves enhancing the protocol—that is, making it more complex. Enhancements don't always lead to improvements.
Again, the challenge is to keep things simple. Compared to many existing systems, we, as designers of self-* systems, have the advantage that our basis is inherently simple. So, in principle, we don't need to first master the seemingly needless complexity that other designers brought in. We merely must stick to the simple design principle of not accepting enhancements that are inherently complex or that easily lead to complexity. There had better be a good reason to incorporate such enhancements—but, in most cases, I doubt that such reasons exist.
Self-* systems are gaining attention, and I predict we'll see more of them in the near future. We might have finally found a way to master complexity through simplicity instead of concealing our poor designs through lousy packaging.
I encourage you to get into the loop. Many articles and books on the subject exist. A good starting point for the uninitiated is Duncan Watts' Six Degrees, an easy-to-read book on various forms of complex emergent behavior (W.W. Norton, 2003). Those seeking to understand some of the mathematical underpinnings should study "Statistical Mechanics of Complex Networks," by Albert and Barabasi ( Reviews of Modern Physics, vol. 74, no. 1, 2002, pp. 47–97). Both references offer links to other material that should introduce you to the fascinating world of simple complexity. You'll also start to wonder, just as I did, why people spend so much time designing complex systems when designing simple ones is easier.
Maarten van Steen is a professor of computer science at the Vrije Universiteit Amsterdam. Contact him at firstname.lastname@example.org.