World: r4wp

I talk about Red not Red/system

Yes, Peter i right

Me too!

is

I think you're both wrong ;-)

Red is a compiler, as simple as that

Well I'm usually worng :-)

You're talking 	about Red/system not Red

Red is evaluated

No, we've been publishing that fact for almost two years now. I don't 
know what else we can do

like Rebol

No, it is compiled like C.

This might give you a clue - https://github.com/dockimbel/Red/issues/308

Kaj: nice! Actually, such kind of function (highly recursive, very 
small body) should perform 5-10 times faster than R3 in the target 
compiler. Functions with bigger bodies shoud be in the 10-15 range. 
Functions with pure math expressions should be in a 20-100 range.


Though, these are very rough early estimates I did on the base of 
a few micro-benchmarks.

Red is evaluated
 No, compiled. :-)

why is kaj's script so slow then ?  ;-)

No optimisations

okay T_T

Uh, what optimisations, Kaj? We are talking Red bing compiled to 
Red/System, so how comes, that the result is only 2 times faster 
than R3? I expected speed of nearly a R/S version. Something must 
be wrong, or Red would not make sense with such poor performance 
at all imo ...

The fact that you're complaining means that the optimisations are 
missing, isn't it?

If Red doesn't make sense at all, then R3 doesn't make sense double 
at all

Well, R3 is dynamic. We are supposed to give-up something in exchange 
in much bigger performance. And R/S gave us some rewards, being only 
some 4-5 times slower than C version? Now if Red is going to be orders 
of magnitude slower, I would be really disappointed ...

You can get Red/System speed if you write in Red/System, not if you 
write Red

Well, I thought, that Red code gets compiled/translated into R/S 
code, and that code is going to be translated into machine code :-)

Red is a high-level language with high-level abstract types. Once 
we get optimizations, Kaj's example should run 5-10 faster than R3. 
For some high-level expressions that have low-level counterparts, 
it is possible to achieve very high gains (in the 10-100 range), 
for those that do not have low-level counterparts, you can only expect 
typical gains from moving from an interpreter to a compiler (on average 
5-10 faster).


Also, there is also a source of additional speed gains: the possible 
runtime optimizations enabled by the JIT-compiler.

Yes, and that doesn't magically make it being programmed in machine 
code

Pekr: high-level language have higher level semantics (materialized 
in the case of Red by the runtime code in %runtime/ folder), you 
can't expect all that "disappear by magic" when translated to native 
code. It is not in the domain of possible things. :-)

to be exact R3 is 300-500 time slower than c compiled code in my 
last tests.
So at least Red should be at leatst 30-50 times faster than Rebol

Those high-level layers are what makes Red able to accomplish all 
the things you like instead of being limited to a macro-assember 
level language (like C or Red/System).

Steeve, I look forward to your Red fork that does that

I forfeit

Your own REBOL clone, then?

it's the limit of the stack based compiler, simple to implement, 
slower than a registers based one

Only partly

Steeve, performances gains will depends on the kind of code you run. 
For micro-benchmarks (like loop 10'000'000 [tail? ""]), the target 
compiler should perform 5-10 faster than R3. For "normal apps", you 
should expect a 10-20 gain (very rough early estimates). For math 
intensive apps, you'll be able to go up to x100 speed gains.

(Kaj, I'm trying to port a text editor to R3 currently, gobs are 
terrible and some times horrific)

Steeve, it is not that simple (I wish it would). You forget to account 
for a lot of things like e.g., exceptions handling and the GC.

yeah, I forgot

Steeve - could you outline then, how would you change gobs in some 
other channel or wiki document. I e.g. don't want to support GTK 
or other bloatware yet, so it might be that I might sponsor View 
engine port, of course, being done eventually right. Gobs are definitely 
more optimised than Faces were though ...

I wanted to say terrible, in the sense of nice

I think gobs are very handy, it would be nice to see a portage to 
Red

But they tend to crash R3 a lot when the command api fail

Steeve, so the design is OK, but implementation needs work?

Pekr, Actually I only use gobs for the rendering part in R3, I completly 
rewriten myu own event handler and VID.

I don't use the VID layer furnished by saphirion

Henrik, yes it still needs work to remove the crashs, and the text 
rendering is not perfect on Win7 but l think we can do everything 
R2 did.

I will probably do a Gob-like binding on Enlightenment

never mind, talking about View engine itself. I don't like gobs logic 
in some aspects anyway ... I e.g. don't like separate gobs for text, 
color, image, effect, draw. Dunno low level logic, but it could be 
all in draw dialect. Simply put - always hated when you can do gob/text, 
but then you can do another text in terms of draw, ditto effect, 
etc.

I mean - never mind you did not use VID ...

I will post something on Github but I can't say too much too soon. 
I don't want to announce another abandonware.

If I can finalize the text editing it could be the beginning of... 
something. :-)