
 *******************************************************
 * EXPERIMENTAL! DRAFT! DON'T TRY THIS FOR NOW !!!!!!! *
 *******************************************************

This is an experiment. This document may be erratic as it is used
as a development sketch.

I plan to try to implement the fudget idea in Eiffel.

Even though Eiffel is not a functional language, Fudgets have major
benefits that go beyond functional programming and apply to
programming in general.

They are:

-- disciplined flow control

-- true composability (they're the closest thing to software
-- components I have ever seen), because of short, clear and precise
-- rules of composing

-- there is a clear separation between the computational aspect and
-- the interactive aspect of the application

-- both aspects have a clear visual representation. Circuit like
-- schemes of the application might help to understand it better and
-- faster

I will be using the Fudgets idea to improve the above-mentioned points
in EXG programs.

The basis for this attempt to fit a square into the circle will be the
EE_EDGET class. I won't use the Fudget name, because I would build a
lot of confusion around it. I will derive another name, as it seems to
be fashionable when it comes to Fudgets. So here it is: EDGETS (from
Eiffel fuDGETS).

Implementation: There will be a pool of named messages.

Each Edget will have an name to help it find its own
messages.

Each Edget will have a `put' command to handle outputting. `put' will
place a message in the pool.

Each Edget will have a `run' command that will be called by the
`message pool master' when there is a message for the edget with the
message as the argument.

Each Edget will know only of a `next' edget and of a `previous' edget
(with the following two exceptions).

Parallelism will be implemented with two special edgets: one that will
receive input from many sources and will re-send them all to its
output and one that will have only one input but will dispatch it to
many outputs.

There will be some master edgets to ease composition and simple loop
master fudgets.

The prefix used for these classes will be EE_ (from EXG and EDGET)

EDGETS are simply a glue.

Each edget may (or not) have an associated Gtk widget. Layout will be
taken care of by Gtk.

Programs will be structured by Edgets, however.

Edget programs will also help turn your program into a parallel one,
as soon as Eiffel will support it (each edget actually works separated
from the others, it can run on a separate processor(thread)).

PROBLEM: how to map the output of the nooutput edget to the output of
the master edget?

problem solved: the `no_output' command in `EE_MESSAGE_POOL'

TODO: this implementations fills the CPU 100%, so I'll have to make
put restart the idling and the idling should stop itself once it has
run out of messages

CPU 100% usage problem solved.

I think there's a bug with class ARRAY of good old se.
I should gather info for a bug report.

