World: r3wp

??
 sounds like a good addition.

Regarding integer64!, wouldn't it currently be possible to fake it 
with float! to pass them around to bindings?

I think it should work.

+1 for "??"

I guess someone can contribute that to github, no need for me to 
write it? ;-)

FEAT: added `print-line` function to runtime, with `??` as alias. 
Works like `print`, but adds a line-feed character at end.
 

https://github.com/dockimbel/Red/commit/82099d117e790859606697c33f90c35ef87cf5b6

Just imo, but:


1) hmm, I am with oldes - if there is 99% case, where you want your 
"print" to print including the newline, it follows REBOL rule = most 
used case goes first

2) There is nothing wrong with following REBOL compatibility, especially 
if we claim, Red is inspired by REBOL. So 'prin and 'print worked, 
new user would learn their stuff

3) If Red itself will have some REBOL compatibility, I would expect 
both 'prin and 'print there. Now imagine, how messy the translation 
is going to be: print -> print-line, prin -> print ...

it's not a big deal for me, so regard it being just my opinion ...

As Doc is a guru here, the final decision is of course upon to him 
:-)

There are going to be quite a few differences between Red and REBOL, 
anyway. It's a fundamentally different language. You can't expect 
to run REBOL programs unchanged, except in incidental cases

I used to be of the opinion that REBOL clones should be compatible, 
but Red is not a clone, REBOL itself is incompatible between R2 and 
R3, and REBOL in general is fading into irrelevance

Pekr: you should really make the distinction between Red and Red/System, 
they don't have the same goals. People currently coming to Red/System 
are usually C coders, not REBOL-only coders. Things like "PRIN" might 
give a negative feeling on the language design, and it would be a 
pity, because PRIN is not my idea/choice, but Carl's one. At Red 
level (when it will be available), we'll have a wider compatibility 
with REBOL, so to ease the transition for rebolers, PRIN will be 
there (but maybe just as an alias).

Well, that does not mean, that what worked for REBOL is not worth 
to consider for new language, which is syntactically similar to REBOL?

BTW, I don't like much the "guru" word, I prefer "leader" or "lead 
developer".

Just a question: did you have the feeling that PRIN was somehow a 
weird choice when first learning about it?

I still have that feeling every time I see it

I don't remember anymore. Not liking the word much, as well as another 
funct, func, etc.

I am just sure, if there is going to be so much of a distinction 
between the Red/System and Red itself. I think I am well aware of 
the difference. But - why would anyone use Red/System, without wanting 
 to use Red, which will have some compatibility level?

To a lesser extent, I had also a weird feeling with FUNC word, but 
it vanished rapidly, I'm very used to it since years now.

The distinction between Red and Red/System is almost as big as between 
REBOL and C.

I accepted PRIN the first time I saw it, just going "oh" and memorized 
it for what it did. I don't agree that Red being a fundamentally 
different language means that you must rename trivial functions. 
That just means there are more differences to learn.

that's it - you just get used to it. Now imagine your source code 
- if Oldes is right, then 99% of time you are going to see print-line, 
instead of print, in your source code. Well, it depends how often 
do you actually print :-)

It's a more common way of abbreviating than leaving off one letter. 
Still, I changed all my FUNCs to FUNCTIONs in Red/System

Red/System is aiming at being a dialect living inside Red, for system 
and bare-metal programming.

I accepted PRIN as well... and as I said, it's usage is really rare. 
I would prefere PRINT to do line break.

Doc - yes, but as I said - will there be many users, using just Red/System, 
not using Red, and vice versa?

Everyone will use Red, some library developers or system programmers 
will also use Red/System.

If not, the mindset is closer than you might think. If someone is 
going to use only Red/System, which you claim being closer to C than 
Red, than such person can just use - a C :-)

I will not use print-line for sure:)

You have ?? instead. ;-)

But - as Red/System is mostly out of my scope, I will acept any decision 
...

Also, it's too early in the project to be nitpicking, you'll have 
plenty of time for that when Red will be out. ;-)

Will some alpha Red come in 2012?

That's what I said -not an important issue, I just wanted to state 
my opinion, that 'print, if used in 80+ cases with new line, should 
do so :-)

Do you want to use ?? in RED as well? Because as Pekr said, it will 
just cause confusion... I have enough problems not to write TRACE 
instead of PRINT :)

There are other ways of looking at it. For example, code is read 
most of the time rather than written. PRINT-LINE is very clear for 
reading

Another view is that a very small audience of REBOL programmers is 
used to PRIN. The big audience for Red is people that don't know 
or even dislike REBOL

Kaj - yes, most of ppl are used to print, which will almost not be 
used, as it does not print a newline - that is also another point 
of view at it :-)

By most of people, you mean REBOL people

yes, because most Red/System users, are going to be also a Red users. 
Red/System is not for C ppl, that is an illusion imo. Why would anyone 
C oriented would like to use Red/System, if he/she would not also 
want to use Red later? :-)

REBOL itself is incompatible between R2 and R3
 - counterexamples:


- my INCLUDE is a complicated script that is working in both environments, 
i.e., the compatibility surely isn't "incidental" in your own words

- the core-tests suite is working in both environments as well, containing 
more than 3000 interpreter tests

Do you mean that's proof that R2 and R3 are compatible?

What else should be?

Well, now I restrain ... I am most probably not going to be a fluent 
Red/System user, so I don't want to influence such a decision, if 
other ppl feel differently about the topic ...

I'll have to refer you to Boolean algebra

Also, I didn't say "incidental" about R2 and R3, I said it about 
Red and REBOL

Well, I can describe more compatibility examples like Brian's backward 
compatibility library, but I think it is absolutely unnecessary having 
mentioned the common interpreter core tests. However, I am curious 
how is that related to Boolean algebra?

Your statement seems to be that R2 and R3 are compatible. Examples 
cannot prove that. Counterexample falsifying that: for my CMS of 
towards 4000 lines, although I wrote it in basic R2 to avoid porting 
issues, I had to make extensive changes throughout and a number of 
alternative functions and wrappers to get it to work on R3

The other way around, there are web sites I can build correctly on 
R3 but not correctly on R2

To put my two cents in: I disliked PRIN the first time I saw it, 
and I still dislike it everytime I have to use it, 10+ years later.