AltME groups: search

Yeah, it is on the list, I call it the Knock Knock feature.  The 
way it works is people can actually sign up before even getting into 
AltME from a website if they want.

Reichart -- glad to hear Altme is being actively worked on.  I'd 
got the impression from an earlier message of yours (on REBOL2, maybe) 
that Altme was what we used to call "functionally stabilised" (ie 
dead as a development)

Now about some interim releases? Create a sense of progress and momentum.

Ammon, yeah, I agree.  We are slowly locking down what I call a "pattern 
language."  In other words using the same UI parts the same way everywhere.

I think of communication software a little differently (in general), 
so I will share this.  

Read states

 (like the Red we are talking about) are a very interesting issue. 
  


Most computer software does a very poor job of replicating empirical 
or visceral conversations.  Email for example has a method of describing 
the "direction" you are speaking.  TO: Bob, CC: Carry.  Where the 
TO: indicates you are speaking directly to Bob, and that Carry is 
standing somewhere to the left or right of you.  BCC is someone hiding 
behind you. 


Email could have an interface where you first pick the people in 
the "room." And then use something like a 2D interface to move the 
listeners around a symbolic version of you.  This would be both silly, 
time consuming, and somewhat confusing, but you get the point.


What you have read and what you have not read though has a similar 
analogy.   There are thousands of sub states and markers people use 
to sort things they have read, will read, need to read again, need 
to respond to, etc.


In Box, Out Box, Papers upside down, putting papers you need to sign 
under your car keys on the floor in front of the door leading to 
the car, etc.


I have one friend who re-wrote some open source email program to 
have some huge number of states and then some simple filters.  It 
works VERY WELL, if you know his system.  He never forgets anything.


So the current model AltME has (right now) is a very simple interface. 
 Tantimount to "Have I ever seen this before."


We are playing with some other models in Qtask, which may get adopted 
into AltME.  I'm working on a system I call Venn Chat.  Some features 
include:

Have I read this before? (like AltME)
Mark this:  

Follow up (add to a list of messages you want to think about more)
Note (All should read this when they come into the group)
All Must Read (converts it into an AltME-like alert)


Convert to a task (and keep the context of the chat in place, this 
is opens up a whole other area)
Branch (something like forum threading)
Re-file (move from one group to another)

Re-post (copy to another group, at the same time, similar to branch).
Trigger (tell me when someone has finally read this).
Status (tell me who has read this so far).
Attach (files, links, etc)

Reichart, I like your ideas.

I would guess that one of the goals should be to pick a 'realm of 
inclusiveness' (I don't know what else to call it).

i.e. If AltMe is suppose to be fashioned as a message-logger then 
these 'new messages' should be flagged until read.

However, if AltMe is suppose to be fashioned as a meeting-place then 
maybe 'new messages' should only be flagged after you log in.


Now, don't get me wrong here.. I am not saying that messages shouldn't 
show up at all, I am stating that their container wouldn't be flagged 
(red).

just found a nasty bug!    if you call browse 5 times in any of the 
rebol view beta versions, rebol crashes.

There is a workaround: call unview, then rate restarts to stop :-)

Ok, probably tomorrow. Perhaps someone else has some comments. I 
simplified yet further to remove the    pFunc();    call.

3130 Bug: On Linux, CALL interferes with TCP port wakeup, 3159 Bug: 
Linux: system port interferes with TCP ports

using it for some hours to do remote calls thru tcp, works. did not 
work with older rebol. IMO fixed.

3326 Bug: CALL should accept file! datatype
does it now (linux)

favourite bug - the one where an encapped application is unable to 
launch another instance after it does a system call

With rebview 1.2.102.4.2 (linux) im getting sometimes this during 
startup -> 
..
..
...
Type "desktop" to start desktop.
WARNING: CALL function enabled in this version.
To see most recent beta changes, type: changes?
>> REBOL console error (1)
REBOL console error (1)
REBOL console error (1)
REBOL console error (1)
REBOL console error (1)

Wow. I read the call for bugs, I check my favorites to see if they 
have been fixed, I submit one to RAMBO that was half-fixed a while 
ago. Two days later, there's a new build (104) that fixes my bug 
(3685). This is the quickest bug fix I've ever experienced from REBOL 
Tech. Bravo!

#3737 (call and file! datatype) : same problem on Win2k. The error 
message is right, it's a path problem - but if it works with string!, 
it should work with file!. A workaround :
call clean-path %prog.exe

and that normal becaus in C to initialise data I will use a malloc 
call witch will attrubute to a and b on the same based type different 
memory location

Ah, this looks like a cgi-stype call. i would try --cgi then. it 
should do this "call and get data from stdin".

Thansk for the wakeup call ;-)

I would call this the Rebol Vault.  or in short   REVAULT which ties 
is very nicely with the REBOL itselft.

Member's Lounge call it Member's profile

maxim that's too easy to say that sunanda runs the things alone and 
that's the reason why rebol.org sucks ... when did sunanda call for 
help never ... when did he try to motivate people hating his website 
like me to participate. Last things my remarks about rebol.org are 
common sense. And they were made vastly in 2005 when it opens and 
when people style gived a damn. 6 years later rebol means nothing 
NOTHING it's lower than scrub and the recursive lack of work her 
killed rebol and any  initiative around it. Not only each time something 
cool is done in this community  Carl comes with a great announcement 
to ruin the effort but the  promise he makes never come to a reality.

I don't see a difference between [ [] [[]] ] type nesting and what 
is currently used...I see that what you call "containers" are what 
the /  \  tags are doing.  Are you saying you prefer the scanner 
to die if the input is "illegal" than trying to proceed with it anyway?

without the recursive call to parse

Maxim: if you're guessed right on the access denied issue, you should 
be able to fix it by addind a few 'wait 0.01 to the 'do-handshake 
function. Put one 'wait just before each call to 'read-packet and 
if you have time do some tests.

Re: MySQL Auth.   IIRC  http://dev.mysql.com/doc/mysql/en/old-client.html
I think we used this option "Tell the server to use the older password 
hashing algorithm" and continued without a house call.  If that does 
not work, let me know and on Monday I will ask the programmer who 
did it what did work.

in write-packet, there is part, where he simply sends passwd and 
calls 'scramble on it ... scramble decides upon protocol V9 or V10 
version, and calls crypt-v9 or crypt-v10 accordingly, those two call 
hash-v9 or hash-v10 ....

if you look into scrambel(), they use sha1_reset, input, result function 
calls, which is imo equivalent of rebol using ports - opening, inserting, 
copying the result ... all this is also equivalent to checksum/secure 
"my-string" .... but, in one place, they call sha1_input two times, 
and I dunno what it does mean ...

however:


if you look into scramble(), they use sha1_reset, input, result function 
calls, which is imo equivalent of rebol using ports - opening, inserting, 
copying the result ... all this is also equivalent to checksum/secure 
"my-string" .... but, in one place, they call sha1_input two times, 
and I dunno what it does mean ...

imo Carl just decided to call it /secure and that 'sha1 was added 
later, dunno ...

I think, that with "my" latest version, I now only need to distinguish 
authentication mode ... and to call scramble-long accordingly ....

Great Doc!
I didn't believe you'd ever call a version worthy of 1.0 ;-)

That's why we call this "Open Source", which is not the case for 
Rebol.

Hybrid open source I call it.

I got following under my Fedora Core 1 Linux, when trying to run 
cgi, with rebpro (when run only in -c mode, I got only REBOL - Security 
violation). Am  I able to call librarie under CGI?

[[root-:-linux] jablunkovsko.cz]# ./index.cgi
REBOL - Security Violation
./index.cgi jablunkovsko.cz]#
** User Error: SQLite near "100": syntax error
** Near: make error! reform ["SQLite" error]

you can't call it CGI if you run it from the console can you?

Well, you don't ... rebol does not support sending email using sendmail, 
but

if you have a version with command-shell support ( call ) you can 
probably create the command line to call sendmail yourself ... I 
don't know how to do this, though.

CALL was freed for use in unlicensed Rebol/View some time ago.

rebol way 
 a: " " 
call/output "set" a
probe a

you can always use call directly

DocKimbel once told me, that with his R#, encapping is so trivial, 
that he even hesitates to call it a product ;-)

is blitting using just new/faster routines, or has in anything in 
common internally with how fast you can enter event loop (time wise), 
to call 'show?

As long as there is a glossary that let's you translate from familiar 
terms, I think you're OK using REBOL's native terms, though they 
were foreign to me when I started.

Window or dialog?

 Or Screen or Form or Layout. A Dialog is usually something other 
 than the main screen in an app. You sometimes need to use all those 
 terms if you're speaking in the domain of an application, so use 
 wha'ts appropriate in each context. 

Face or graphical object?

 Or Control or Widget. Tough call on this one. I was used to Control 
 from VB, and Face confused me as it could be a layout as well. I 
 like distringuishing between layouts and controls. Hmmm Maybe a hierarchical 
 tree.

Facet, attribute, property or descriptor?

 I like either Attribute or Property. I can live with Facet in REBOL, 
 it's shorter, and it makes sennse if you think in terms like "let's 
 discuss this facet of the business". 

Style, widget or template?
	Style, definitely.

same for anim adding to the feel a recycle call after the show face 
will stabilize the memory usage

after some play on forwar/backward icon-button I get 7600 ko of allocated 
memory without  any recycle call ...

How does this line work?
	| set arg word! (

  either in widgets arg [append-widget widget: arg] [attribute-color: 
  get arg]
	)


append-widget checks for 'widget but 'widget is set after the call 
to 'append-widget


Further, in the parse-rule the above line comes last. But it parses 
the widget words. When do the parameters get parsed? I would have 
expected this rule to be the first after the keyword rules.

the only thing you needs to change is the modulo call "modulo i 2" 
can be replaced by "i // 2"

Mike, I started using Apache and rebol as cgi, this is not suited 
for performances as on every call to the cgi, a new instance of rebol 
is  initialized, run and closed.

I thought about using fastcgi, but never came to a working solution.
Now I use uniserve as main webserver, here some advantages:

-it is fast! On my local machine I get +- 600 req/sec for static 
pages and a max of 160req/sec for dynamic rsp pages

-it is written in rebol, I could easly(less than 10 lines code) add 
a rewrite engine

-child process are persistent, this mean you can keep state of your 
web applications, implement caching, keep a pool of connection to 
databases open (in apache + rebol/cgi you'd have to open and close 
the connection for every request)
-it is written by Dock whom I may be the biggest fan ;-)

btw I'm running an unreleased version (have bought commercial support) 
 that support http 1.1, stuff like If-Modified etc..

If you have more specific questions, I'll be glad to try and answer.

something called runit exists AFAIK. But i never understood what 
the advantage in regard to rebol is. i can just write a testscript 
and call it?

foreach file scripts[ call/wait file ]
and in each script:
 echo on
 print "Test1"
 ..
-> report

So we can call it RebSAX approach :-)) ?

Balancing the detail of the events against the function-call overhead 
of the language may be appropriate. One advantage to SAX-like apis 
is that you can register handlers for certain events and ignore others 
you aren't interested in, making your code even more efficient.

We have done a little in Qtask.  WE save the tasks as XML (and call 
it XLS so that Excel can load it).
We will be writing an RSS reader soon.

All works, "read/custom url reduce ['POST query-string]" did the 
trick! Thanks guys.

My little 64 line script now does the following:


 1) Read Address Book vCard file and extract a list of number/name 
 pairs (I prefix the numbers with 'n to assist with lookups)

 2) Read each Linksys SPA942 IP Phone's call history and create a 
 sorted list of number/frequency pairs

 3) Join these 2 lists and create a query string for matches and an 
 exception report for numbers without an address book entry
	4) POST merged and updated name/number pairs back to each phone


Script took 2 hours to write and debug, runs in 2-3 seconds and gives 
us the features of an advanced call management facility for free. 
Once again, REBOL to the rescue (my business partner shook his head 
when he saw this and just said, "but HOW can REBOL do all this???").

I usually creat myself a new function which calls make and the  object 
init (wether class or prototype based)  if that init needs to create 
new inner objects, then its responsible for doing so.


in your case the make-xml-object  could accept an xml string and 
then call make-xml-object recursively for each element it finds.

Also it's probably possible to use parse instead of the recursive 
function call, but it's working for me so I will stay with this one.

I meant to do a call for papers/presentation abstracts earlier, but 
have been busy, the time is still good.

It is already a time to do a call for papers/presentations to build 
up publicity, and to do a press release, which gives plenty of time 
for it to google up.

If it is decided to do, then first press release could be one for 
call for papers, not naming exact location, only the name, then when 
a location decided, a second press release. (just wanting to throw 
some ideas from last years experiences)

Find me a language that make it shorter ! (except a phone call, that's 
just 12 number ;-)

reason: first of all, the devcon is for rebolers first, others second. 
second, we need speakers, otherwise there's no point in having other 
people coming; if we have no speakers, then let's just make a "meeting" 
or "party" or whatever you want to call it.

I want to visit a Cash-Machine and "not" see the blue screen of dead 
but "Please call Carl, init.r is missing"..

Pekr yes, external library call can solve it (partially). I have 
to install some C/C++ SDK and start to learn it again...

That which we call a siren, by any other name would sound as sweet?

im going to port it to R3 tomorrow and rely on Call to play sounds

that is the set of proto functions - those string manipulation functions 
- you do use them everywhere ... even in graphics ... you have face, 
which has pane (container), and you insert, append, find, replace 
another gui elements, and then you call 'show ...

R, and you call it "SafeWorlds!"

denismx, when I've taught REBOL to people, even people who are already 
familiar with other programming languages, it has been helpful to 
make the distinction between the REBOL language and the dialect engines.


REBOL is really a data model and related syntax, and a bundle of 
library functions that manipulate data in this model. A dialect is 
really a semantic model for interpreting this data, like what people 
think of as a language in real life. A dialect engine is a set of 
library functions that think of the data in the same way - I know 
this sounds anthropomorphic, but it makes it easier to explain REBOL 
if you think of the different dialect engines as entities that are 
acting on a set of commands you are giving them. You can even use 
role playing to demonstrate this, having one of your students act 
out the part. It also helps to name each of these models after the 
main function that implements them - otherwise people might not get 
the distinction between them and REBOL as a whole.


There are some functions that only deal with the REBOL data model 
and don't really do anything with the data other than translate it 
from or to some concrete syntax. It is best to group these functions 
by the syntax they implement - the group that implements what people 
normally think of as the REBOL syntax is LOAD, SAVE and MOLD.


When teaching REBOL dialects I usually start with what I call the 
DO engine, what people normally think of as the REBOL language. DO 
is a stack machine like Forth, but it uses a prefix syntax to make 
it easier to use (by making DO dialect code more resemble that in 
other programming languages). DO also does a simple swapping hack 
to implement inline operators, which you will have to demonstrate 
so that your students will understand DO's operator precedence or 
lack thereof. DO always works on REBOL data: If you pass it a string 
or file that contains REBOL syntax code, DO will call LOAD to convert 
it to REBOL data - this is an important distinction to make so that 
your students can distinguish between the data and the processor 
of that data. There are many functions that depend on DO to interpret 
their blocks of "code", such as IF, WHILE, FOR, etc. It is important 
to note that these are just functions, not "syntax". DO's only syntax 
is the predefined operators that DO swaps (these are effectively 
keywords because of how the swap is implemented), the word/set-word/get-word 
difference, the interpretation of paths and the precedence of parens. 
Everything else is a function.


There is also the PARSE engine, a rule-based recursive-decent parser 
with limited backtracking, that implements three dialects (simple 
parse, string parse and block parse). These dialects actually have 
keywords, as well as an entirely different execution model. Also, 
there is the View engine, which implements the LAYOUT and DRAW dialects.


Refering to these engines as state machines isn't helpful, because 
the distinctions between their execution models, or whether they 
even have execution models, is important for distinguishing between 
them. You need to use the higher-level terms like stack machine, 
composition engine and such.

I hope this helps!

A couple questions:

- Are the exit and return opcodes still implemented with setjump/longjump 
?

- Is there still a plan to enable rebcode procedures to call other 
rebcode procedures, other functions? Or do we just use the do opcode 
for that?

Actually, when I think about it, the flexible function call syntax 
of REBOL would be a bit of a slowdown to implement directly in rebcode. 
All of the operations now are fixed in arity and known ahead of time. 
One way to get that same predictable behavior in rebcode is to put 
the call in a block and assign the result - coincidentally this is 
the syntax of the do opcode.


Another way to do this would be to add something like an APPLY opcode 
with three parameters: A result param (word!), a function param (word! 
| path!) and an arguments param (word! | block!). This opcode would 
pass the arguments to the function (perhaps with refinements) and 
assign the result to the word provided. This would allow the higher 
order programming that would otherwise be awkward - the do opcode 
could be used for traditional function calls. If necessary, the operation 
could be split into two opcodes: APPLY for function values assigned 
to a word, and APPLYP for a path literal or value assigned to a word 
- whether to do this would depend on which was faster.


Another awkward thing to do in rebcode is getting and setting values 
through indirection, like the get and set natives do. Those seem 
like a really basic operations that should have opcodes assigned 
to them rather than having to resort to do blocks. I'm just thinking 
of the basic get/set word assigned to word scenario, not the more 
advanced object/block stuff.

Gabriele, you might want to change the compose/deep call in the rewrite 
rules generated by rebcode-define to compose. The current version 
might trip up makers of rewrite rules, like it does in your first 
example rule above in the (either paren? ...) clause. Let any further 
composition be up to the rule makers, just in case they actually 
need to use parens themselves.

Qtask uses a Rebol version of AJAX (we call it Comet).

but still, dom interface is weak, no? otoh we don't need full rebol 
version of dom, js has one, so via do-browser we can call even dom, 
right? :-)

Anyway, I'm giving ajax (or I don't know how to call it, because 
it's not ajax, it's just a httprequest) next try with this modified 
function:
	function getXMLHttpRequestObj(){
		var ajx;
		if(window.ActiveXObject) {
			if(_XML_ActiveX) {
				ajx = new ActiveXObject(_XML_ActiveX);
			} else {
				var versions = [
					"MSXML2.XMLHTTP",
					"Microsoft.XMLHTTP",
					"Msxml2.XMLHTTP.7.0",
					"Msxml2.XMLHTTP.6.0",
					"Msxml2.XMLHTTP.5.0",
					"Msxml2.XMLHTTP.4.0",
					"MSXML2.XMLHTTP.3.0"
				];
				for (var i = 0; i < versions.length; i++) {
					try {
						ajx = new ActiveXObject(versions[i]);
						if (ajx) {
							var _XML_ActiveX = versions[i];
							break;
						}
					}
					catch (e) {}
				}
			}
		}
		if(!ajx && typeof XMLHttpRequest != undefined) {
			try {
				ajx = new XMLHttpRequest();
			}
			catch (e) {
				return null;
			}
		} return ajx;
	}

I've been telling people foy years to get a machine for work and 
a machine to trash for games etc.

Because if they call me (as they often do) and say "I've broken my 
only computer by downloading a game and now I can't get it to work 
and I've got to do something important" they get zero sympathy and 
I'm pretty dis-inclined to lend a hand in fixing their crisis.

You could call it Open Spec though.

wrt simplyfing the use of "noise"  ... why not just call compose/deep 
by default within the 'execute call of the client on ALL sql calls? 
 it could be a global option and IMHO the use of parens within the 
code is quite obvious and is used in many dialects. and its less 
cumbersome than to add the reduce word in your code, a string and 
then variables out of context of the sql statement.

hello, i d like to know if its possible to call db.r script from 
an encaped program.  It says that core 2.6 is needed and if i try 
to remove the security it fails.  what i try to do is the following 
:
rebol []


#include %/C/Documents and Settings/xavier/rebApps/spikes/mezz.r;

#include %/C/Documents and Settings/xavier/rebApps/spikes/prot.r

#include %/C/Documents and Settings/xavier/rebApps/spikes/view.r

test: request-file
write %test/param.par test
do to-rebol-file read %test/param.par
probe db-select * patients
ask ""


in this example the file u are supposed to point is db.r.  When it 
s not encaped it work, not when it is.  if someone has an idea ...

the advantage of those protocols is that they call sqlite.exe, so 
even no /Pro users might be satisfied ...

Antont - it can't be easier to fix, as it is a binary file .... I 
really like old unix mail format, which nowadays uses mozilla/netscape 
- plain text files - that is what I call easy to fix ...

While testing I started a script using sqlite several times, at about 
the 17th call I get this error:

** Script Error: Library error: Max Callbacks
** Where: context
** Near: sqlite-trace: make routine! [
    db [integer!]
    clb [callback! [int string!]]
    ptr [integer!]
] SQLite3lib

I'm using the following version:

	Title:		"SQLite driver"
	Owner:		"Ashley G. Trüter"
	Version:	0.1.3
	Date:		22-Feb-2006

clear buffer

 is also an optimization as it defaults to 32K values (make block! 
 1032 * 32) and I don't won't to reallocate it each SQL call. The 
 following benchmarks (Transactions Per Second) give some backround 
 to the design decisions I made:

	buffer				1744718
	copy buffer			282
	copy/deep buffer		76

	clear buffer			1144733
	buffer: copy []			824352
	buffer: make block! 32768	387


So the approach I took optimizes for large result sets by allocating 
a large buffer once up-front and then just referencing it thereafter.

0.1.5 available at: http://www.dobeash.com/SQLite/sqlite.r

Changes of note include:


 - New /format refinement of CONNECT that formats output like MySQL 
 (can be turned on/off via SQLIte/format?: true|false)
	- Widths block (SQLite/widths) added to supporrt above

 - DESCRIBE, TABLES and INDEXES functions rewritten (and simplified)
	- Added an EXPLAIN function

 - CONNECT rewritten (note that the attach refinement has been replaced 
 by the function accepting a block! of file names instead)
	- DATABASE function added

 - Experimental IMPORT function added (but not exported to global 
 context - see example for how it is used)

 - Error trapping / reporting more informative (especially if a library 
 call error occurs)
	- Example block updated (do example)

Documentation will be updated as time permits.

I got an error in the 'sql func ...


** Script Error: length? expected series argument of type: series 
port tuple bitset struct
** Where: switch
** Near: *bind-text sid i val length?

the database is opened with /direct refinement.

The call is:
	sql ["select * from person where guid = ?" guid1]


Where I know, that the dataset with this guid exists, because I have 
just got it from another selsct.
The dataset contains only strings, some of them empty.


Well, this is it: ["h-o-h.org_20060326_182311691_1224" "Urte" "Hermann" 
"Urmeli" "" "" "" "" "" "" "" "" "" "" "Opera ID: 359" "" "" ""]

And I am using the right guid.

Any ideas?

That's why we call them domain specific languages .. they're not 
for everyone, right!

if you ever change something interactively and wish to recompute 
the layout (cause the sizing needs have changed for any reason) then 
call refresh on any face or group.

sometimes you'll need to call refresh on the window itself, cause 
the new/old faces will change how the whole tree of groups measure 
up against each other

wrt the slim word... you can rename it in the slim.r file if you 
really want to... but its your call.

ah... just wanted to announce a little milestone of liquid useage 
 :-)   In the current instance of liquidator, event handling and 
window refresh have been successfully decoupled  :-)  this means 
I can refresh based on a timer, instead of based on input events... 
 so I can now properly scale interactively of the view based on its 
weight without even removing one event from the view  :-)


you'd say... but we can already do that... well not exactly... yes 
 you can prevent the call to 'show in your mouse handling... but 
can you prevent the whole processing occurence when you are interactivally 
editing an item?  hehe .


because of liquid's lazy computing, the actual processing is delayed 
until needed, and the show will only occur after this.   so I can 
call update 30 times a second, and it will still only call show when 
things have realy changed, inversly, I can change the data 100 times 
a second, and only the real number of calls to update will actually 
cause a data refresh of all dependent data which changed (like the 
draw block :-)

and thus, even if you change any input node's values or link new 
stuff to node_c... none of that will actually call any processing, 
untill you ask for the content of  node_c

applying this to a gui driven with liquid nodes, you could freeze 
the the whole layout on a modal window... and let your inputs continue 
to process in the background... updating animation, and reacting 
to async reads... for exacmple.


when you unfreeze the gui and call a refresh of the gui plug, all 
the data which was being processed in the background, is now automatically 
available ,as if nothing had been frozen and a simple update of the 
node, will refresh you gui with nothing to manage.

max... i've been studying liquid and how it can be used (or not ;) 
in vid+ (or vid2 or vid3 or whatever we want to call it)

my conclusion is the same as nenad's... it's overkill :) i think 
i can do all that users need to do with just event handling. that 
is, recognizing that in the ui everything is about events. the system 
does not need a network, just direct "links" between elements (call 
them widgets, styles, etc).

just thought I'd share this list I built while coaching someone in 
using liquid last night...

SANITY PRESERVING KNOWLEDGE WHEN USING LIQUID:
--------------------------------------------


#1:  liquid isn't a bully  - liquid shares its state, but asks for 
data (pulls, observes, etc) from its subordinates ("parents"), not 
the other way around (it doesn' push or force feed, like a highly 
inneficient signal messaging engine).


#2:  liquid is lazy by default - unless a plug or one of its observers 
 ("children") is stainless, nothing will process automatically (thus, 
faces usually are set to stainless, so that they refresh automatically).

#3:  liquid has several computing modes in a single base class.  
  * linking is for once sided dependencies
  * piping is for inter-dependencies or synchronisation
  * containment is for data storage
  * linked-containment is for processed data storage   


#4:  liquid mutates - plugs automatically change computing modes 
when you call some methods like linking, piping and filling.  depending 
on the order of these operations, a plug may "stick" to its previous 
computing mode.  e.g. a piped node remains piped, even you attempt 
to link it to something.


#5:  liquid is alive - remember that as you are setting up a liquid 
network, your plugs will start receiving messages as you are building 
up the tree, meaning that the process() (and other) functions might 
be triggered before every expected connections are done. always verify 
the integrity of the data before starting the process.  (i just got 
stumped by this one again, 5 minutes ago).


#6:  liquid is a collection of droplets - each plug should do one 
thing or manage one step of a process.  the more you break up the 
network, the better you will be at making it stable, reusable, flexible, 
and fast.


#7:  liquid is highly memory efficient - !plug uses shared classes. 
 so all the liquid operations are in a sub-object called a valve. 
 Thus, when you call internal functions, remember they are within 
the valve, and you must supply the plug as its first argument.  my-plug/valve/stats 
my-plug


#8:  liquid is volubile - its slim-based verbose & indented console 
printing engine (vprint) is YOUR BEST FRIEND.  use it profusely, 
to understand the chain of events and what the hell is going on.

SANITY PRESERVING KNOWLEDGE WHEN USING LIQUID:
--------------------------------------------


#1:  liquid isn't a bully  - liquid shares its state, but asks for 
data (pulls, observes, etc) from its subordinates ("parents"), not 
the other way around (it doesn' push or force feed, like a highly 
inneficient signal messaging engine).


#2:  liquid is lazy by default - unless a plug or one of its observers 
 ("children") is stainless, nothing will process automatically (thus, 
faces usually are set to stainless, so that they refresh automatically).

#3:  liquid has several computing modes in a single base class.  
  * linking is for once sided dependencies
  * piping is for inter-dependencies or synchronisation
  * containment is for data storage
  * linked-containment is for processed data storage   


#4:  liquid mutates - plugs automatically change computing modes 
when you call some methods like linking, piping and filling.  depending 
on the order of these operations, a plug may "stick" to its previous 
computing mode.  e.g. a piped node remains piped, even you attempt 
to link it to something.


#5:  liquid is alive - remember that as you are setting up a liquid 
network, your plugs will start receiving messages as you are building 
up the tree, meaning that the process() (and other) functions might 
be triggered before every expected connections are done. always verify 
the integrity of the data before starting the process.  (i just got 
stumped by this one again, 5 minutes ago).


#6:  liquid is a collection of droplets - each plug should do one 
thing or manage one step of a process.  the more you break up the 
network, the better you will be at making it stable, reusable, flexible, 
and fast.


#7:  liquid is highly memory efficient - !plug uses shared classes. 
 so all the liquid operations are in a sub-object called a valve. 
 Thus, when you call internal functions, remember they are within 
the valve, and you must supply the plug as its first argument.  my-plug/valve/stats 
my-plug


#8:  liquid is volubile - its slim-based verbose & indented console 
printing engine (vprint) is YOUR BEST FRIEND.  use it profusely, 
to understand the chain of events and what the hell is going on.

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?

the pipe server thus serves as an in-between.  the fact that its 
also a plug makes it very flexible, since you can call the purify 
function on it.

I really do worry about conference a bit. No proper activity/propagation, 
call for sessions. The only one session so far is Carl's R3 introduction 
.... Hopefully it will all come ...

like your skype call :)

yes, but then i say, we meet, and allow others to see video stream 
(worked well in France), and call in via skype (just need to make 
sure we have a pc with skype set up ;). 100% virtual is not even 
1% of the fun. ;)

Call for topics and presenters placed in the checklist.
Sent out an email on the mailist to inform and gather input:

Dear Fellow Rebolers (of the mailist faction),


There has been some interest in a virtual gathering of Rebol developers 
and users. These discussions have been taking place in the Rebol3 
Altme World. I know there are many here that do not regularly go 
there but nonetheless would be interested in participating. The date 
and time that has been looked at is December 27th from 12:00 PM. 
How does that sound to you?


There has been no decision on the technology to be used but you're 
input would be much appreciated. We are also in need of presenters 
and/or desired topics.

To summarize, we are looking for:

An agreement on the time and date
Topics desired
Presentors
Ideas for technology to be used
Other

rebol [
	title: "explore.r"
	version 1.0
	date: 2009-03-19
	author: "Maxim Olivier-Adlhoch"
	copyright: "2009(c)Maxim Olivier-Adlhoch"
	tested: "win xp"

 notes: "Add any dir to the dirs block.  options are self explanatory"
]

dirs: [
	%/C/ []
	%"/C/program files/" [expand]
	"%tmp%" [label "temp dir"]
	"" [ label "my documents"]
]

blk: []

explore-dir: func [path expand? /local cmd][

 call/shell rejoin [" explorer " either expand? ["/n,/e,"]["/n,"] 
 path ]
]

ctr: 1
foreach [item opts] dirs [
	ctr: ctr + 1
	expand?: found? find opts 'expand
	label: any [select opts 'label to-local-file item]
	append blk compose/deep [ 
		pad 20 
		(to-set-word setw: rejoin ["dir" ctr]) check (expand?) 
		pad 20 

  btn 200 left (label) [ explore-dir to-local-file item get in (to-word 
  setw) 'data ]
	]
	append blk 'return
]


view layout compose [across vtext right "expand?" vtext "folder" 
 return (blk)]