World: r3wp

the function doing update could work as follows:

update: func [
    {updates the current application}
    application-file [file!] {the current application}
    tmp-file [file!] {a temporary file}
    source {updates from this source}
] [
    if exists? tmp-file [delete tmp-file]

    ; now we can rename the application-file, since the tmp-file does 
    not exist

    rename application-file tmp-file ; I guess, that this works, even 
    if the application is running?
    write/binary application-file read/binary source
    call application-file
    quit
]

rename works fine on linux. but you'll only need it for encapped 
programs. no trouble directly overwriting the currently running .r

I guess, that shadwolf meant it for encapped programs

shadwolf?

Ladislav, your update function won't work in Windows

The easiest way to do this is to maintain your source in an encrypted 
and signed compressed binary.  So, you have the stub which does the 
update and executes the source.  It checks for new source, overwrites 
the old one and then executes it.  Since it is not updating the exe, 
there are no file locking issues.

Ladislav, your update function won't work in Windows
 - as far as I can tell, it works even in Windows

Can you be more specific?

renaming won't work if there is a file lock on it

I tested it under Windows 7, it just works

Again, can you be more specific?

Hmm...  it does work!

Ahh.. but it locks the tmp-file instead

so what? that does not matter, does it?

so, to be sure you have to make sure that the tmp-file is not locked, 
or does not exist

yes

Well this is very interesting if this works.

consistently

So, the point is that you can't delete the running binary, and you 
can't delete it even if you rename it first, but you can rename and 
write a new binary in its place

you can even insert wait 1 at the start of the UPDATE function to 
make sure the old version is not running any more

well, you'd run update from within the old version, no?

yes, but you can even run it from the new one, if you are hasty enough 
;-)

hehe :)

quit/call

call it quits

I see, that this should have been in the SDK group, not here. Sorry 
for being off-topic

Just blame shadwolf !

yeah blame :)

i'm not talking about .EXE i'm talking about script

if it would have been asked in sdk people would had complain ... 
Ok straigh I don't care where I post  what is important is the answer

just noted that rebol3 conversion to binary! always results in a 
network byte order (big endian) binary!, irrespective of host endianness; 
which is nice

Shadwolf, for scripts, there is no file locking. So the process is 
much easier if you are getting and writing the new script, saving 
your data, shutting down and starting up with the new script (similar 
to what Ladislav's function is doing for exes). If you just want 
to reload the script in place in the current interpreter instance, 
you have to do the live state migration I mentioned above.

http://www.rebol.net/r3blogs/0326.html

Pairs as floating points

rebol.net is down fro me actually !?

fro=for

was down for me before

couldn't browse to any of the rebsites

same here for the past 10 hours at least.

working again now.

YEs

Ok, so there are going to be some issues about PAIR's that need discussion!

more than those you already noted ?

First, the math side of PAIRs as floats works out quite well.


However, there are some issues when converting to and from pixels, 
which are "quantized" as integers.

For example, now that:

>> 101x101 / 2
== 50.5x50.5

what is the size of this image:

>> make image! 101x101 / 2

?

Steeve, remind me, where did I note them?

You posted something on y

You just posted something on your blog...

And more interesting... tell me the sizes of these images:

  img1: make image! 1.4x2.8

  img2: make image! 1.000001x2.999999


So, if you understand floating point, you see where I am going with 
this, no?

Perhaps Ladislav can bring some insight to this issue?

yes, right, there is even some code assuming, that rounding occurs 
automatically, which ceases to be true...

yep I see