Information Technology Reference
In-Depth Information
This generates a hierarchy of codelets, in which those at a certain level have
“knowledge” of the codelets they generated, but ignore both their “superior” codelets
and their “peers”.
Some differences between the way that codelets work and more traditional pro-
gramming are the following:
1. the structures built by codelets can be both dispensable and redundant, whereas
programs usually have non-redundant code, and whatever they build is rarely
destroyed;
2. codelets that are “peers” (i.e., at the same level in the hierarchy) work in parallel,
whereas programs are usually written to run sequentially; and
3. there is no “supervisor” with a total knowledge of which codelets run at any
moment and what they will eventually achieve, except at a very local level, when
a higher-level codelet becomes a supervisor, but only of the codelets of the imme-
diately lower level that it spawns; instead, in traditional programs the programmer
has an overall view and knowledge of which pieces of code exist and can run at
any time. Thus, the system of codelets is dynamic and distributed, bound only by
the constraints of its hierarchical structure. 1
An example might clarify the question of how codelets build structures, solving
problems at the same time. Let us consider the problem of visually perceiving a
written piece of a sentence, and attempting to understand its meaning. Suppose the
phrase (i.e., fragment of a sentence) is:
.
meaning
that
he
failed
to
discover
it”
We can imagine a highest-level codelet the task of which is: “to understand the given
phrase”. This codelet spawns a number of other codelets, some of which have tasks
as: “to understand one given word”; others: “to put words together in a syntactically
correct structure”; and so on. Codelets of the former kind spawn other codelets
assigned the task “to read a word”. If the perceiving agent is a human being, then
the task “to read a word” entails signaling the muscles that move the eyes to perform
eye saccades and sample a few spots within the word; whereas if the perceiving
agent is a program it could do something analogous but by processing letters within
a string, or by processing the pixels of an image, if the above phrase was part of one.
Occasionally, some codelets might produce a wrong result. For instance, the “e” of
“failed” might be seen as a “c”, but this will not make sense in the context of the
output of other codelets because there is no word like “failcd”; thus, another codelet
can re-perceive the letter in a way that makes sense. The destruction of already-built
structures can be seen more explicitly at the level of syntax: the reader might perceive
the word “meaning” as a noun, interpreting the phrase in this sense: “it was that kind
of meaning which he failed to ...”; but, alas, after the word “discover” comes the
pronoun “it”, which either is redundant or—if this is a correctly written fragment of
1 Hofstadter [ 10 ] does not assign a hierarchical structure to codelets; the idea of a hierarchy of
codelets is introduced in the present article.
Search WWH ::




Custom Search