World: r4wp

works perfectly with 2.1.4

havent been looking at changes to zmq for a while now

but all of my python stuff works just fine with 3.2

AND i have pub-sub working between r2 and python

2.1.4 on r2, 3.2 on python

They made some awkward changes in the 3 series that I haven't reviewed 
yet

I'll probably switch to Crossroads I/O

hmmm - dont know that one
checking it out now...

Fork by the original developers

SUjoy, send me a reminder next week. I'm very busy the next few days, 
but have ported many of the 0mq guide examples. Mine use Andreas's 
binding, but it might still help.

Will do Greg...I saw on the zmq list that you were doing the peering 
example as well...super stuff

Found the underlying problem: I had the push/pull definitions the 
wrong way around

Fixed it and added the complete ventilator example:

http://rebol.esperconsultancy.nl/REBOL-2-ZeroMQ-binding

:)
i should have been able to pick that out

thanks kaj...downloading now

I only realised at the end, when no other possibility remained :-)

working with zmq3.2? i'm wondering if i should download and move 
up to 3.2
...though crossroads i/o looks very good

Better wait, I haven't adapted to 3.2 yet

ok. thanks again Kaj

I haven't followed crossroads too much. Is their i/o very different?

very similar from what little i've seen
they even have a libzmq compatability layer built in

only supports zmq 2.1.1 though

and will be deprecated

That makes sense. Forks happen.

I see that some folks use 'copy' on top-level bindings (i.e., foo: 
copy [], bar: copy "", bas: copy #{}). Is this simply stylistic (for 
consistency with initialisation inside of blocks) or am I overlooking 
a potential pitfall?

The pitfall is the copy trap.

and the copy trap may occur anywhere.

http://www.rebol.net/wiki/Forgoing_faux_pas#The_COPY_Trap

sure, but that example is inside a block

( f: has [t] [t: [] append t 1] )

i'm asking why (if) i should do:

rebol [] foo: copy []

instead of

rebol [] foo: []

it does not matter. it occurs anywhere.

If you use foo: [], you can.


There are perfectly legitimate ways to use the block that way. You 
should simply be aware of this fact, when assigning the word to that 
block.

so is there any reason for using copy at the top level (global assignments) 
with binding to literals?

(i.e., i'm asking about 'foo: [1 2 3]' rather than 'bar: [1 2 3] 
foo: copy bar')

i guess a related question is whether i'll run into difficulties 
with 'context [ foo: [] ]' versus 'context [ foo: copy [] ]'

(typo: 'with binding' should read 'when binding')

that again depends on how the word is meant to be used. if you use 
the context as a copyable prototype, then the original 'foo block 
will be re-used, if you don't copy it on creation of the context.

at the top level, there may not be a reason, but through various 
tricks, it's still possible that it may be relevant to copy it, such 
as if the code itself is later used in a context, which means the 
code is no longer top level.

if you don't copy it on creation of the context.

 => "if you don't copy it on creation of each new copy of the original 
 context."

hmm

maybe i'm misunderstanding your clarification, but i don't see any 
difference between copying the literal block: http://pastebin.com/L2Qx4djY

oops, 'when copying the literal block'* (sorry for all the typos)

hmm... I clearly remember it being not copied, but I seem to be wrong 
about that.

aha, it's the case for contexts inside contexts.

so is there any reason for using copy at the top level (global assignments) 
with binding to literals?
 - certainly, there are reasons. See these two examples:

; example #1
repeat i 2 [
    a: []
    append a i
    print mold a
]

and

; example #2
repeat i 2 [
    a: copy []
    append a i
    print mold a
]