Where Tunes is going.

[Brian Rice]

>  Brian> It sounds like you've completely missed the point.  I'm
>  Brian> suggesting abandoning the *language* idea altogether as a
>  Brian> model for Tunes, and you state support by proposing your Open
>  Brian> Implementation *Language*.  
>
>Don't get fooled by the words. OIL is *not* a language as C or
>Lisp. It does not have a builtin syntax. It should provide a means to
>describe _what_ you want to do in the most abstract manner, without
>having to care about the _how_ you want do it. It's not fully
>implemented yet, but that's our goal.

It's still a language, you idiot, even if it is reflective.  In fact,
considering that it's highest aspiration is dynamically-configurable (I'm
guessing without any real docs) AOP based on lisp, I can hardly consider it
more worthy of consideration than Maude, which is based on well-understood
ideas.  (read papers on aop from recent ecoop conferences).  AOP is just a
special case of graph-rewrite rules!  It's amazing that I didn't respond
sooner to this drivel.

>  >>  I want Tunes very very badly too. In a few weeks I'll be
>  >> starting up a company with a friend, and we intend to provide
>  >> support and services for Tunes. (We don't actually call it Tunes,
>  >> but the ideas are the same I think). I am working on a prototype
>  >> which you can download at
>  >> http://laurent.penguinpowered.com/~laurent/oip.html. I'd be very
>  >> glad to work with you on Arrow if I knew that we have the same
>  >> goals. But I still don't know what is Arrow all about. So if you
>  >> have a working implementation, or a few _real world examples_ to
>  >> show me, I'll have a look at it and see if my OIL is equivalent
>  >> to your ARROW.
>
>  Brian> Yes, you're right.  You (and others) still have no idea what
>  Brian> Arrow is about.  I've looked at your code, and it isn't any
>  Brian> more impressive than an open-source Maude or some equivalent.
>
>It is not meant to be impressive. It's just bootstrap code and
>experimentation for the moment. 

Well, I have had bootstrap code for experimentation available on the tunes
site for months, and I have yet to find anyone suggesting ideas or even
attempting to understand my ideas based on it.  Thanks for wasting Tunes
resources on ideas that have already been tried.

>  Brian> And how can you ask me for a "working implementation" when
>  Brian> you don't know what the damned thing is for?  I re-iterate:
>  Brian> it is not a language, it is a framework for migrating
>  Brian> information patterns with no inherent semantic content.  
>
>I ask for a working implementation because I still don't understand
>what it's all about, so I need some examples so that my little brain
>can get the idea.

You idiot!  YOU'RE part of tunes, the group which is supposed to develop
the ideas that everyone else uses.  If tunes were about a bootable
reflective lisp implementation, then we wouldn't have the problems with no
one agreeing on the method to do it!  And I don't have the time to work on
this stuff, which is why I have applied to the group (to no avail).  There
are _still_ people on the Tunes list who are so dense that they can't tell
the difference between Arrow graphs and categories, though the paper
directly states the difference!  I can't believe that you people think you
can actually achieve the Tunes (official) goals and have the 'perfectly
moldable' system you desire.

>  Brian> I also disagree that you want Tunes.  
>
>Every body here has his own definition of Tunes anyway, so I think
>that this kind of remark is useless.

Well, it seems that the hundreds of pages that Fare has written are a
complete waste of his time.  Maybe the group would be better off "going
back to basics".  It's not a useless remark if you are, indeed, mistaken,
but then you'd never consider that possibility.

>  Brian> I believe that I just expressed why a C coder will never
>  Brian> actually want to have Tunes.  They would never support it
>  Brian> properly, even if it did exist.  The fundamental difference
>  Brian> between coding and supporting Tunes spells it out quite well.
>
>I don't consider myself a C coder. I'm using C/C++ to implement the
>bootstrap interpretor for OIL because my first attempt with Tcl had
>very serious performance problems. Once the interpretor will be
>reimplemented in OIL, I won't touch C anymore. All will be done in
>OIL. 

You missed the point. "low-level"ness of a language is relative. picking a
semantics to work with and staying with it is low-level (e.g. computational
notations in general).

>I'll have to learn IRC one day ...

get a clue. do a net search on it.  (this says volumes about your ability
to deal with new ideas ;)

>-- 
>Laurent Martelli
>martelli@iie.cnam.fr

Isn't anyone going to back me up?

	-Brian