World: r3wp

The resulting value type for math operators is the type of the left 
argument (an implicit type casting is operated when required).

What motivation lay behind this?

Implementation constraint for + and - to support pointer/struct/c-string 
arithmetic without having to explicitly cast the 2nd argument. So 
to avoid having a different rule for * , / and //, I chosed to let 
the implicit casting occur on all math operators. But as the implicit 
casting is reducing the safety of expressions, I might make it more 
strict than it is currently.

Will you add floats to Red/System? Will 1 + 1.5 then yield 2?

Floats in Red/System: depends if Red would rely (fully or partially) 
on Red/System's code emitter or have its own one. If Red/System gets 
floats, such operation might be authorized too. The implicit casting 
would do a ROUND/DOWN conversion, so additional rounding functions 
will need to be supported too.

Implemented seekable i/o in the C library binding

We had some tea at Hekovnik (hackerspace) and one very experienced 
programmer here started talking about new language Red .. I was what?? 
Did you say Red :) .. he read about it on the OSNews

:-)

Did he have an opinion yet?

You'll note that only a few trolls have responded to the article, 
and one person who already knew REBOL. This is typical when you introduce 
something that people don't understand. They'll hold back from responding 
in fear of saying something that makes them look stupid. However, 
so far four thousand of them have traveled from the article to the 
Red site, which is more than we get on a typical Syllable article

He was interested about it all so I hope Doc's (and comunity's) progress 
will go well. ( BTW: Doc, He also noted you have a little familiar 
name ;) )

I will try to chip in once you get to more app / lib level :)

4K of visitors? Nice.

A question is being asked about the JIT on OSNews.

Janko: cool news :-)

Kaj - what is your take on the Red & Syllable? I mean - Syllable 
is open-source. You used Boron for some stuff, and then you thought 
of using R3. Are you now thinking about the switch to Red?

About the LLVM question on OSNews, someone with an account there 
could anwser by posting this link to a similar question on the Red's 
ML: http://groups.google.com/group/red-lang/browse_thread/thread/eeca0a4787da56c2?hl=en

And maybe few questions to Doc:


1) R3 got some stuff as codecs (not yet implemented) and devices 
for async. Will you think about such abstractions too? (e.g. ports), 
or is Red going to be more "straighforward"/traditional?


2) as View is mostly open-sourced too - will event system allow to 
eventually port View engine to Red later?


3) as 2) requires 'parse, do you plan to have kind of R3 parse too? 
Is that even possible? (as Red is not so dynamic as REBOL?)

1) Ports and devices: yes, definitely. What features does exactly 
"codecs" cover in R3?


2) I was not aware that it was allowed to use View sources with anything 
else than R3?


3) Parse: absolutely. Not sure yet if it will be 100% compatible 
with R3, but it will at least, support R2's whole parse dialect. 
Red should be as "dynamic" as REBOL for the code<=>data paradigm 
once the JIT compiler will be in place.

View sources: If it's BSD licensed (essentially) what would prevent 
them from being usable elsewhere?

If View sources are available under BSD, I will be glad to have it 
as one of the possible libraries for making GUI apps.

I will ask formally.

Petr, it has been a bit of a process in my head in the past few months, 
but to be honest, I've decided to move all my R3 developments and 
plans to Red. All of those also apply to Syllable

I've been waiting for a decade to be able to use REBOL, because it 
never ran on Syllable, and for the past half decade, all subsystems 
were planned to be replaced, seemingly making it uneconomical to 
start using R2 on other platforms

In the past two years I made a lot of effort to get R3 running on 
Syllable Server and then Syllable Desktop, and just now that it was 
becoming somewhat usable, it's being abandoned

This after going through the Atari trauma, and having decided never 
to do that again, seeing all those other people go through the Commodore 
trauma, the Amiga trauma, the RISC OS trauma and the BeOS trauma

I made an exception for REBOL because it's brilliance couldn't be 
found anywhere else, and I paid dearly

Kaj: thanks for your answer to the LLVM comment on OSNews.

Hope I'm saying it right

Yes, it is nicely summed up.

The Rebol source headers say .. free to use as long as you keep the 
headers intact.  And then refers you to the full license .. whereever 
that may lie.

Are the View sources complete in the host-kit or are some part of 
it sill buried in the closed Core?

I think they are complete, but the official word is that the host 
kit will be separated under two licenses: one part open source and 
one part not open source. Both projected licenses are still unspecified

The interfaces between REBOL and AGG are rather REBOL specific. I'm 
not sure it's worth it to try to use them in Red

Cyphre says that it's easily possible to use the AGG part outside 
of R3.

License is a question for Carl. Perhaps it's simpler to just interface 
AGG directly. Not sure.

If you get a BSD licence. The purpose of the other unspecified licence 
is specifically to prevent REBOL competitors

Well, latest AGG version (2.5) is distributed under GPL, development 
has stopped in 2006, it doesn't support hardware acceleration AFAIK, 
so it's a no-go. Cairo seems like a more modern graphic vector engine. 
Anyway, it is open to any contributor, as I don't plan to work personally 
on a View-like engine for Red.

2.4 is BSD. 2.5 is only slightly improved. A residual community around 
AGG has been continuing with 2.4 and has made a few fixes to it

http://agg.svn.sourceforge.net/viewvc/agg/

There are basically four options: AGG, Fog, Cairo and Skia

I was always unimpressed with Cairo. If you want a full-featured 
library, Skia looks better

AGG and FOG may perform better, but I'm not sure. The choice between 
those two is difficult. AGG is basically abandoned, but still more 
popular than Fog

I have heard about Skia, I agree, it seems like a nice library. Never 
heard about Fog before, but its performances are impressive: http://code.google.com/p/fog/wiki/Benchmarks

Comparing against Cairo is like taking candy from a kid :-)

I'd like to know how it compares to AGG and Skia

I also want to know if rendering quality in Skia is as good as in 
AGG. It sucks in Cairo, or at least it always did. Fog is likely 
to be as good as AGG, because it builds on the same principles

Implemented character set tests and case conversion in the C library 
binding

talking about the C library... will Red compile against the uclibc?

Red/System is written in REBOL

From conversations that I have followed, it does not directly access 
C libraries.