holistic code-generation model

[RE01 Rice Brian T. EM2]

>How are you to encode this ontology?
>I'm asking this question because I don't see how you intend to get
>from an abstract problem description in someone's head to actual
>machine instructions which will run on a target processor of some
>kind.
>My problem is that I'm confused about how your proposal actually
>works. I'm confused, because I don't understand the way in which you
>actually intend to translate from this 'non-specified' high-level
>interactive development environment down into actual machine
>instructions which can run.
>However, what I'm asking for is an
>example of how some simple problem might actually exist in this
>system. Surely at some point some data must actually be in some
>structure inside the system, and must be transitioned into machine
>instructions to run.
>I understand your reluctance to talk about absolute things like
>'formats'. However, what I'm asking for is an example of how real data
>might actually flow through the real system. Real data has to be in
>some kind of format. 
>
>As an, example, if you were trying to teach me algebra, and had said:
>
> x = y + 2
> 
>If I just didn't understand, I'd ask you to give me a specific
>example, and you would say:
>
> y = 1, x = 1 + 2 = 3
>
>You didn't constrain the problem, or create any frozen dataformat, you
>just gave me a solid example which showed me exactly how "x = y + 2"
>actually _works_. That is what I'm asking for.

Computational problems will be solved the same way they always have.
The way that the methods are made will change.  Then will come the new
ways of doing things.

I apologize, since this won't satisfy you, but I don't want to spend
time on tracing an execution path.  Let's just say the user would be
manipulating a model of the situation, like a dynamic slider bar with
symbols or something representing the length of the parts.  e.g. :

<-----------------------------x----------------------------->
____________________________________
|_________________________|__________|
<----------------------y-----------------><------2------->

(forgive the ascii art) remember, this is not x := y + 2. that would
require i/o constraints be explicitly laid out.

The incremental development technique would ensure that the system
'translated' this into a sentence which is parsed.  The variables are
placed on a heap, for example, and instructions are generated with
output updated on the interface.  (I realize that this example is quite
poor relative to the Tunes ideals, but it is 'ad hoc'.)

Have you ever read Cat's Cradle by Kurt Vonnegut?  The central motif is
this distant father who never pays attention to his son because of his
absorption in his study of science.  This father, it is related, one day
realizes this and tries to think of something to entertain the boy, so
he plays with a piece of string until he makes the pattern most people
call "the cat's cradle".  He shows it to the boy, who is quite confused
at it- "No cat.  No cradle."  In other words, lots of meaningless adult
fluff.  (Imagine me saying that with my long sentences! :)  Signs
everywhere, no meaning in sight.
One of my main reasons for having this system (which I consider to
resemble Tunes only as a matter of psychohistoric forces) is for
mathematics.  Not what you see.  Not the signs on the page, in your
head, the words you hear, but meaning.  Math is atomic meaning.  You
have never been told about math.  You never learn math.  Everybody knows
math, since no facts are introduced to teach it.  I speak in terms of
epistemology, I believe (also in prose, of course :).  Society teaches
its members technical things by rote.  Patterns must be recognized.  The
difference  between intelligent and average is atomic
pattern-recognition of some kind.  Those who recognize more and deeper
patterns (liminally or subliminally) are enabled to control others with
those patterns.  Those who do not become robots with respect to the
aspects of their lives addressed by those patterns.  In other words,
metaphor-making ability is cybernetic power.  The results of my project
will face this.

The Point!! -> x = y + 2 does not 'work'.  matrix-multiplication will
not 'work'.

y = 1 => x = (1) + 2 = 3 is the same as the most indecipherable piece of
code that you have ever seen.

My issue with ontological relativity is the same: an ontology is a
pattern.  A pattern can be described by a system of statements (many
systems, in fact).  Those statements and the patterns and sub-patterns
they form use metaphors provided by humans to match the function
provided on the machine with the purpose supplied to the software.  In
my system, the language environment is a first-order entity, available
for analysis.  That is reflection.  However, what seems to differentiate
Tunes from my idea is that the reflection I want to provide will be
designed so that people will have to manipulate as few symbols as
possible, while the system provides them with all the feedback of
meaning, representation, etc. that they need.  In other words, the
software will write the equations and parse them and so on.  The user
supplies only metaphors.

To answer your question in first-order terms: the software manages the
programming language, code-generator, and run-time scheme.  All of the
objects (yes, it still is 'object-oriented') will be "abstract objects",
so to speak.  The message-object ontology will usually be simulated
unless the user or computer finds it desirable to name certain memory
locations as 'The Location's of specific objects.  Everything will be
defined mathematically (atomic reflective logics, not with linear
algebra or statistics).  The second part of the software project will do
away with naming as a global ontology, for the most part.  I intend to
have the software system itself write documentation dynamically (and
throw it away, of course.  I detest static definitions for an
ever-changing system.).