World: r3wp

HAHAHA

The string parsing is done at LOAD time. Keep fighting :)

spoken like a true french would...

if you can't beat him... lie!    ;-p

Usually it works

(for the record... I'm french speaking too :-)

So you would know :)

(ithough,  was right on the specific evaluation scheme)

americans exaggerate, we just invent stuff... its more fun... hehehe 
 but we all lie  !  ;-D

Yeah, it's still parsed, but it's block-parsed instead of string-parsed.

so it's a mid-lie

half a truth is no truth AT ALL !!!!

I prefer to think that I deduce and induce, rather than lie :)

assuming is just lying with a good case!

;-)

As long as you track (and preferably state) your assumptions, it's 
not even lying at all.

right... that's just boring .... hahaha

it was just imprecision.
I too simplified to be sure that Maxim got it

All right, you foreigners, tell me what you think of http://curecode.org/rebol3/ticket.rsp?id=1212

i never use ALIAS

(just being silly about the foreigners stuff, but the ticket is serious)

Where's Jerry when you need him?

In a decade of REBOLing, Ive tried to use it exactly twice, and ended 
up having problems, so I created global words instead and forgot 
about it.

Guys, what are you coding with R3 currently ?

I've been mostly writing R3 itself. The projects I want to work on 
require capabilities that R2 don't have, and R3 didn't - until recently.

I've been trying to get R3 in shape to use for my projects, and it's 
been paying off recently (extensions, command!).

Actually, there is too much evolutions, i can't focus on a specific 
project

Haven't used R3 for anything serious yet.


but now that extensions are upon us, the OpenGL integration will 
allow me to use R3 for a *VERY* serious project.  still need Carl 
to fix the make/copy issue before I can convert most of my cool stuff 
over to R3 (like liquid and globs).

I hope extensions will be in the linux and mac ports shortly.

R2 still pays the bills and works very well for me.

OpenGL integration is a too big project for me, i lost my motivation 
after some days

Its working on my system  :-)


when A80 is out, depending on what he will have added to the API, 
I will try to port a simple OpenGL game to REBOL  :-)

well, i have some fun coding a proxy for R3 since some days, but 
I reach my limit attention

porting relavance to REBOL is also another big project of mine, probably 
will start in under a month  :-)

another one RDBMS

It's not Relational, is it?

ADBMS, sorry

Assoiative, relational... 

To my mind, there is no difference, it's just the query language 
which is different

*associative

At the end is always the same problem.
To have fast indexation algorithms

I don't code R3 things yet. Too many moving targets.

Re ALIAS -- it has several security and other issues.

Enabling it via SECURE is a good way of limiting the inadvertent 
damage it can do....And of drawing attention to its dangers for any 
casual dabbler.

The module rework has finally been submitted :)

Now it's time to backport it to R2/Forward, to the extent possible.

The set-block! datatype would make good sense with functions, that 
return more than one value. In Lua, a function returning 3 values 
can be defined as:

function f () return 1, 2, 3 end

and be called like:

a, b, c = f ()


Now a, b and c holds the values 1, 2 and 3. In REBOL we have to write:

set [a b c] f

It would maybe be nice to be able to write:

[a b c]: f

I find it easier to write set [a b c] than to notice the colon on 
the end of [a b c]: - but that may be just me.

Yes, the colon can be hard to notice. It's hard to say, if it will 
be easy to read such code.

The readability of REBOL is one of the deliberate design features 
that makes REBOL quick to program in.

I'm working with a long time REBOL programmer these days. We discuss 
the language now and then. One thing, we discuss, is how the minimalistic 
syntax can make REBOL hard to read. We can use parenthesis for arguments 
to functions, but we rarely do it. We could write:

insert (back (tail (series))) value

but a REBOL programmer would just write:

insert back tail series value


Even if we use parenthesis, REBOL requre different parenthesis notation 
than other languages. The above code in C would look like:

insert (back (tail (series)), value);

And C programmers often don't write the code this way with functions 
within function calls. They use to write:

void *pointer = tail (series);
pointer = back (pointer);
insert (pointer, value);

or something.

That is only because of line-oriented debuggers :)

This, I think, is one of the huge benefit of REBOL. To be able to 
combine words into sentences, that actually makes sense to read and 
understand. I don't know of any other language, that can do it this 
good.