RE: Language design values (Re: message primitive)

["Daschbach, John L" <John dot Daschbach at pnl dot gov>]

	Question:  how can one express the notion that the members of the basis
set
	themselves are maximally simple?  Presumably one could define a basis
set
	that includes semantically complex functions which could be expressed as
a
	combination of a different basis set.  I'm having trouble at the moment
	coming up with a realistic example, but suppose you had a "frobnicate"
	function that really means "first bevorpilate, then pibbelize", but the
	latter two are excluded from the language for some reason, or are always
	implicit in other primitives.  Is there a term from mathematics that one
	could use to indicate a basis set has or has not been maximally
decomposed?

In your example it seems likely that "frobnicate" would not be orthogonal, since
it is composed of two conceptually simpler operations which you say are likely
implicit in other primitives.   If you can find an operation which may be
carried out with different sequences of primitives, each with at least one
unique member (non-null and non-logically negating) then you have shown the
basis set of primitives is not orthogonal.  

The best term I can think of off the top of my head comes from group theory,
"irreducible representation".  This is a bit of a stretch, since symetry
operations in group theory leave the underlying object indistinguishable from
before the operation.   However, given that stretch, it does seem like it works
in a sense.  In group theory an irreducible representation is the set of reduced
dimension representations which can be used to express the operations of the
group.   However this still does not uniquily specify the basis functions for
the representations.  By convention these are generally chosen to be simple in
form, e.g. the C2v group is generally considered with the basis functions,
(x,y,z,x^2,y^2,z^2,xy,xz,yz)

It is my understanding that RISC architectures strive for orthogonality.   To
stretch this, the design of a RISC machine goes along the lines of "We'll do all
the operations that we don't think you can code around and which are needed, we
think, the most.  We'll do it very well, and provide lots of registers for
scratch space to handle what we haven't done.  We expect that the clever
compiler writers can better figure out how to to the rest fast, rather than
trying to anticipate what is needed".  The problem translating this to scheme is
that, in general, we don't compile.  This is a serious difference and one that
is in general not part of the academic background of scheme.  While it may be
possible to implement lots of functionality on top of a minimal scheme core it
can be much slower than having a more extensive set of core (C) primitives.

	-John