Structured design, goto's, and the holy grail

Richard Harter g-rh at cca.CCA.COM
Sun Jan 31 12:00:47 AEST 1988

In article <10392 at mimsy.UUCP> chris at mimsy.UUCP (Chris Torek) writes:

>And when the number of protocols expands beyond some limit, it
>becomes incomprensible as a whole---just as when the number of
>labels in a Fortran program gets out of hand, the structure of a
>module dissolves.  While loops and case statements and such provide
>a way to keep the structure of modules, without having to break
>them into sand-grains rather than building blocks.  Object oriented
>message passing models provide a way to add structure to global
>interactions, but someday, someone will wonder whether to use a
>SemaphoredQueue or a MonitoredSparseArray, or was there a better
>type...?  Time to root through the 15 GB index of possible datatypes!

	Yep.  Some expounders of CS (but not Chris) don't seem to
understand this fundamental principle.

>>The problem of 'global data' is a manifestation of the problem of
>>organizing large systems.
>I think no one really knows how to do this, no matter *what* the
>system, when it gets truly enormous.  Large companies and governments
>have the same problem.  Hierarchical [my fingers want to type
>`heir'!] breakdown works well up to some size, but eventually the
>sheer number of levels in the hierarchy becomes a problem.

	Chris and I are really saying the same thing (I think).
One way to look at it, very loosely, is this.  Suppose that there
is a limit to the number of things that we can keep track of, call
it N.  Then we can understand any system with N or less items in it.
When we build a large system we use decomposition so that any particular
piece can be understood by understanding the piece and its connections.
This lets us expand the size of the system that we can deal with to
2**N items.

	There are three implications to this idea.  The first is the
implementation of the general scheme -- how to build the pieces and
their connections so that the scheme works.  The second is that the
scheme still fails when the size reaches a much larger limit.  The
third is that we have traded complete comprehension for a limited

	An interesting thought is that, if we want to deal with
really large systems, is that we ought to look at how life works.
Life (biological life, not the game) is a really immense system
that works.  A single cell, considered as a system, is more complex
than our largest programs.  A living animal has trillions of cells,
organized in multitudes of subsystems.  The biosphere has billions
of living creatures, interlocked in the general ecology.  And it all
works.  Maybe if we really understood how the human body works, we
would also know how to create really large systems software.


In the fields of Hell where the grass grows high
Are the graves of dreams allowed to die.
	Richard Harter, SMDS  Inc.

More information about the Comp.lang.c mailing list