Yet another overly simple explanation of Tunes

[Jecel Assumpcao Jr]

David Manifold wrote:
> 
> When I read this, I wonder how it can make any sense to anybody.  Tell me
> if it makes sense to you.  Anyway, it probably isn't anything new.

It makes a lot of sense, though details stand in the way
between grand schemes and working implementations.

> The entire system can be treated as one big expression.
> In fact, this big expression could be written as a string.

This supposes a single coherent state, which I guess is
important in a system that is based on proofs.

> Anything at all that can be done in the system comes down to an edit on
> the expression.  (Including programming, word processing, internet, etc)

The state can be changed, which is pretty normal in the
computer world. My current thinking sort of takes me in
a different direction (multiple versions of the state, each
immutable).

> The expression is always being evaluated.   The reason it is always
> evaluating is that each object has at least one element in its
> specification, that of "existing".  So the existence of the system is
> constantly evaluating, as long as the system exists.

Is it possible for an implementation to optimize this by
having the system note that an expression, if evalutated,
will give the same result as in the previous evaluation
(if it hasn't been edited, it is side-effect free and
all the inputs as the same) and so reuse the old result
instead? BTW, you introduce "objects" here. How does editiing
the global string affect object identity?

> Since the system is constantly evaluating, an edit on the expression will
> cause changes to take place immediately. 

Having created an "instant assembler", I know this is harder
to do than to say. An edit is defined as what? When I type
in a letter, it changed the expression yet evaluating it
now will result in a syntax or runtime error. I have to wait
until I type some more, delete some text, type even more to
reach another consistent state. The usual solution is to
clone the string, edit that and then press an "apply" (or
"cancel") button to update the string atomically to be the
same as the final edited string. The problem is that breaks
down your model - during some time there are actually two
strings and the one that you are seeing on the screen is
the "fake" one (the Self people would say that it is not
"counterfactual").

> Any changes that are not to take
> place immediately (or subexpressions that are not to be evaluated yet)
> will simply be specified to not evaluate yet.  The constraint to not
> evaluate will still be constantly evaluated.  (Until it is changed, at
> which time the expression it is referring to gets evaluated.)

You mean like  (car (quote (cdr car cond x))) --> (car '(cdr car cond
x))?

Or like  x>3 ifTrue: [ x := 10 ] ifFalse: [ x := 2 ] ?

You do need something like that somewhere in the system.

> I would appreciate comments on this.. I can't make any progress on the
> system unless there is a discussion of my posts and the ideas get refined
> so that they are understandable.  Thank you very much.

It isn't always easy to find the time to reply.

> Won't someone ask how reflection works?? 

Reflection is the relation between the "global string" and the
actual state of the system, right? If so, then no questions.

> Does anybody have any questions
> about the practicality of the above model? 

It is very practical as long as you exclude distributed
systems. See below.

> Any specific questions about
> "how do I do X in Tunes"? 

If I want to add a little something to Tunes, where in
this global expression do I put it? This is a question
that doesn't make much sense in Smalltalk, Self or even
C, but is important in Beta, Scheme or Oberon. The
difference: lexical scoping (or not).

> What we need is some vehement anti-tunesers to
> start flaming the list.  Maybe we should go trolling on the usenet...?

I can do that ;-) Actually, I couldn't be called an "anti-tuneser"
since I very much wish to see it succeed. But after talking
to Fare' about merging it with my own Merlin project I decided
against it since we had some significant differences. The search
for an ideal (the "Not Expedient" part) and the emphasis on proofs
were things I thought were not very good for an "open system". I
wanted Merlin to span large and dynamic networks of machines and
the idea of a single coherent state simply doesn't apply anymore.
I prefer things that work in practice even if they are wrong in
theory. So I concluded that the best thing was to keep the projects
separate (but keep in touch) since each would serve a different
need.

When I hear "Tunes can do anything", I am reminded of a teacher
at the University of Sao Paulo. He was very forceful and
convincing. Even though his whole background was in "traction"
(as in electric trains and stuff like that) he insisted that
he had beaten the Japanese to the "fifth generation computer"
(if you don't remember what *that* was about then you should
study up on it before continuing Tunes!). He thought he had
eliminated the "Von Neuman bottleneck" between processor and
memory by eliminating the processor and computing directly with
the memory. He would take an EPROM, use some address lines as
inputs, some data lines as outputs and feedback the rest of
the data lines into the remaining addresses (a classical
implementation of a state machine, but he thought he had
invented it). It is true that such a machine can compute in
*theory* anything that a classical computer can. In *practice*,
anything beyond the trivial examples he did demonstrate would
have required many gigabytes for EPROM to work. IBM financed
a book of his describing this idea and it sold pretty well!!
Please don't let Tunes fall into this trap. Even the worst
Win3.1 is better than an OS that can only exist in emails...

-- Jecel Mattos de Assumpcao Jr -- mailto: jecel@lsi.usp.br
          http://www.lsi.usp.br/~jecel/merlin.html