Tom Novelli
Sat, 12 Dec 1998 12:01:17 -0500

On Mon, 7 Dec 1998 13:33:20 -0500, Matt said:

>         I don't believe that overnight, TUNES can burst forth into
> existence as a new medium of computing that's many generations ahead of
> everything else.  Things tend to require several iterations of
> evolutionary refinement.  TUNES is so ambitious that, once real goals are
> established and work begins, several prototypes may need to be written
> before the right balance in achieved.

Yeah, we need to get our hands dirty. There's nothing wrong with having
several prototypes under construction at the same time... it's just that
there should be some common ground. We'll want to merge parts of these
prototypes together from time to time. Of course, if you come up with
some great idea, by all means pursue it, even if that means straying far
from our current goals for Tunes. Goals change sometimes :)

Another reason I thought of for prototyping: We could learn a lot by
seeing (and improving on) each other's code. Code is the best way to
communicate some ideas. BTW, I think design by committee sucks too. Open
development is a different matter.

>         Basically, I feel that the TUNES project needs to get realistic
> and the attitude of the contributors should be pragmatic.  I am in favor
> of building/organizing a knowledge-base, since that allows people to be on
> the same page and establishes some common ground for dialog, in addition
> to its other advantages.

You know, all the fancy words are hampering communication... we're not
quite speaking the same language. For example, I see "Reflection"
written all over the place. So I looked in the glossary, but that didn't
explain it too well. I had to read a fucking doctoral dissertation to
figure it out! And that was so cryptic I'm still not really sure I
understand. Here's what I currently think reflection is:

	A reflective programming language has a _formalized_ way to 	
manipulate itself. 

	In other words, you can modify the language itself without editing 	the
compiler source code and recompiling it, without hacking the 	machine
code, etc... In practice, a reflective OS or language can 	modify itself
on the fly, while it's running.

Now I wouldn't be surprised if I missed something there, so feel free to
clarify that.

When I have a better understanding I'd like to add plain-language
definitions to the glossary, and maybe some longer explanations. I also
started writing a Forth tutorial, and I should write one for Scheme.
It's hard to find good, concise documentation.. so I'd be happy to write
it if it's useful to other people. 

Tom Novelli <>