World: r3wp

this will allow us to use window events directly within a lazy computing 
environment, for example, or provide dependency notification of child 
to parent changes.  this will allows a node to send a manual signal 
"downstream" and possibly take processing/setup decisions based on 
those messages.  downstream nodes should be able to return data in 
order to feedback the effects of the signal to its author, which 
might then, also activate some code.

so for liquid, this means a processing decision can be based on downstream 
nodes capability to handle it,  its like look-ahead processing

Max, you should take a look at petri-nets. I'm sure it will give 
you a lot of inspiration.

Woohoo, finally starting to make some progress with my comprehension 
of !Liquid!

And I'm building up a lot of code and information for creating tutorials 
 :-)

I'm finding myself writing standard test code for each plug type 
as I go along and I was just thinking it would be nice if I could 
add the code as a block on the plug such that I could test any plug 
type by calling 

liquify/test !plug


Or something like that...  Could be a nice documentation/usage example 
feature.

that is a Tremedous idea.  I even know how It could be done... be 
carefull I might put you in charge of developping it   :-)

Sounds good to me!

As you know, I just totaly reviewed how liquid-vid will handle its 
layout (now a live prodecural network in its own), so I am hard at 
work building that, but I will definitely put some time on integrated 
unit testing, when I rebuild the visual graph editor.  its such a 
great idea, as we have discussed, the I/O aspect of plugs cannot 
be ignored in dataflow, so this would be a great way to profile, 
document and verify expected node behaviour.

BTW...  I seem to be seeing a node processing it's liquid when it 
shouldn't be.  Once a node is liquified, filled and purified it shouldn't 
call process() or purify() again until it is filled again, should 
it?

this and the !plug/document.

I really can't wait to play with liquid-vid.

btw there is already a plug/valve/stats feature embedded within, 
which gives you the node's current state and setup.

btw, the work being done for liquid-vid's layout, is now the official 
prototype for the inital layout engine for GLASS

although GLASS will use the data within AGG instead of view/faces.

Hrm...  Accord to stats my node is still dirty although I KNOW I 
am returning TRUE from purify()

so after 15 years of analysis, design and countless prototypes of 
all shapes and sizes , I am now finally working on the first true 
code that will find itself into some layer of the GLASS engine. 

=oD

you called content on the plug before calling stats?

(content is a duplicate word for the cleanup function)

Yup!

!color/process() [
]
!color/purify() [
]
0.255.75
0.255.75 (should be)
>> c/valve/stats c
liquid/color[1]/stats [
    ================
    PLUG STATISTICS:
    ================
    LABELING:
    ---
    type:      color
    category:      !plug
    serial id: 1

    LINKEAGE:
    ---
    total subordinates: 3
    total observers: 0
    total commits: 0

    VALUE:
    ---
    tuple!: 0.255.75

    INTERNALS:
    ---
    pipe?: none
    stainless?: false
    dirty?: true
    shared-states:
    linked-container?: false
    mud: 1.2.3
    ================
]
>> c/liquid
== 0.255.75
>> content c
!color/process() [
]
!color/purify() [
]
== 0.255.75

i don't know a part from you forgetting to liquify the plug first 
what could be going on!

that's a class... not an instance.

use liquify first.

c: liquify !color

from the liquid code's purify documentation (in the code)


   ; we RETURN if this plug can be considered dirty or not at this point. 

so if you return true, it remains dirty.

I might have described it the other way around, but I meant to say 
like its described in the above sentence... sorry if I mislead you!

LOL, fix blood.r then, please!


; this is ESSENTIAL determines if plug is dirty or not... basically

; if you return false, the node stays dirty... and is re-evaluated 
everytime.
; if you forget to return a value, liquid causes an error. 
true

hahaha

yep... I WILL

Fixed.  Sweet!

strange I can't find that specific code in blood.r... I guess I already 
fixed here, hehe.

darn, even I was using it upside down in many plugs, in other stuff! 
  hehe I guess I should learn to RTFM... especially when I writing 
it!   ;-)

LOL

you guys can't imagine how nice it feels to be discussing and teaching 
about how to use liquid.... I've now got three pupils... in one week... 
that's so cool...

Oh, my bad.  It's not in Blood.r.  It's in the code you posted above 
for the !color node...

Congrats!

anyone who wants to get to use liquid, don't hesitate to try and 
ask stupid questions.  They are hard to answer, and its giving me 
a chance to get a general feeling of what needs more attention in 
the forthcomming revision to the whole liquid documentation.

for the layout algorythm,  I actualy did a complete flow analysis 
of a row/column resizing liquid graph.  its actually rather simple, 
when you force yourself to follow what data goes where.  note that 
I was able to build this without creating a processing cycle... which 
is neat, since some values are going to the parent face and coming 
back to its pane elements.

It's not clear why you created the !int-range-srv plug for Blood.r 
rather than just creating !int-range directly.

when you pipe two or more nodes together (using pipe() on a plug, 
using the /piped refinement of liquify, or fill/pipe) the system 
automatically creates a pipe server which acts as a broker amongst 
all piped plugs.

this is a normal plug to which all plugs are linked, via the pipe? 
attribute.

this allows you to normalize the values amongst all piped nodes. 
 since, you can redefine that plug, like any other.

Ok...  So, what's the difference between a pipe and a link? >;)

to tell the system what node to allocate, you preset the pipe-server-class 
in advance, so it knows what kind of pipe you want.

Yeah, I figured that last part out.

linked nodes will ask their "subordinates" about their values... 
this starts a recursive chain reaction, until all subordinates of 
all subordinates have cleaned up.

but no two values may intercommunicate.

plugs may be filled with data directly.  when you do this the node 
becomes a container, and this effectively turns off all of the linking 
management..

your plug simply stores a value and returns  it (but purify IS still 
called on it)