World: r3wp

layout compose/deep [button "Hello" with [(load at mold :things 14)]]

Dumb solution, but it works.

>> third things
== [item-type: something]
>> type? second third things
== word!
>> things/item-type
== something
>> type? things/item-type
== word!
>> type? things/item-type: to lit-word! things/item-type
== lit-word!
>> third things
== [item-type: 'something]
>> type? things/item-type
== lit-word!

yes

I vaguely remember some sort of hack I worked with Compose to come 
out with the correct result on item creation but I may very well 
be mistaken.

I've done the mold+load trick as well Henrik. I've also taken the 
block from THIRD and changed each word type to lit-word.

  change-each w third things [either word? w [to-lit-word w] [w]]

thanks, Gregg. I'm assuming now there is no truly quick way to do 
this.

henrik, the trick is to keep them as lit words:

make object! [
    item-type: to-lit-word 'something
]

Have there been any efforts to standardize on IPC methods?

Not that I'm aware of, other than me bugging Carl about it. I've 
used a number of different methods myself (files, local TCP ports, 
tuplespace).

Graham - what do you mean by IPC? Rebol task to rebol task?

IIRC r3 architecture counts on it, and there should be ipc:// scheme, 
or I think I saw something like that proposed :-)

Yes, rebol process to rebol process

are rebol's words stored as a linked list? also, where are rebol's 
datatypes stored? is there a value in front of every value that is 
the datatype? is the datastructure stored in a separate place to 
the values themselves? how does it work?

No one is really saying, Nick. It's a part of the implementation 
that may change at any time.

Some clues have surfaced over the years in discussions about "slots" 
(search for [REBOL slots] for more links:

http://www.rebol.org/cgi-bin/cgiwrap/rebol/ml-display-thread.r?m=rmlKVVC

Can anyone explain exactly what random/secure does?

Does this help?  http://www.rebol.net/cookbook/recipes/0019.html

My belief is that  /secure is like /seed except much the algorithm 
is far stronger.than the /seed algorithm.

what does strength mean here? the number of times between two identical 
outcomes?

dunno.

/secure provides its own seed. Theoretically, that seed is less guessable 
than the sort of things we are likely to think of in mezzanine code 
-- like time/precise.

But we don't know for sure. All we do know is that with /seed we 
can provide the same seed and get the same series of random values; 
while with /secure if is not so easy.

So, /seed is used for replicating issues ...

That's what I use it for, anyway. Try this and see the effect:

loop 5 [random/seed 100 print "start of new series" loop 5 [print 
random 100]]

Well, wait, the cookbook example from Carl starts with a   random/seed 
now   before calling the random/secure code.  So I'm confused.

I think that may be so he can later _remove_ the /seed and have secure 
numbers once testing is complete.   Look at the *bad* effect of starting 
with a seed in my example:

loop 5 [random/seed 100 print "start of new series" loop 5 [print 
random/secure 100]]

Compared with:

   loop 5 [print "start of new series" loop 5 [print random/secure 100]]

change the seed!

Or do not have one when using /secure, and expecting /secure to work!

I usually seed with a precise time value

so, random/seed now looks okay to me

Graham, if you ever (ever) need to do that under win98, you must 
be careful, because time precision is much lower there.

Umm... not sure if my stuff runs under win98!

hence, you can get the same value, if you do it again after 1/10th 
or 1/100th of a second.

just so you know. :-)

what do people do to create a UUID?

This is what I am doing .. hope it's okay!


make-uuid: func [ pid ][

    form checksum/secure rejoin [ "" random/secure 10000000 form now/precise 
    pid ]
]

where pid is the id for the customer in the crm

I think it's OK. I use:

checksum/secure random to-string now/precise


Never had a duplicate with that, but I would want a fast one for 
performance built into REBOL.

But, just in case of duplicates, you need to write that to a file.

If the value already exists on that file, try again. Repeat until 
a unique number emerges.

sunanda and when there is a million values?

Hmm... mine is already time based.  I doubt my hard drive IO is faster 
than that!

As an experiment I tried a plain 'checksum on now/precise, because 
I wanted a shorter numeric ID that a user could type in. On 5000 
users there were 3 collisions, so.. no good.

The question to ask is not:

-- how would I ever get duplicates (you'll easily find that out when 
something goes wrong -- it's called debugging).
Instead ask:
-- how damaging would duplicates be?

If very damaging, then make sure your system is robust -- not simply 
that it looks so.

the only problem arises if the pc clock is set back.

Or if the clock gets stuck!

but then I synchronize the user's clock to NIST time at the start 
of the session.

The only way is to generate a stupid long ID to reduce the likelihood 
of a duplicate by a factor of... astronomical.

I know lots of people use UUIDs for database records .. wonder what 
their algorithm is.

I don't .... I use an autoincrementing field ... but think in retrospect 
I should have used UUIDs instead so I can merge databases

There are a lot of ways to do it. Some people use the GUID API on 
Windows. Some use a high-low model, kind of like you are by including 
the PID. Combining clock (with setback checking), counter, machine 
info, and a key (like PID), is plenty good.

Noticing that many people use two words to time things, I made a 
little timer function.

time: func [s] [
    t: now/time/precise
    if do s [now/time/precise - t]
]