objects and messages

[RE01 Rice Brian T. EM2]

I'd like to refine the viewpoint on objects and messages in computing.
I'm not really clear about what I'd like to say here, so assume that I
will attempt to clarify the argument.  This exposition will take some
time, as well.


If we take the problem of matching the user's need with the functions of
a general-purpose digital computer, we see that the situation faced is a
non-linear one: that it depends on the current total state of the
digital computer's role in society.  By this, I mean that everything
about the computer changes as society changes, particularly as it
introduces new computational devices.  I have suggested before the
scheme that these problems be separated out into their linear and
non-linear components to optimize the development process of software
for the human-computer pair.

Here follows the mathematical aspect:
I guess I should go over the general linear problem as I see it.  This
is the classical problem the computer faces: to find the optimal set of
solutions based on a set of constraints which are described by linear
equations (at low-level).  Usually the space over which the solution may
form is a convex planar (hyperplane-bounded) space, with more complex
(but nearly as easily dealt with) problems consisting of a finite set of
convex planar spaces.  The solution set usually quickly collapses into a
combinatorical problem involving the boundaries (faces and edges) of
these spaces.  For those familiar, I am speaking of the Simplex method.
The NP-complete problems are those for which the 'final solution' is
testable by a computer without user aid, but a guarantee of a simple
linear method of finding The Solution probably will not be found.
Non-linear problems have ridiculously complicated spaces to deal with,
in terms of the 'finite sets of linear equation constraints' model we
used previously.

(For those of you wondering, 'Where are the objects and messages this
guy promised?' the relationship will be drawn shortly.)

And now for the common-sense explanation:
The computer system we desire should be able to work with the simplex
method in its fullest general sense to maximize the automation potential
of the general-purpose computer.  What I mean is that this method is
everything but 'intuitive leap'.  This method takes some constraints,
which the user may describe by various general constraints like 'don't
take too much time doing this that you make this process interminable'
or 'don't interrupt me with every little question that you have' or
'don't spend so much time thinking that you waste more time than the
alternative' (this part of the argument definitely needs some
refinement).

The usual approach to dealing with this space of working with computers,
that of communicating goals or information updates, is usually
accomplished by the object-message ontology.  By this, I am not only
referring to the usual object-oriented programming methods that we are
so familiar with today, but the entire paradigm for programming which
has been in use since machines have been developed (this includes most
all of human social development in eastern, western, and associated
cultural systems).  The 'fine-grain' project goal of the Tunes attempts
to address this system's inherent lack of utility.
I intend to explicate the metaphor between a system of objects sending
messages to each other in order to perform some sort of computation with
the higher-level idea of the logic of problem-solving in mathematical
spaces.  Here are some elements of the metaphor:
*	objects have state.  this is stored information, which is equivalent
to a problem-solving (sub-)structure.
*	objects can have meta-state.  this is a useful addition/separation of
information to the structure, by reducing the computability of
properties and meta-properties (i.e. proofs) of the process going on.
*	objects send messages.  this is usually guaranteed statically with
respect to the problem.  therefore, it is equivalent to an
information-update condition.  in other words, it encapsulates the
problem-solving process in some way, by the fact that message-sends are
atomizable, and that a reflective language (interface) can make
statements about the process with those atoms.  This last part assumes
that the message-sends are retained potentially indefinitely, then
thrown away as their information is made redundant by further
computations, either by the object-system itself or by the meta-system
(i.e. a profiler, debugger, or proof-generator).
*	objects respond to messages.  this is guaranteed, almost always, by
the language itself, as an implicit structure generated for each object
(usually dynamically, in this point of view).  most systems regard
message sends as applying to the entire universe of first-order objects,
with various declaration-schemes statically or dynamically determining
whether a given object acts on the message.

Goals for this topic:
*	refine the mathematical definitions' explanations and embed them into
the usual paradigm of 'what the user is doing with the computer'.  (i.e.
identify components of usual computational actions with linear
problems).
*	refine the object-message paradigm explanation and embed linear and
non-linear problem-solving into the traditional object ontologies for
programming systems, including the usual ones seen in commercial
environments (ugh) (e.g. SmallTalk, Self, BeOS, NeXTSTEP, Beta, and
Windows (shiver)) as well as the ones implicit in the human-computer
interaction model.
*	address the Self paradigm of programming, as well as the Lisp and C
styles.