World: r3wp

I usually do that kind of thing like this:

objects: []
loop 2 [
	append objects make object! [a: 1 block: does [a]]
]
objects/2/a: 2
objects/1/block ; == 1 !

To me thats the typical copy-problem. i use 'copy in context-blocks 
too.
   make object! [a: 1 block: copy[a]]
In most cases it does not matter, as 'func copies too.
But when it goes wrong, its pretty confusing.

The only time it can get tricky is when sharing parse rules. The 
way I work around that is to encapsulate them in a shared object, 
but occassionally it can cause a problem (simultaneous parsing) that 
only copying can help with.

BrianH: nevertheless, you didn't tell me, when would the changed 
CONTEXT cause you any trouble and what kind of trouble?

Now that we have open/seek, is there some way to compute a check 
sum on a large file by reading it in part by part ?

Ladislav, I frequently use shared data in non-copied data structures 
that are referenced by many objects. This data isn't always in blocks 
- frequently I use hashes, lists or objects. These would be copied 
by your CONTEXT changes too, when my code expects them to stay the 
same. Lists and hashes are not affected by your rebinding problem 
- only blocks, parens and functions are rebound during object creation, 
because only they directly contain code under normal circumstances.


In the past I've found it easier to change the code that treats blocks 
as shared code ckunks into functions, or to make helper functions 
that create and initialize objects appropriately.

Hm this is strange

>> none and true
** Script Error: Cannot use and~ on none! value
** Near: none and true

Looks like 'and is calling 'and~

So perform some simple tests.

>> x: now/time/precise loop 10000000 [true and true] probe now/time/precise 
- x
0:00:03.39

>> x: now/time/precise loop 10000000 [and~ true true] probe now/time/precise 
- x
0:00:05.188

Hm, 'and is calling 'and~ but is faster than 'and~

BrianH: do you think, that you could give a simple example using 
MAKE OBJECT! that would break using the deep copying variant of CONTEXT?

Even better, if you have got such an example already in your scripts

TIA

I found that that running core on a AMD 64-bit box is not better 
than in a 3-year older 32-bit box. Should we expect a 64-bit core 
build ?

Not any time soon.

how do you know? :-)

logic!

>> true? logic!
== false :-)

RT has already stated their priorities viz OSX, SDK, and then IOS. 
 Since Rebol presumably runs already on windows 64 bit version, there 
is no pressing need to develop that product, and so it is logical 
to assume that it falls in priority after all of the above.

well, no news on OS-X for how long? One month? Things really go way 
too much slowly .....

However, since Carl released the Genesi PPC Linux version  just recently, 
I guess it also true to assume Carl does not act logically !

:-))

well, it is surely easier to port Core than to port View ... that 
might be the reason?

Do you mean, do the easy things first and leave the hard stuff to 
later?

If so, I don't think that's a recipe for success.

not sure ... but maybe Genesi sponsored some of Carl's time and convinced 
him it might be important for them to have Rebol ... then Rebol for 
Genesi might be an enabler ...

once again we are here to ask ourselves, if open-source would not 
speed-up things significantly ...

speed is not RT's priority, but ensuring a successful company is.

hmm, that does not have logic at all? How you want to be succesfull, 
if you are not able to fullfill your plans for one year? What from 
last year's plans got actually released?

I can tell you the truth - if there would not be 1.3, I would not 
be with rebol already ... and ppl at ml were right - 4 years to wait 
for View update? I hope it will not happen again ...

fortunately we are seeing updates at regular intervals.

genesis - this medical firm is in search for an os, isnt it? its 
small, efficent, amiga-like? and ppc is a good embedded processor? 
Just thinking loud :)

I recall AMD was a big RT customer (using IOS for intranet, documentation, 
...). This would make the case for x86_64 core

What's the logic! in this ?

>> true: all [ false ]
== none

>> false
== false
>> all [false]
== none
>> true: all [false]
== none

I mean, should all [ false ] return false ?

instead it returns none.

>> ? All
USAGE:
    ALL block

DESCRIPTION:

     Shortcut AND. Evaluates and returns at the first FALSE or NONE.
     ALL is a native value.

if there is nothing before false... what's there to evaluate?

returns at the first FALSE

>> all [ true false ]
== none

>> true and false
== false

yes, if it's equivalent of AND, that makes sense

>> all [1 2 3 4 5 false]
== none
>> all [1 2 3 4 5]
== 5

but:

>> 1 and 2 and 3 and 4 and 5
== 0
>> 1 and 2 and 3 and 4 and 5 and false
** Script Error: Expected one of: integer! - not: logic!
** Near: 1 and 2 and 3

well, the behaviour of 'all confuses me.

it doesn't make too much sense as a shortcut AND.... it makes more 
sense to say that it returns a value unless there is a FALSE or NONE 
in the block