holistic code-generation model

[RE01 Rice Brian T. EM2]

>Perhaps you misunderstood what I meant when I said example. I want to
>explain every single transition of the code, until it finally becomes
>something which can run machine instructions, including how the
>optimizations we can come up with will work.
>
>I was thinking more along the lines of an example where we describe a
>matrix operation to combine two datasets into a third, or code for a
>doubly linked list, and operations on that list. Where we start with
>the proposed high level description, and my hand perform this
>'holistic code-generation' on that high-level description.

ok. Now I address the problem in question.  In Tunes, we'll assume that
the user will naturally see the advantage to always program in
high-level, or at least that's what the example user will do.  The user
will probably use a mathematics-type statement for the matrix
combination (let's just assume concatenation).  If the type is some sort
of database (as a list of records with relations over them)- the more
likely scenario, then the environment will, as the user specifies the
subject matter, gather the objects and their related methods and aspects
into a 'thought-processing corral' (ok, I'm stretching it a bit for lack
of a better term ;) where the code performs queries on the objects in
question.  The objects respond with messages, as in any other object
system, giving another math-based definition of the final object's
elements, and the relations over both data-sets that apply.  We may
require an interface resolver to match up the meanings of the
data-fields, which should have been done before-hand by the environment
to consolidate code for both of the data sets.  The relations should be
combined with formal statements and semantics look-ups.  Any unresolved
questions from the system should be posted to the user (who can ignore
them or send them to a log), as well as aspects which the system
considers 'special' (applying to the case sufficiently to warrant
code-weaving).  The aspects will probably include the possibility of
creating the new matrix solely by creating new methods (at low-level)
which cause the two matrices to be treated as concatenated, while
recording the meta-data somewhere (where????????***).

I hope this gives us something to work on.