Arrow System -- Rationale?

[RE01 Rice Brian T. EM2]

> > that is, it is relatively trivial in the Arrow system to make
> > statements about parts of other statements.
> What's a "statement," in the Arrow system?
> 
> >  we achieve 'reflection' by including enough information about the
> > system so that it encompasses it's own existence.
> 
> But how is information represented in the system?  Define an Arrow
> system which represents the binary string "00".  For example, it could
> be represented 
> 
> with this Prism metamodel:          and this model:
> 
> _pStream (Binary String)            _pStream
> +----+-------+                      +-----+
> | 0+ | _pBit |                      | '0' |
> +----+-------+                      | '0' |
> (State 'zero' of _pBit represents   +-----+
> the binary digit 'zero' and state
> 'one' of _pBit represents the binary digit 'one'.)
> 
looking at this question, i see that it is time to explain some implications
that the Arrow system has in the direction of information encapsulation.
for instance, if within the system you wanted to describe a symbol of a
language, then that symbol is just an arrow diagram if the language is not
an object in the arrow system.  in other words, there never is information
within the system which cannot be made explicit, because all information
beyond the primitive arrow object is 'built' out of arrows.  this is a
property which i intended for the system to have.  that is why the system is
so simple: to make the process of knowledge-level reflection simple and to
make reflection on other concepts explicit.
because of this, you can't make some object (like '0' or '1') all by itself
and expect the system to understand it completely.  doing so would be like
reverting to the usual programming languages, where the user is expected to
manage the majority of the semantic content of the program, and the software
is expected to make routine checks on the format of the code within certain
limits.  so, '0' or '1' only mean as much as the chosen context allows (i.e.
state of a binary-state machine with or without dynamic (action) semantics).
now, the first thing which comes to mind is that this is very difficult.
what first-time user wants to define the semantics of the usual math systems
if all he or she wants to do is make a spreadsheet that just works?  of
course they wouldn't want to.  so, we build a library of understanding for
the computer in the Arrow system that gives closure (completes the
understanding that the computer would need) for working with a number or an
entire spreadsheet.  And with the arrow system, the syntax of expressing
such knowledge to the computer would leave accessible all sorts of
semantical interpretations within the Arrow system.  That's because the
syntax of the Arrow system is so simple in its set of assumptions.  It's
more general than the lambda calculus and its derivations, and more general
than category theory and its view of the universe.

this is useful in showing how Arrow supports Tunes.  i promise examples
soon.

> Or is the Arrow system also a semantic meta-metamodel, as I define it? 
> That is, does the meaning of a given Arrow system depend on the meaning
> you choose to give it?
> 
not the meaning that YOU choose, but instead the meaning that another arrow
structure gives it (i.e. via closures).  you could choose the former
perspective, but in reality, there would only be a simulation of your
desires within the arrow system doing the real interaction.