World: r3wp

Yeah...

Comment back that the same could be said of Python's no-bracket syntax 
 ;)

I've had the same argument with someone for several years now, only 
about round parentheses...

The people who are supposed to be wise don't get it, either:

By the way, not like any readable Haskell.

>>----- Quote ---->>

Lisp with square parenthesis?
<<----- Quote 
---- <<

Yes, another 
Lisp for the poor" "

And one light:

Cheers, been waiting for this release

well, if people are judging a language on that, then it's impossible 
to discuss it on a higher level.

I wonder now, what people generally thought of C, when it came out. 
Of course things were slightly different back then.

2 more watchers of the github repository.

My floating point support todo-list for Red/System:


http://groups.google.com/group/red-lang/browse_thread/thread/5fe1e6bde8576d51?hl=en

what is that channel? If a new one, a forum, please add it to the 
Community section on red-lang.org?

btw - did not Ladislav do something with floating and rounding C 
level support for R3? Maybe you could consult with him ....

btw - I would not hesitate to post that info as a normal blog article 
on a red-lang.org, or some ppl might miss it?

what is that channel?
 Just the Red's mailing-list, nothing new there.

Ruby's author Matz (Yukihiro Matsumoto) tweeting about Red: http://t.co/rUZtxSOE

Well, the floating point support is just planned for now, not even 
a work in progress, I'll blog about it when it will be more tangible.

Wow Doc , EPIC ..

I predict rebol-like will be going mainstream in 2 years :)

If we do things right, it is not impossible. ;-)

my webapps (latest one is wip timetracking) code is getting cleaner 
and shows more benefits with every itteration. And all in direction 
only rebol-like langs (not even lisps) can provide AFAIK. And ages 
away from classical / python / ruby code.

(and I am not even that good at reabol .. some code that I saw at 
powermezz was also nothing I've seen before)

like nothing

Just a question towards the RED possible performance. Are all RED 
natives going to be implemented in Red/System? There might be possible 
cases, where RED is going to be slower than REBOL, no? E.g. SORT 
- in REBOL, it goes directly to the C level. If RED compiles to RED/System, 
and SORT is going to be written in RED/System, which will be surely 
slower than C, then there will be cases, when RED is slower than 
REBOL? Well, we might as well implement SORT or math intensive stuff 
in C directly, as kind of cross-platform lib, and pass it over, but 
then such a library would have to be compiled for all platforms ...

Once we'll work on optimizing Red, we'll use the fastest routines 
available for critical code parts. For SORT, I'm not sure it will 
be slower, but if it's the case, we'll use the C version.

I mean we'll use qsort() if faster than the equivalent in Red/System. 
Building a runtime lib in C for Red is not necessary, that would 
defeat one of the purpose of Red/System.

if I were to use SOURCE on a native! in Red, would it show the actual 
source?

Watching your floating point support, another question - is it possible 
(later) for Red/System to evelve into general C wrapper? I mean - 
that I would not need to use C, but Red/System, maybe plus inlined 
C/ASM, having math operations including floats? But maybe that's 
not Red/System intended purpose even in the long run?

As I understand it, the priority is to support such features in Red/System 
recently, to allow 1) wrapping of external libraries 2) provide enough 
of ground for RED itself to be compiled into ...

Red/System has supported that from the start

The point of developing an own low level language with an own compiler 
is to not need C and a C compiler. Which is something we can use 
very well in Syllable, for example

RED/System, which will be surely slower than C.


There's no reason for that to be necessarily the case. Red/System 
is a compiled, low-level language; at the very same level as C.

And as Kaj already said as well, Red/System is actually not only 
to "evolve into general C wrapper?", it is meant to actually replace 
C (for some purposes). Red/System aims to interface nicely with native 
libraries (which are, more often than not, created by using C).

The only reason that Red/System would be slower than C would be if 
the C optimizer were better than the Red/System optimizer. The languages 
have similar semantic models and are implemented similarly - they 
are in the same class, more or less.

I can only hope that Red's SORT will be more correct than the one 
in R3, which has known bugs :(

It will be slower in average especialy for looping intensive computations 
like the sorting algorithms. I don't think the Red compiler can remain 
simple and beat a full featured optimizing c compiler.

The simple current compiler technique used by Red (variable pushed/poped 
 on the stack ) is already easly beaten by any c compiler.

Any C compiler with a register allocator, that is :)

obviously ;-)

Yes, there are C compilers that don't care :)

TCC for example, if I'm not mistaken.

TCC is for science not for business :)

Don't say that :) TCC has many obscure uses :)

Steeve: certainly, but as you might have noticed, Red/System current 
implementation is a bootstrap for the Red/System future version written 
in Red. So all the current Red/System code written in REBOL, will 
be trashed once Red will be mature enough. Adding heavy optimizations 
at this point would be just a waste of time and energy that would 
serve no purpose.

For example, supporting fastcall calling convention and having a 
good register allocator are part of the optimizations that will be 
added when Red/System will be rewritten. Also, the internal compiler 
architecture, especially the code emitter will be quite different 
from the current one. I plan to introduce an intermediary representation 
and an internal event-based API. The various optimizations should 
be added as plugins/modules to the compiler, allowing to "hook" at 
various different stages of the compilation process. Also, this "API" 
should be partially (or fully) exposed at Red level, allowing to 
"easily" write Red & Red/System compiler extensions if needed.

Public service announcement: it's "Red", not "RED". Thanks for listening 
:)

I think RED is a registered trademark.

(anyway)

Thanks. :-)