I looked at Neman Cells.  It looks like a pretty straightforward
implementation of the observer pattern.  I only took a quick glance, but I
see nothing that would handle circularity.  The async cells look to me like
one could have an inconsistent view of the data depending on *when* one
looked at the cells.  This is fine, I suppose, for some purposes, but I'd
prefer something more deterministic.  Plus I'd prefer less state rather than
more.
When I finish my Datalog work, I'm thinking of leveraging some of that
knowledge to build a dataflow declarative computation framework similar to
Cells, using explicit parallelism rather than asynchonisity.

If anyone knows of this mysterious "one more implementation", I'd love to
see it.

Thanks.

On Mon, Feb 9, 2009 at 5:08 PM, Frantisek Sodomka <fsodo...@gmail.com>wrote:

>
> See neman.cells:
> http://clojure.org/libraries#toc61
>
> I believe there is at least one more implementation somewhere.
>
> Frantisek
>
>
> On 9 Ún, 17:26, Jeffrey Straszheim <straszheimjeff...@gmail.com>
> wrote:
> > I know I could just go read the docs, but I hope someone familiar with
> this
> > Cells stuff could save me some time:
> >  1. Does Cells handle circular dependencies in your computation?  If so,
> > (briefly) how?
> >
> >   (e.g. if the value of X depends on Y, and Y depends on X, can it handle
> > it?)
> >
> >  2. How is state handled?  Does each cell maintain its value statefully?
> >  Are some stateful and others not?  How are updates cascaded?
> >
> > Thanks in advance.
> >
>

--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To post to this group, send email to clojure@googlegroups.com
To unsubscribe from this group, send email to 
clojure+unsubscr...@googlegroups.com
For more options, visit this group at 
http://groups.google.com/group/clojure?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to