Edgeware - Principles


Grow complex systems by chunking.

Allow complex systems to emerge out of the links among simple systems that work well and are capable of operating independently.

What we could be doing


Question: Who built the Internet?

That’s an easy one. The answer, we all know, is no one. Not Bill Gates or any other computer genius. The Internet is our most visible and oft-cited example of emergent phenomena, an elegant case study of how a complicated and vastly diverse system can self-organize … in this case, almost overnight. On close examination, we see that the Internet evolved in chunks – like a set of building blocks – with components being integrated into the system only after they had been individually refined, proven and accepted by a collective, systemic jury.

Complex systems are … well, complex. They are not easily understood or built in detail from the ground up. Chunking means that a good approach to building complex systems is to start small. Experiment to get pieces that work, and then link the pieces together. Of course, when you make the links, be aware that new interconnections may bring about unpredicted, emerging behaviors.

"Interesting, beguilingly complex behavior can emerge from collections of extremely simple components."

"A scan of history shows that technical innovations almost always arise as a particular combination of well-known building blocks. "

This principle is the basis upon which genetic evolution proceeds. Building blocks of organism functionality (for example, webbed feet on a bird) develop and are combined through crossover of genetic material with other bits of functionality (for example, an oversized bill more suitable for scooping fish out of the water) to form increasingly complex organisms (a pelican). The good-enough genetic combinations may survive and are then available as building blocks for future combinations. The UNIX computer operating system is another good example of an ever-evolving complex system that was built from chunks. The basic – and at the time it was introduced, revolutionary – principle behind the UNIX system is that software functions should be small, simple, standalone bits of code that do only one thing well, embedded in an environment that makes it easy for each such function to pass its output on to another function for further processing.

"The only way to make a complex system that works is to begin with a simple system that works. Attempts to instantly install highly complex organization … without growing it, inevitably lead to failure.To assemble a prairie takes time – even if you have all the pieces.Time is needed to let each part test itself against all the others. Complexity is created, then, by assembling it incrementally from simple modules that can operate independently. "

Applying this principle to teambuilding in a mid-sized organization, for example, would suggests that leaders should look for and support small natural teams. We might provide coaching and training for these teams. Then, when these teams are functioning well, look for ways to get the teams to work together and involve others. These new links may result in weird behavior; with a CAS, this is to be expected. The leaders should be open to doing some adapting of their own. Rather than insisting on pressing forward with the training, ground rules, or procedures that worked so well in the first teams, the leaders should understand that the interconnections among teams has resulted in a fundamentally new system that may need new approaches.

Continual reflection and learning are key in building complex systems. You cannot reflect on anything until you do something. So start small, but do start.


Next | Previous | Return to Contents List

All Components of Edgeware Principles Copyright 2001, Curt
Lindberg, Complexity Management, VHA Inc. Permission to copy for educational
purposes only. All other rights reserved.