Allow complex systems to emerge out of the links among
simple systems that work well and are capable of
operating independently.
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."
–Waldrop
"A scan of history shows that technical innovations almost always arise as a particular combination
of
well-known building blocks. "
–Holland
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. "
-Kelly
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.
1. Thoughts
