World: r4wp

FUNCTION. It's mentioned here: https://github.com/dockimbel/Red/commit/cc5c8dcb839572bb25559f964ed7d30419cb5a31

Thanks Doc. I support the idea of decimal! as the BCD type.

Doc, I can see Rudolf being pretty active with testing Red, Red/System? 
Nice, I thought we have lost him when R3 went into a non-development 
mode ....

He showed up again shorter after Red first alpha release. He's working 
on updating the BNF grammar of Red/System to add namespaces.

No gob! Does this mean no GUI or just gui done in different way?

There are GTK+ and SDL bindings. There will be bindings to native 
GUIs in the future (I consider GTK to be the most native binding 
for Linux and BSD systems)

They're for Red/System for now, not connected to Red yet

Does this mean no GUI or just gui done in different way?

 See all the presentation slides for Red, a native GUI system will 
 be provided. Also a web server with a new web framework will be part 
 of Red stack, so modern style web apps will be supported.


The GUI will probably be done in different way than R3 underneath, 
maybe a gob!-like datatype will be a good match, but such implementation 
detail is not known until implementation starts. Also, it is possible 
to extract R3 GUI code, wrap it in a shared library and plug it in 
Red (but I won't be the one doing that and maintaining such wrapper).

As Kaj underlined, GTK+ will most probably be the native target for 
Linux.

I've finally been able to write a Red version of Fibonacci numbers. 
It executes twice as fast as R3

Red/System is roughly hundred times faster

Is the Red version pure Red? Why exactly is it faster than R3?

It's compiled

parameter: 35

fibonacci: func [
	n		[integer!]
	/local	a
][
	either n < 2 [
		n
	][
		a: fibonacci n - 1
		a + fibonacci n - 2
	]
]

prin "Fibonacci "
prin parameter
prin ": "
print fibonacci parameter

Functions in red are not compiled yet, right ?

Wrong.

Functions are compiled  in Red.

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