AltME groups: search

I suggested REDUCE/into and COMPOSE/into, and found them to be immediately 
useful. I don't know why UNIQUE/into is being suggested, its use 
case.

Henrik had a use case for DEDUPLICATE, though that was when he thought 
he could eliminate the copy, and actually wanted to change UNIQUE 
to be modifying instead. It's not a common enough use case to make 
it into the core functions, but there is a mezzanine for it in the 
CureCode ticket.

REDUCE/into and COMPOSE/into were actually worth adding

 - no problem with that, what I was saying, though, was something 
 else

well IIRC Steeve had done tests and it was much faster... so something 
is being saved.

it was so that new memory didn't need to be allocated in this expression, 
and the old didn't need to be garbage collected:

b: reduce b

About the /into refinement.

I don't bother if internaly, a copy is done or not, while it's faster 
and memory safe (the block must be freed immediatly not by the GC) 

The GC used to have some memory leaks and was reacting too late to 
be useful (especialy in apps with a GUI).
I now it's better now (thanks to recycle/ballast).

Sounds interesting. I know that CHANGE/part is the real fundamental 
operation, but that needs an additional parameter and would require 
renaming the option - /into isn't an appropriate name for that operation. 
But I don't think it would have been implemented in that case, and 
having it be a direct CHANGE would definitely not have been accepted 
because /into is mostly used to replace chained INSERT and APPEND 
operations.

The downside of the /into option is that you have to be careful when 
using it or your code won't be task-safe. Your multiple references 
to a block that can change scenario is an example that can quite 
easily lead to task-unsafe code, for instance. But /into is great 
for micro-optimization and local code simplification, as long as 
you are careful to not modify shared structures without coordinating 
tasks.

for the record (for the other people reading, which might not be 
as fluent in the more low level aspects of the core)..


I just want to note that your comment about thread safety doesn't 
only apply specifically to the /into... 


It applies to *all* series usage in REBOL 3 since they are mutable 
and MANY functions modifiy series "in-place".


Other languages always copy on assign so its not as big an issue 
as in REBOL.

I can paste from the browser to notepad, and other apps, and it's 
just text, but .... the clipboard shows empty.  The problem will 
go away if I reboot though.

Correction, I can write to the clipboard:// and paste into other 
apps, but Rebol is seeing nonthing there.

I was just copying from Chrome's address bar .. and also writing 
to the clipboard using core.

What OS and what REBOL version?

Interesting, and very good to know.

Could be as simple as a change that tried to handle errors better 
and now fails for some reason.

started up view 2.7.6, pasted to clipboard and can't read in 2.7.7 
again.

And thanks to Ladislav for PIF/CASE.

Ah, I missed the negative sign, and forgot that Rambo did that.

Yes, I wrote PIF, and inspired Carl to write CASE, I guess. Later 
on, I renamed PIF to CASE for compatibility. (and because CASE is 
a better name than PIF)

graham, I've been using 2.7.7 for a while and have never had any 
issues with the clipboard.   I am running xp though, so its possible 
that something in windows 7 is causing this.

Hi, did somebody also notice the speed difference between Vista and 
7 as below?

Benchmark run 27-Aug-2009/16:16:06+2:00. Rebol 2.7.6.3.1
Computer: 100Mega Athlon II X2 250/4G DDR3
OS: Windows Vista 64
Precision: 0.05
Empty block: 104000000.0Hz

Eratosthenes Sieve Prime (size: 8191): 54.0Hz, result: 1899 primes
Four-Banger test (+,-,*,/): 150000.0Hz, result: 10.0

Integral (icount: 10000) of sin(x) 0<=x<=pi/2: 42.7Hz, result: 1.00000000000003

Integral (icount: 10000) of exp(x) 0<=x<=1: 60.2Hz, result: 1.71828182845896
Merge Sort (500 elements): 68.4Hz

Benchmark run 4-Oct-2010/17:00:19+2:00. Rebol 2.7.7.3.1
Computer: 100Mega Athlon II X2 250/4G DDR 3
OS: Windows 7 Professional 64-bit
Precision: 0.05
Empty block: 131000000.0Hz

Eratosthenes Sieve Prime (size: 8191): 69.0Hz, result: 1899 primes
Four-Banger test (+,-,*,/): 188000.0Hz, result: 10.0

Integral (icount: 10000) of sin(x) 0<=x<=pi/2: 49.7Hz, result: 1.00000000000003

Integral (icount: 10000) of exp(x) 0<=x<=1: 74.8Hz, result: 1.71828182845896
Merge Sort (500 elements): 90.4Hz

(I checked, that the speed difference between 2.7.6 and 2.7.7 is 
not that big)

I am wondering what is the simplest method to implement the Touch 
function in REBOL? Is there anything simpler than to append one character 
to the file and remove it again?

and how it does it.

why not just alter the time of the file .. .and if it doesn't exist, 
then create the file?

There is: Touch a file and get its time

Now that I think about it .. my NAS box has that problem .. I copy 
files to it, and the file dates are in the future because the box's 
time runs fast :(

And it doesn't work in R3 for some reason?

Doing open/binary and it works.

Universal except that is corrupts binary files and will be very slow 
for large files. I don't know if you can be universal, but you can 
get close:

touch: func [
    {touch the given FILE}
    file [file!]
] [
    file: open/seek/binary file
    append file ""
    clear tail file
    close file
]

You just need to remove /binary for R3.

Ladislav: also, I think OPEN without /DIRECT will actually read the 
file and then write it back, so it's no different from Geomol's solution 
actually. Gregg's /SEEK/BINARY (actually I think /SEEK implies /BINARY) 
should work better.

And performance memory issues on large files.

So, I need to send seme emails and need to login into my SMTP server. 
And this mostly fails out-of-the box in Rebol 2 and I can't remember 
what to do to make it work:

>> send [robert-:-muench-:-googlemail-:-com] "Test"
Net-log: ["Opening" "tcp" "for" "esmtp"]
connecting to: mail.saphirion.com
Net-log: [none "220"]

Net-log: {220 mail.saphirion.com ESMTP Exim 4.63 Sat, 09 Oct 2010 
12:12:46 +0200}
Net-log: [["EHLO" system/network/host] "250"]

Net-log: {250-mail.saphirion.com Hello mail.saphirion.com [10.0.0.3]}
Net-log: "250-SIZE 52428800"
Net-log: "250-AUTH LOGIN CRAM-MD5 DIGEST-MD5"
Net-log: "250 HELP"
Net-log: ["Supported auth methods:" [login cram]]
Net-log: ["MAIL FROM: <[robert-:-muench-:-saphirion-:-com]>" "250"]
Net-log: "250 OK"
Net-log: ["RCPT TO: <[robert-:-muench-:-googlemail-:-com]>" "250"]
** User Error: Server error: tcp 530 Relaying not allowed
** Near: insert smtp-port reduce [from reduce [addr] tmp]


I think the probem is that Rebol isn't logging in correctly. Either 
it doesn't understand the supported methods or something else is 
different. Any ideas how I can fix it or track it down?

Sorry I forgot to decompress the message:


I have no problem sending from an ESMTP account from Rebol after 
setting the account name and password with set-net:

You could possibly get this message if you are not directly connected 
to the ISP hosting saphirion.com.

I found this explanation helpful :

http://www.answersthatwork.com/Download_Area/ATW_Library/Networking/Network__3-SMTP_Server_Status_Codes_and_SMTP_Error_Codes.pdf

And in R3, it will bypass the setting of locals with funct

and in R2 using the r2/forwards

And in R3, it will bypass the setting of locals with funct

 - in R2, as well as in R3, when using the SET function, you bypass 
 the collection of object locals. In R3, with FUNCT, you may not bypass 
 the collection as follows:

set [a: b:] [1 2]

Didec, i have the same results than Peter with the A49.
And what you're saying is not the problem i pointed.

See, there something strange with the number of evaluations done.

>> dp [loop 1000000 [pick t x + 1]]
== make object! [
    timer: 517292
    evals: 4000011
    eval-natives: 2000004

>> dp [loop 1000000 [t/(x + 1)]]
== make object! [
    timer: 350263
    evals: 3000011
    eval-natives: 1000004


So the conclusion is that evaluating a path don't  follow the same 
scheme than a block evaluation.

arg yeah rebol plugin is important and it's a bad thing if people 
considers it as a malware T__T

BrianH ... when what screw the fucking browser statistics is the 
fact 95%  of computers are wndows based and 100% of them comes with 
IE ...

but that doesn't means I use it (I use chrome, opera and firefox)

and unless the web gets replaced by rebol, the plugin will always 
be more important to "the industry" I mean, to get others to use 
rebol in THEIR environment.  which is the biggest weak spot of rebol. 
 it is Hermetic.

you can't tell a company that invested several years to start over 
from scratch.  it has to be able to migrate without changing the 
habits... rebol has to sink into the other model first, then slowly, 
if it worth it, people will start putting rebol in the center and 
eventually, something like rebrowse can replace the current framework 
or maybe even live besides it while the migration takes place.

I've suffered of trying to get rebol INTO companies and it never 
works.  there is too much ground work to do, it costs a lot of money.

yes we can :P YES WE CAN :P and i'm sure all of them will really 
like to do it ;P

like Lua .... but ppl will say but Lua already do it and it's better 
damn people ...

Ever tried to use rebol in a company that has only .net, python, 
or java code?  good luck.  it takes weeks before you can use most 
of the DB stuff they have built up, because there are sooo many modules 
out there, and they have huge frameworks, which actually DO more 
stuff than rebol .  rebuilding those libs is not even always possible....

the /skip in many functions are implied records... and the reason 
they are there... not getting the record as a return values... is 
an oxymoron IMHO

The R2 method is much more flexible. The R3 method is identical to 
"first select/skip", and I doubt there would be that much gained 
by having a specific alternative function for the R3 method.

I tend to use FIND and SET [w1 w2 ...]

Maxim, yes. I'd say that if every single REBOL function used /SKIP 
consistently, you could do flat block databases and rely on /SKIP 
without getting your records screwed up.

I noticed something weird too. If you have multiple R3 windows open 
and switch between them, does the window title change?

The window title thing seems to be related to marking up text in 
the console and is not caused by R3. Never noticed that before.

I would really like the /skip to be consistent as "implied fixed 
record" it would make flat record management and "explicit" feature 
of REBOL.

Let's say that modifying functions should error out if the block 
is there would be data corruption (just SORT, I think), but retrieval 
and builder functions should act like the series is none-padded.

Maxim, it was decided that for R3 the bounds of a series were more 
of an implementation detail, not an error. A none in the middle of 
a block is considered the same as a none off the end of a block. 
That is why the ordinals (first and such) act like PICK now.

I  usally use none as a no-value/don't care/error especially since 
I use ANY/ALL a lot, but for records, none and missing data are completely 
different.

We are taking the SQL attitude towards none, that none and missing 
data are the same thing. This lets us use ANY and ALL to deal with 
missing data no matter where in the series it is missing from.

We are really consistent in treating none that way, which is why 
map! values of none don't display and are skipped.

This makes a clear distinction between none and unset:
- None is missing data where missing data is OK.
- Unset is missing data where missing data is probably an error.

I agree, since its now consistent everywhere, we can expect the reaction 
and know that when its important, we must check instead of relying 
on an attempt or try to catch it.

And ANY instead of COALESCE :)

its like reading... there is nothing here and here too  hehehe  I 
see none like a portable hole (remember in bugs bunny ;-)

Not the same thing. If you have skip > length of the series, it will 
only do one iteration and your access to the results off the end 
will usally be none, unless you constrain it yourself. The question 
is whether negative skip should be silently constrained or generate 
an error, as a general rule.

yep... not the best for the math in index calculations.... hehehe 
but much more human readable for code and human interaction, so I 
still prefer one indexing after 9 years... even if the techy in me 
sometimes lets out a little <sigh>  in trying to get to the proper 
start/end of complex series extractions  hehehe

well, I just realised that it should do the exact same as for the 
end... if you are not currently record  aligned  and are doing reverse 
operations, its possible you'll encounter incomplete records at the 
start.f

so fill with nones. to prevent the start of the records to shift 
and corrupt the first record.

in reality there should be something between 0 and 2  if "23" was 
to keep its alignment with its original position within the series.

with this detail in place, and with blocks, I'd say it would be usefull 
to pad with nones.

Give me a moment and I can answer your concerns.

I have difficulcy to get Chat files. I do nf, to list new files, 
then I submit get * but nothing is synced. I try other aproach, going 
to e.g. R3 mezzanines section, and doing get * does either report, 
that there was no change to files, or that my local copy is changed, 
and hence it can't be synced. I am sure I did not do any local changes 
here ... So - how do you usually work with Chat file facility?

Situations like that are why DevBase and chat are integrated now.

OK, Maxim, the MOVE/skip example you specify is not an error in MOVE, 
it is an error in the code calling MOVE in that example. MOVE was 
specifically designed to do something useful in that case, rather 
than generate an error.


The whole reason that MOVE takes one position and one offset is because 
that limit gets rid of a host of potential aliasing errors. MOVE 
is designed to be the most efficient and safe solution to the problem 
of moving stuff, and it should *never fail* unless the series is 
protected from changes. MOVE is a DWIM function: Do What I Mean. 
This goes for treating negative /skip lengths as an error too - having 
it magically constrain the /skip length to 1 or greater was a deliberate 
design choice, the result of a lot of discussion.


So the question is whether the error of having /skip lengths being 
less than 1 is worth worrying about, worth the overhead of generating 
an error and checking for that error every time you use the function. 
Don't be fooled, that overhead is really significant.


We've already changed other functions so they don't generate errors 
anymore, and just DWIM, like FIRST not complaining about bounds and 
acting like PICK 1 now. These changes have made these functions faster, 
and better to use. Generating an error is considered something to 
do when it is really important, as it sometimes is. How important 
is the /skip < 1 error?

you have been talking about the actual /skip parameter value, and 
all along I was talking about the effect of using /skip which causes 
the function to go outside of bounds of the series based on the skip 
size... 

doh!   hahahaha

and I understand that adding too much verification to series handling 
code really slows the whole a lot.

The problem is that DIFFERENCE/skip < 1 generates an error, and every 
other function /skip < 1 hangs. So the question is whether they should 
*all* be changed to act like MOVE (silently DWIM), or all be changed 
to act like DIFFERENCE (generate an error).

No, RETURN, EXIT, BREAK, CONTINUE and error throws are just as slow 
in R3. It's the setjmp/longjmp exception frame overhead.

Progress milestones:

Single graphics engine
VID3.4
Unicode
Tasks
Modules
Built-in chat system
Built-in open source management

Completely redesigned ports (fully documented and ready to use, you 
protocol writers)

When finished:


Fixing almost every deficiency that R2 has through 10 years of use 
by expert developers.

Gabriele - why not? The chat system is more powerfull than that of 
AltME, and I find AltME usefull, although it has its limitations. 
Once we create GUI for it, it will allow for some nice simple IM 
stuff. Why do you think SlashDot ppl would have problem with it?

At least don't call it a "chat system" without the description "direct 
hotline to the main developer", as that line would stand out and 
make people think it's a joke

So far, R3 tasks don't work properly and should be considered a placeholder. 
We can't do a proper task model until there are changes to the basic 
semantics of REBOL. Fortunately most of those changes were done in 
the last month.

and almost all skip bugs too

It's good for speed and memory saving, and better binary conversions. 
Once we have vectors, we will have less people complaining about 
the lack of rebcode, except for the people who never take good enough 
for an answer :(

And yes, Carl marks the native changes as done in CureCode the moment 
he gets a working build. I mark mezzanine changes as pending as soon 
as they are submitted to DevBase, then as build when they are released.

so we can do array transformations in REAL TIME for things like polygons 
and 3d objects  :-)

Ones that aren't as huge either, and that can be accessed through 
a C API.

now if we can be the go-between things like these libs and opengl 
.....   :-D  can you see where I'm going ?  we already have a dataflow 
engine which could act as the kernel for managing when updates need 
to occur, and all rebol is doing is the whiping, while the grunt 
work is done by the various libs out there  ...

Re: #744. They no longer crash but the "launched" script uses the 
same console session as the original script so keyboard input and 
screen output gets mixed up. This is different from the behaviour 
under Windows where R3 opens a new console session for the "launched" 
script.

The following session shows that launch does not effectively run 
a script as a separate process and return immediately.

>> ans: "yes"      

== "yes"

 >> do [ while [ans <> "no"] [ans: ask "(l)aunch, yes or no ?" if 
 ans = "l" [launch %launched.r]]]
(l)aunch, yes or no ?l
Checking for rebol.r file in /Users/peter/Desktop/Rebol3/
Checking for user.r file in /Users/peter/Desktop/Rebol3/


Evaluating: /Users/peter/Desktop/Rebol3/launched.r

launched script
Do you want to continue running the launched script?yes

yes

Do you want to continue running the launched script?yes
yes
Do you want to continue running the launched script?yes
yes
Do you want to continue running the launched script?no
no
(l)aunch, yes or no ?y
(l)aunch, yes or no ?y
(l)aunch, yes or no ?no
== none

The source of %launched.r is:

REBOL []

print "launched script"

ans: ""
while [ans <> "no"] [

   print ans: ask "Do you want to continue running the launched script?"
]

I'll mark it as tested then, and we can post any tweaks to the behavior 
as new tickets.

I checked call on Windows and it doesn't work either. I opened ticket 
757.

and returns none

Could you post system/options from R3 on Mac? Just run R3 and type 
in system/options

Encapping is going to be different in R3, as is the console. It is 
intended that a graphical console will be developed, and callable 
from any graphical host. Hosts will be the new encapped apps.

Similar to R2, though the errors start disarmed and need to be armed 
with DO. CAUSE-ERROR wraps this.

The reason why is because people didn't understand that '+ was for 
unsigned, and '- was forr signed.

why + was for unsigned and not the reverse? :-)

I don't work at that level of REBOL. So we now have vector! datatype 
mostly fixed. One thing I don't understand is, that we are heading 
for performance, and then we can see minimum-of and maximum-of becoming 
mezzanines. The other thing is - what now? What is now available 
at practical level? What can we do with vector! type?

They can be mezzanines and still be as fast because FORSKIP is now 
native. Making the looping functions native makes REBOL faster overall. 
One thing people don't get is that mezzannes can be really fast in 
R3.