Challenge my assumptions!

[iepos@tunes.org]

> Tunesters,
> 
> I'm in the middle of a big research push for Prism.  A lot of groundwork
> is being laid for critical issues such as language interoperability. 
> Before I get too far, I'd like you to challenge my fundamental Prism
> assumptions.  It will soon be too late to change them easily.
> 
> Here they are:
> 1) The basic Prism data types (_Bit, _Stream, _Map) are SUFFICIENT to
> represent any concept, particularly programs.

well... i could define a construct of, say, _Touching_My_Finger_To_my_eye.
This construct could represent any concept, whatever i wanted it to
represent. if you want your question to be technical, you are going
to need to formalize it like this maybe:

"is there a single language, with a fixed interpretation, such that
using only sentences built out of _Bit, _Stream, and _Map by
<insert your language's method of construction here>, any program
can be expressed?"

however, i don't think you really plan on building your sentences
out of _Bit, _Stream, and _Map. instead, you are probably planning
on building sentences out of instances of those types.  if your language
is going to provide a special way to represent instances of those
types, you're going to need to say (for instance, does your language
have words "True" and "False" for the two instances of _Bit, or
a special listing construct for the instances of _Stream, or a table
construct for the instances of _Map?).

now, the first part of your assumption (that your language, with a fixed
interpretation can represent _any_ concept) is likely going to be wrong. Your
language can only represent a specific enumeration (albeit, possibly 
infinite) of concepts, but some sets of concepts cannot be enumerated
(even infinitely), for instance the set of real numbers, or the set
of numerical functions. You should restrict your assumption to programs, 
although you're going to need to formalize what you mean by "program" if you 
want to be sure that assumption is correct.

oh, looking at your web site, I see you did define a language "Prism-GTL"
for representing instances of the data types. But it looks like you
didn't give fixed meaning to any structure. So, you can't represent anything
with that "language". maybe you intend to use extensions of the language
that do assign meaning; if you do, you are however going to have the
limit that i mentioned in the last paragraph. 

> 
> 2) The basic Prism data types lend themselves to INTUITIVE metamodels
> for representing specific types of concepts, especially programs.  I.e.,
> it's EASY to create Prism metamodels (or, at least, they introduce
> minimal added difficulty).

again, I'm not sure what you mean by program. If you include, say
"print the letters 'a' through 'z' in a series to the user's terminal" 
as a program, then there seems to be no way to represent that program
using only instances of those data types, unless maybe you associate
some arbitary sequence of bits to letters, but this hardly seems intuitive.

> 
> 3) There is NO LIMIT on the range of metamodels that a person may
> create.  Metamodels may be created for any human concept.  (This one
> seems obvious to me, since metamodels are defined with natural language,
> but hey! that's why it's an assumption...)

actually, i'm not even sure what you mean when you say model, metamodel,
or meta-metamodel. you're going to need to explain that...

> 
> Fare, you once criticized my choice of _Bit, _Stream, and _Map for the
> Prism meta-metamodel.  That's what I'm asking about now.  Does the
> meta-metamodel meet my goals?  (If my assumptions are correct, it
> does.)  Should I replace it with something else?  (If so, please explain
> how the alternative also meets my goals, and how it is better.) 
> Everyone else, please chime in!

they do seem like odd choices. may i suggest an alternative structure
for representing information: the binary tree ("function application")
with a finite set of words for the nodes. Actually, strictly, just one word 
would suffice (but this might make the interpretion more difficult); if you 
are willing to have self-referencial trees, then no words are necessary 
(this would be like Brian's arrow system i suppose).

> 
> Relevent goals:
> 1) Allow any concept to be modeled within the Prism environment.

binary trees make a real great way for representing concepts.

> 2) Make it easy for the user to create metamodels.

again, i'm not sure exactly what you mean by "metamodel". If you mean
"language", then yes you could use binary tree sentences to describe
new languages. you could do this using a language about languages (also
using the binary construction as the sole construct), maybe what you call a 
"meta-metamodel"...

> 3) Allow Prism models to be understood, manipulated, and transformed by
> outside observers (humans & programs) if their metamodel is known and
> understood.
>

binary trees are usually natural to interpret... english sentences
seem mostly to be trees, and any tree can be represented as a binary
one using currying.
 
> -Jim
> 
> Prism is at http://www.teleport.com/~sphere
> 

you might want to take a look at my web site, http://www.tunes.org/~iepos ...
i'm working on an introduction to binary trees, and the essential tools
that come with them in any powerful language based on them, the combinators.
i've been doing things from a logic standpoint, but you could probably
come up with a good imperative language.

- iepos