World: r3wp

Regardless of whether it's RED or R/S, it's highly counterproductive.

I find a code with preprocessing TERRIFIC, AWFUL, and TERRIFYING. 
It slows down compilation to orders of magnitude.

#include must be replaced by IMPORT or DEPENDENCIES

Since compilation of included file is done everytime, and for IMPORT/DEPENDENCIES 
it is done once, and then a compiled version of a dependency is used 
everytime, which is infinite orders of magnitude faster.

#define may be replaced by MACRO keyword (more specific) or by DEFINE 
keyword (if you want to use a broad term). # is redundant and ***misleading*** 
since it makes one think it's C #define.

why not use the simple

define macroname: macrovalue

syntax

?

#if and #either are easily replaceable by "if" and "either" with 
an optimising compiler

and are completely redundant

#switch is the same as #if/#either.

So, all preprocessor directives can easily be removed from a language 
of Red/System, and replaced by normal keywords.

They give no pros, and give only slowdown of a translator and also 
much greater complexity of a code (try to analyse it metaprogrammatically 
and you will understand what I tell about!) and they also give a 
redundant extra layer of complexity.

I propose to start a RED v2

Red/System v2. Without a preprocessor directives at all.

Not if it delays RED

Haha. So you advicate a sShort time progress with Eternal

oops

Sorry. So you advocate a short time progress with Eternal regress 
and pain of recompiling included files and unavailability of metaprogramming 
possibility? No-preprocessor languages can easily be analysed metaprogrammatically 
and transformed, and preprocessor languages cannot (almost).

That's very childish, then. Uninformed decision.

Okay my intent is derive ROD from REBOL... Not sure I will reach 
a result.

err from RED

I don't know what you mean by "I want to be able to analyse metaprogrammatically". 
But if you want "cleaned" sources, you just have to run the pre-processor 
on the "biased" sources.

Though, I don't know if it's possible right now to just run the pre-processor. 
But feel free to ask.

http://en.wikipedia.org/w/index.php?title=Metaprogramming&oldid=472528422

I hate preprocessors installed right in the language. That's a sin 
of mixing layers into one layer.

Steeve, such cleaning removes important information from a code. 
That's reduction. And removing the preprocessor removes this reduction.

That's reduction of meaning of a program. Reduction of its semantics.

Okkkkkk, I know what the word means in its regular sense. I just 
feel you should make clear yourself with the context and provide 
some use cases.

for example how to analyse this:

#either macroname cond [ a if macroname ] [ b if macroname ] either 
macroname

And we should switch the discussion into another thread

either macroname [ c ] [ d ]

that's not analysable. Into which thread?

This is related to RED only. I can discuss privately with Dockimbel, 
but why should I go private?

Maxim, from a R/S spec: "Red/System ... will be embedded in Red scripts"

AFAICT, Red/system is used more like a high-level VM (compilable 
source rather than interpreted opcodes) which can be natively compiled. 
  RED won't have RED/System semantics.

Max, I share some sentiments with Evgeniy. I too don't understand 
some design decisions - my first take is, that Red/System should 
be as much compatible to Red, as possible. Hence I will never agree 
to decision for 'print differing from its Red counterpart. I don't 
give a <censored> to C users, as imo noone will use Red/system, unless 
that person also plans to use Red itself.


My take is, that compatibility between Red and Red/System is much 
more important, that compatibility between the Red/System and C.


Ditto the strange aproach to use kind of preprocessor for importing 
the libraries, whereas R2 and World are OK with just make routine!

Ditto for strange declaration stuff:

declare struct!
alias struct!
#import for a library

Intead of:

make struct!
make lit-struct!
make routine!


If Red/System is going to be inlined in Red, the aproach to costructors 
should be as much the same as possible. This is a dialecting - the 
same words have different meaning in different context usage. I don't 
give a <censored> about protecting a possible C user's knowledge 
...

The print names have nothing at all to do with C

It does :-) It does not print newline by default, although it will 
be 90% time of requested feature. Just because the compatibility 
to C, Doc introduced print-line, which will be equivalent to ??. 
So 90% of your time your code is going to be ridden with print-line 
or ??, becaue we don't like 'prin ...

What does that have to do with C?

That is what I call a protecting C nonsense. We are REBOL, not C, 
period. I am so mad about it, that if there would not be option to 
use print along with block, I would stop using Red/System ...

The decision was based clearly upon the fear, that Red/System is 
going to be used mainly by C ppl, and that in C print doeas not add 
new line by default ... that is imo a wrong design decision ...

Please point to the "protected" C equivalents

That is total nonsense

Explain ... that is how I remember the decision point ...

Then you remember wrong. It's easy to reread above here

Pekr,  Red and Red/System don't have the same semantics so I see 
no reason why they have to be compatible in any way except lexically.

I feel that there is a lot of merit in Evgeniy's approach, not least 
the possibility of a one-pass compiler. 


I think it is worth remembering that the current version of Red/System 
is a "bootstrap" version with which to build Red. Once Red is built, 
Red/System will be re-written in Red.


It is most likely that there will be many imporvements to Red/System 
, some may involve syntax changes. 


I feel we should all expect to have to re-visit existing Red/System 
code when the "real" Red/System is released.