AltME groups: search

Only add fork that time as this is a three-way Brian chat.  :)

Has anyone ever detailed the voodoo of caret escapes in strings?


^^^{   does not return ^{  as I read it should.  It's ==ing as ^^{, 
but I'm not sure if this a post process of the == result display. 
 ??  Seems like voodoo.  And instead of exploring, I'd rather just 
read something this time.

I'm debugging my debugger right now. For some reason it does not 
log certain lines of debug information. The method I use is:

write/binary/append %debug-file.r string


By probing it in console, I get the correct output, but the same 
lines are always missing in the disk version. Would there be any 
time this write would not occur?

I think I know what the trouble is - it's not easy to know whether 
a host OS rename can support move or not. Therefore rebol can't choose 
beforehand between rename and copy+delete.

A workaround to that might be to try the rename first and see if 
it works (does not return an error message), but that adds complexity 
and performance problems. It could be done once at rebol startup 
in a temp directory, though it still seems a bit messy.

(The real solution seems to be to go back in time and define POSIX 
rename and move properly.)

I had hoped to be at any time able to identify the running script 
by filename

It is currently impossible to determine the filename of an inner 
script unless you have stored this information somewhere. For that 
matter, if there is an error in a script, you would only be able 
to get the name of the running script. If the error is in a function 
created by a script that is used after the script is finished executing, 
there is no way to determine which script the function came from 
without storing that information somewhere ahead of time.

yeah and run that every time a script is renamed and perhaps also 
when an enduser gets a hold of the script. nope, it's too errorprone. 
I can see this won't be fixed, but I still think it's a missing feature. 
gotta go spend a couple of hours fixing this. :-)

I use it in TRETBASE to define the datatype of each respective field. 
 It saves time and performance cost.

Maxim once mentioned that he spent a lot of time sandboxing his Elixir 
engine.   iirc, he was confident enough to let it be open to random 
code.

In your version, the syntax error was at load time, before the attempt 
was called.

PeterWood, you should definitely try MOVE. We were very careful to 
avoid the aliasing and overlap issues that often happen with move 
functions; getting it right the first time was the whole point of 
its inclusion. :)

What's the best way to produce random passwords?


I have an algorithm, that use RANDOM. I figured, I would use seed 
to start the random generator like this:
random/seed to decimal! now/time/precise

to be sure, it starts in the most random way. In theory this will 
give the same result, if the routine is called two times right after 
each other, and the time didn't evolve meantime.

Maybe I shouldn't use seed?
How does REBOL start its random generator, when REBOL launch?
What does RANDOM/secure do?

We take several steps in various bits of REBOL.org system code to 
produce unique identifiers.

The code factors in not just now/time/precise but also things like:
-- user name
-- length? mold system
-- incoming IP address

But, ultimately, you cannot *guarantee* not to get an id clash that 
way. So (in cases where clashes matter), we also create a temporary 
file, id.tmp .... If that already exists, we generate a fresh id 
until we  get a unique one.   In the case of REBOL.org, the id.tmp 
files are deleted weekly, as a week old clash is not important.

Geomol, use RANDOM/SEED NOW/PRECISE (no /time and no to decimal!)

Gabriele, I'm afraid, that's not good enough. Try this:
>> loop 10 [random/seed now/precise print random 100]
28
28
28
28
28
28
28
28
28
28

While if I do it my way, I get this:

>> loop 10 [random/seed to decimal! now/time/precise print random 
100]
75
53
21
3
2
57
54
69
74
15

(I did it under OS X with version 2.7.6)

As I suggested above, if it is a webservice, you can use other things 
in addition to the precise time:
-- caller's ip address
-- referer URL

They will vary between calls -- unless exactly the same incoming 
URL is processed at exactly the same moment....That's unlikely, even 
if someone is resetting the server's time.

To illustrate my point, try create this rebol script (call it random.r 
or whatever) on you disk:

REBOL []

print random 100
ask "OK"


Now click it from the explorer in windows. I get the result 95 every 
time. That's not random!

Generate pools of passwords, and store a counter to use when you 
need to re-seed and generate a new pool. That way you can generate 
them over a long period of time and just pull them as necessary.

what happens if no random/seed is used in a REBOL program?


That same thing that happens with almost all random generators, which 
is a pattern is used.  REBOL has a starting seed value (unknown with 
out extensive testing).  However, it will (and should) have the same 
value upon start up.

The problem (you are perceiving) is with the word "RANDOM" 

Perhaps it should be called PATTERN instead.  


However, if seeded, RANDOM in turn will use a formula to generate 
more in the series.  This is indeed true random, in as much as the 
seed's size sets the size of the universe.


So, if you want to always have a random set, you need to get fresh 
random data (hmmm, I seem to recall mentioning this in another thread).


Of note, the RANDOM we use in slot machines is NOT like REBOL's random 
function.


REBOL's RANDOM (like most language random functions) is really SEED+OFFSET 
in a series. (thus a pattern).


I'm not sure what Carl did to make it secure, but my best guess is 
he is sucking in what ever he can find to make it Random (this doing 
what I'm suggesting in the first place).


For example, reading the mouse port, temperature, current time (to 
the jiffy), etc.  This would make RANDOM what you expected it to 
be in the first place…but in theory this would be slower.  In your 
case,  this would be the way to go.

I think, I should do, as I first suggested:
random/seed to binary! now/time/precise

before making my random password. If I put in a little wait, I can 
also make sure, I don't produce the same password two times in a 
row.

random/seed now/time/precise followed by an indeterminate number 
of
   random/secure to-decimal now/time/precise
or a few waits
will make it harder for anyone trying to guess your passwords.


But none of that guarantees you won't produce a random number you 
already have. If you need your passwords to be unique, you need to 
do one of several things:

-- check each one against all previously issued (as I've suggested)
-- generate a unique pool in advance (as Gregg suggests)


Both approaches introduce a potential security flaw: the table/pool 
of passwords is an attack point for a hacker.

Geomol, you need a single daemon to give you out random numbers, 
or, if you're on Linux, use /dev/random or something like that. to 
decimal! now/time/precise means that your numbers just cycle in 24 
hours, that is, i can easily predict what your password will be at 
a certain time of the day.

Yes, random/seed with a decimal doesn't use the seed:

>> loop 10 [random/seed 1 random/seed to decimal! now/time/precise 
prin [random 100 ""]]                                            
                           
52 52 52 52 52 52 52 52 52 52

So I need to construct an integer from the time.

This is misleading to me. I got the impression, that I could do
random/seed to decimal! now/time/precise
but that's no good! Should it be reported as a bug/flaw?

Does anyone know, that now/time show at midnight? Is it 24:00 or 
0:00?

try to switch you PC to 23:59 and do some loop which will print time 
:-)

A suggestion for an algorithm to produce a random seed from the time:


s: to integer! 2 ** 32 / 86400 * (to decimal! now/time/precise) - 
(2 ** 31)
s: enbase/base debase/base to-hex s 16 2
reverse s
s: to integer! to issue! enbase/base debase/base s 2 16
random/seed s

It does this:
1) convert now/time/precise to an integer using all possible bits
2) make a string of 0 and 1 from it
3) reverse the string
4) convert it back to an integer
5) And finally use it as a seed


Doing it this way, I hope to have a good span of possible start values 
for the random generator. Did I miss anything?

So this should be about as good:

random/seed to integer! 2 ** 32 / 86400 * (to decimal! now/time/precise) 
- (2 ** 31)

John wrote "It seems to be 1."


And this is probably correct from a social point of view.  But I 
will stick with "unkown without extensive testing" because many integers 
can give the same sequence, and might even give the same sequence 
for a long time before they diverge.


This is the subtle point I'm trying to make about what is random 
vs pattern.


Things that "seem" are the reason hackers crack codes…this is where 
I used to start when I cracked other people's systems…

My test show, that random/secure give the exact same sequence of 
numbers every time, if started with the same seed. Check it with 
code like:

>> random/seed 1 loop 1000000 [random/secure 10000000] random/secure 
10000000
== 1253129

>> x: 1 loop 10 [random/seed 1 loop 1000000 [random/secure 10000000] 
if 1253129 <> random/secure 10000000 [print x] x: x + 1]


So I conclude, that I can only make 2 ** 32 different passwords with 
this, not 60 ** 8.

that random/secure give the exact same sequence of numbers every 
time, if started with the same seed

 That's an intended feature ! You should set the seed only *once* 
 with a random (or pseudo-random) value like now/time.

So a way to get good random numbers over a long period of time, is 
to start such a routine (like the Mersenne twister) only once. The 
routine should then work with a high number of bits, the more the 
better and store the state, it has come to, to disk. Every time the 
computer is turned on, it can pick the state from disk, and start 
from where it left off. A password generator should use this routine 
and call it between each character in the password. If the routine 
has high enough resolution, it should be possible to produce 60 ** 
8 different passwords.

This is the randomize func I use, FWIW: Alan Parman did quite a bit 
of R&D and posted this as his best solution.

    randomize: func [
        "Reseed the random number generator."

        /with seed "date, time, and integer values are used directly; others 
        are converted."
    ][

        random/seed either find [date! time! integer!] type?/word seed [seed] 
        [

            to-integer checksum/secure form any [seed now/precise]
        ]
    ]

I installed R on my Mac more than a year ago, but haven't found the 
time to use it yet (or did't find the need). I've heard, it should 
be good at doing graphs.

I'm not fair using the word "ignorance". I don't think, you are. 
I base my conclusion on the following:


See the password generator as a black box, that you feed with an 
integer, and out come a password. The integer input has 2 ** 32 different 
combinations and is used for the random/seed. Out come a password, 
and there can only be 2 ** 32 different passwords coming out at most. 
It doesn't matter, how the algorithm is constructed, if you put time 
delay in, call random or random/seed more than once, etc, as long 
as you don't get other input as the first integer. This is basic 
in information theory. And it's related to the determinism in digital 
computing.

Given a good algorithm (like Mersenne twister), and a true random 
generator for seeding (like hardware sensors) a computer could cover 
the 60**8 range. A humain brain, even given enough time, can't (I'm 
talking about generating random combinations, not using loops to 
generate every single combination). Even worse, humain results would 
show heterogeneous distribution of results, while computer will give 
a uniform distribution. So in that case, computers would give you 
better randomness than analog brains.

A long time ago, I remember reading something where the author suggested, 
as a shared seed, using a substring of PI.

about 2 ** 32, that's a limitation of *your* algorithm, not RANDOM. 
indeed, if you don't reset the seed each time, and use random/secure, 
you probably get all of the possible passwords (and very likely more 
than humans would pick). besides, it is not proven that random/seed 
only takes 32 bits of data when seeded with a date!. (C rand() is 
most likely 32 bit, but random/secure could be using more than that.)

I don't know where you got that number from; If I remember correctly 
the first time you can get a problem with rebol file size is at 2 
^ 31 - 1

ahhh time to eat - be back in a few.

If it's a time critical app like a web server I'd go for speed ...

I use them all the time.

yes... jeruzalem time-zone:)

yes... it's every time... there is no timezone in windows settings 
as well for this zone

or the app has to be no timezone aware:) Don§t know what can takes 
less time to fix:)

Maybe it's because 0 is false in C so the native time format thinks 
there is no timezone

Don't presume, check. If you don't get the ack in time, timeout.

I knew this at one time, but is there a way to test if a word has 
been set / exists, that doesn't involve error trapping?

>> if error? try [n][print "error"]
error

Learn to bind knots with REBOL lecture one. ;)

I always have trouble with BIND. Maybe I didn't ever take the time 
to really get it. So much to investigate with this language. :)

Geomol, I was like that too, for quite some time, at the beginning. 
But... we can teach it to you !!  It's really a simple concept.

Geomol, yes the known word just defines the context.

I use two binds because there are two contexts involved - the h/q/1 
context, and the function's context. (Each time you create a function, 
a context is created for its locals.)

Geomol, when FUNC is evaluated, a new function is created, along 
with a new "function context", as we say. The words in the function 
body block are then bound to the new function context. There are 
only two words in the block, 'do and 'code.  So those are the only 
words affected.  This binding only happens *once*, at function creation 
time. It does not happen again automatically when the function is 
evaluated for the first time, or any time afterwards. Even if it 
did, it would not affect the block of words referred to by 'code, 
because, as I've said above, BIND does not evaluate words to check 
if they are a block so it can recurse into them. (If it did, that 
would have far reaching consequences.) Not having to rebind words 
each time the function is evaluated keeps it efficient.  If we want 
'foreign' code to be bound to a function's context so it can interact 
with the function's locals, then we have to do it ourselves; functions 
created by FUNC won't do it for us.

Did you mean: 
s3: load rejoin ["{" s2"}"]  ?
with s2 in the rejoin and not s ?

That seems to work and produce what I'm tring to get...

A little awkward but only two lines for what I want...

Thanks again,  Anton.


I can use this in the short time but I may need to just use SQLite 
or my own solution for storage as Paul is no longer developing Tretbase...

I need to form the date in UTC coordinates....  eg. 2008-10-25T08:33:0.4Z

Anyone got something more elegant than this?

form-utc: func [ d [date!]
    /local 
][
    ; convert to GMT
    d: d - d/5 
    rejoin [ 
        d/year "-" 
        either d/month < 10 [ join "0" d/month] [ d/month ] "-" 
        either d/day < 10 [ join "0" d/day ][ d/day ] "T"
        either d/time/1 < 10 [ join "0" d/time/1][ d/time/1 ] ":"
        either d/time/2 < 10 [ join "0" d/time/2][ d/time/2 ] ":"
        round/to d/time/3 .1 "Z"
    ]
]

as-utc: func [date] [
    if all [date/zone  0:00 <> date/zone] [
        date: add date negate date/zone
    ]
    date/zone: none
    if none? date/time [date/time: 0:0:0]
    date
]

to-ISO8601-date: func [
    "Converts a date! value to an ISO 8601 format string."
    date [date!] "The date to format"

    /T           {Use T to delimit time value, rather than a space}
    /no-zone     "Don't include the timezone"
    /local pad z
][
    pad: func [val /to len] [
        val: form val
        head insert/dup val #"0" ((any [len 2]) - length? val)
    ]

    rejoin [
        pad/to date/year 4 "-" pad date/month "-" pad date/day
        either T ["T"] [" "]

        either none? t: date/time ["00:00:00Z"] [   ;<< reusing 'T here!
            rejoin [

                pad t/hour ":" pad t/minute ":" pad round t/second
                either no-zone [""] [

                    either 0:00 = z: date/zone ["Z"] [  ;<< setting 'z here!
                        rejoin [
                            pick ["+" "-"] z/hour > 0
                            pad abs z/hour pad abs z/minute
                        ]
                    ]
                ]
            ]
        ]
    ]
]

format-10: func [ d [integer! decimal!]
][
    either d < 10 [ join "0" d ]
    [ form d ]
]

form-utc: func [ d [date!]
    /local 
][
    ; convert to GMT
    d: d - d/5 
    rejoin [ 
        d/year "-" 
        format-10 d/month "-" 
        format-10 d/day "T"
        format-10 d/time/1 ":"
        format-10 d/time/2  ":"
        format-10 round/to d/time/3 .1 "Z"
    ]
]

COLLECT will be back-ported to R2. At the time of the 2.7.6 release 
the function was still under discussion - now it is finalized. We 
only backport final functions. I'm thinking that FOLD will probably 
make it too :)

I think not. The only way might be to set start: now at the beginning, 
and then read it out somehow. If the process crashes though, you 
are lost. You could write it to log from time to time, to see, what 
was happening and when ....

How can I iterate over a range of IP addresses (looking for a particular 
response) and "time out" the ones that "hang". I've got something 
like:

ip: 10.1.1.0
loop 100 [
	rc: read join http:// ip
	if find rc ... [...]
	ip: ip + 0.0.0.1
]


This works great on most devices (IP Phones, Printers, etc) but hangs 
when it hits a computer with Stealth mode. I've tried read/no-wait 
but that doesn't seem to make a differemce.

Ashley think I did something like that a long time ago by construction 
a port! and then calling wait [port! 0:03] in a loop.

dont sort by name to don't try to be efficent and send to multiple 
names in the same domain as the same time  don't send spamy content

Yeah, these are separate emails only sent to one person at a time. 
And the content is just simple words (these are tests) and no symbols.

you mean time consumming ?

i give you a script i used to profile the ideal size of the buffer 
used with read-io to have the best perfs.
On my computer the best size for the buffer is 8ko or 16ko.

REBOL []
f: open/seek/binary %large.dta

foreach len [64 128 256 1024 2048 4096 8192 10240 16384 32768 65536 
131072] [

	f/state/index: 0		;*** Problème quand on emploie read-io :
					;*** apparement c'est un bug, par défaut l'index est à 1
					;*** du coup, le premier octet n'est jamais lu
	

 buff: make binary! len + 1	;*** Encore un bizarerie, si le buffer 
 a exactement
					;*** la taille voulue, read-io lit un octet de moins
	n: 0
	recycle
	t: now/time/precise

 while [0 < read-io f buff len] [n: n + 1 clear buff f/state/index: 
 f/state/index + len]
	print [len tab v: now/time/precise - t tab v / n tab n]
]

close f
halt

You need to print out the time to more precision.

each time you do a copy/part a new internal buffer is created, it's 
better to use always the same buffer. easy to understand.

more of that, the profiling script say that it''s faster to read 
16ko than 2 times  16 bytes

because each time you do a copy/part you create new buffers in memory 
which are not erased by the recycler so that you should consider

using always the same buffer especially if you do thousands and thousands 
access in one second

let me put it another way Steeve, I will not be reading more than 
16 bytes per request (because I don't need any more than that) and 
it isn't a 16  bytes segment that is next to another 16 byte segment 
really I'm moving back and forth all over the file to get 16 byte 
segments each time.

I do not think this is a bug, and it may not be trivial to fix it 
if it was (which means, it'll never get fixed as Carl is not going 
to spend that much time on R2 for something not important)

I think Maxim mentioned that he had done a lot of work when he sandboxed 
Elixir.  I didn't study enough of the magic Elixir to know how he 
pulled it off, but if it's Max, it's good and ahead of it's time.

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

/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.

I usually seed with a precise time value

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

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

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

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]
]

Historical?   start (set) and then end (report).    R3 has a dt (delta-time) 
function built in and some other nice profiling words.

I used simple randomized copy/part upon checksum/secure now/time/precise. 
Worked so far ...

The past few weeks I've had more time to devote to Rebol.  I'm working 
on some typical examples and routines to get aquainted with it.  
So I appreciate all the help I'm getting from this forum.  Currently 
just playing with the delete-dir function.

I'm not able to get this to work....is this even possible.....

in the environment: myPath = C:\myTemp

	myPath: probe get-env "myTemp"

 ....(tried several iterations of code here to fix the path perfectly)
	delete-dir myTemp

also tried reduce 

the path has been refomed to //%/myTemp/, %C/myTemp/,  and several 
others forms.

it says that it expects a dir argument of type: file url

Chris: I googled about what you said but didn't find any source, 
but interesting.. this stuff was running on amiga at the time :)

hm.. but why is it then called fifo if read needs to happen at the 
same time as write, I thought it's some sort of fifo (first in first 
out) stack/queue

It's not the insert that changes the litword to a word, it is the 
initial evaluation of the litword. By the time insert sees it it's 
already a word.

COPY "" is faster than MAKE STRING! 0 (amazingly enough), and you 
don't have to allocate a literal "" every time, just once at LOAD 
time

In R3  (R2 is a very small bit faster, but I guess its related to 
the console) :

>> t: now/time/precise loop 1000000 [copy ""] print [t - now/time/precise]
-0:00:00.203

>> t: now/time/precise loop 1000000 [make string! 0] print [t - now/time/precise]
-0:00:00.25

The other way around, Doc. Mezzanines are not slow. It all depends 
on what the function is doing. Most of the time any interpreter overhead 
is dwarfed by the work the code is doing. This is why REBOL can be 
so fast when do much of it is written in REBOL.

BTW DideC, if you use now/precise instead of now/time/precise and 
use difference instead of - then you don't have a problem around 
midnight.

I'm having a hard time producing code that reproduce the bug, if 
anyone can provide a piece of code that could stresstest [call] I'd 
be gratefull! 8)

Well, thanks for the offer, having Gab's Call script would save me 
some useful time. Anyway, I would rather prefer Carl to fix this 
issue. Carl maybe forgot, but all RT's customers are running on R2, 
not R3. The priority should be clear.

I made a post about 2.7.6 being near the end of life of the REBOL 
2 line.  I was told by Carl that I was mistaken ... completely.  
That was oh, 8 months ago or so.   At that time; REBOL 2 is still 
very much an RT supported product line and there are no plans to 
change that stance.

I'm almost ready with the lexer for Python's Pygments syntax highlighter. 
Just need to define the keywords.. All the time I do it I don't know, 
which one to choose:)

Anton: thanks for taking the time to test it.

I will experiment a little with this when I find time, thanks all

the initial offset  (which column)  the sort is on changes, but that 
is 
sort/skip/compare/part  ref1 span   column  ref2

Brian's concern is what does this sort do to ref5 and ref 6  position. 
are they still valid.

time to experiment

I presume it's recreated anew each time the create-template runs

(I participatted in this discussion already one time and it also 
seems consistent to me)

Paul: I think Brian or Henrik told that time that 'word is "active" 
something and rebol reduces it when encounters it in the same way 
as it would auto-reduce function a: get-two not assign it to a (at 
least that was my compilation of it that time :) )

It does sometimes but not all the time.

By the time LIT-WORD? sees the value, DO has already converted it 
to a word!, the way it is supposed to. LIT-WORD? works fine.