World: r4wp

And Doc himself claims from very beginning, that R/S is mostly for 
integrators, as you are. Most ppl will look into Red, and find such 
features missing. I am really not interested into some Curl binding, 
I want Rebol level ports, etc. based networking. So our milleage 
might vary ...

Yes, this is something we found out along the way. Red/System is 
very powerful

I have nothing against R/S, in fact - I am liking the overall Red 
architecture. I somehow can't explain it, dunno. Simply put - I worry, 
that basing my programs upon some already existing bindings is risky, 
as Red will provide its own solution later, which will make it incompatible 
imo ...

You will keep making those thought mistakes as long as you don't 
start programming

It is kind of Osbourne syndrom with me - waiting for native Red implementation, 
instead of using what is available ... strange feeling ...

As in Ozzy?

not, wikipedia term :-) Ozzy is metal singer :-)

Not familiar with any other kinds of Osbourne syndrome

Osbourne syndrome is, when company announces some product, its features, 
not releasing it for some time, and customers stop buying their product, 
as they wait for new and better stuff to appear ...

Oh, that Osbourne

That was REBOL. Red is released all the time, so you should start 
yesterday

With a new Red release, you don't have to throw away your previous 
Red. It's still in there. And you don't even have to pay for the 
new

What's the easiest way to try Red/System? I see do/system and #system 
[ ... ] suggestions in the docs:
http://static.red-lang.org/red-system-specs.html#section-17

, but I don't seem to get it to work.

do/system is unimplemented, #system and #system-global are

But for just using Red/System, giving your program a Red/System header 
is easiest

It's easiest to start from the included examples/tests

Ok, I'll look at those.

I agree.  I haven't done much with Red yet, but Red/System is great. 
 I wish it was easier to work with strings, but I guess that's when 
I'd want to be using Red.

In our project, I have arrived naturally at an interesting technique 
combining the two

Normally, you would bind low level interfaces or code using Red/System, 
or the DLL interface in R3, or an extension in R3. You would then 
marshall all the arguments of the low level functions back and forth 
to Red or REBOL all the time

In the R2 DLL interface, there's no other way to do it. But in Red, 
I'm keeping all data that Red doesn't need to know about in the Red/System 
level. Many low level arguments don't have to be marshalled to Red 
at all

The bridges are through the ROUTINE functions in Red. I don't give 
them all the arguments of the functions that were bound in #import; 
I only add an argument when it becomes needed in the Red application 
logic

So you're usually handling strings comfortably at the Red level, 
and you can keep simple low level data such as integers and #import 
arguments that only need default values at the Red/System level, 
where they're native datatypes that are handled efficiently

Thanks for the insights, Kaj!

kaj, that is most probably the correct way of how to use it anyway, 
thanks for the hints

i can still imagine an example, when one would like to have more 
expressive R/S. Red does not compile only down to R/S, it also adds 
some Red related framework, which might mean larger executable, loss 
of speed, etc. Not sure what Doc thinks, as he always tells me - 
hey, use Red for such purposes, but maybe, who knows, there is a 
place for more advanced barebones R/S 2.0 after all :-)

I know list of enhancements for R/S 2.0 exists, yet I don't expect 
it having more advanced series handling ...

It's hard to draw the line. If you want to use Red/System on its 
own, you need things like that, so I made some in my bindings. But 
if you use it together with Red, most such things aren't needed

Sometimes the decision is made easier. It would be hard to use Red 
in a kernel driver, for example, so you need everything for Red/System 
that you need to write drivers

The future and more usage patterns will show what is needed ...

Yes, it often turns out to be surprising :-)

I canunderstand, but where exactly would you drive the line? We start 
with series, next we ask for IO, then we request parse :-)

I/O is already here, and my C library binding has parsing functions 
:-)

drive = draw

You'll need them to write Red/System programs, but a lot of it has 
no place in Red. Perhaps that will make it easier to understand why 
most of my stuff is separate from Red

I hop Doc is not going to be demotivated after ReCode. Fork said, 
that Carl said, that if he would be about to rewrite Rebol, he would 
took R3 aproach ..

I expressed my need for R2 like dll interface for R3, as I find it 
easier to use R/S than R3 extensions, and guys said, it will come 
...

Don't expect that to throw Doc off balance :-)

I am still with Red though, even if Carl stated, he will resume some 
R3 developments. I will follow both projects, hopefully good times 
ahead ...

you know, for our Led screen, I wrapped the dll using r2, red/system 
and world. In fact, it was rather easy to switch. If there is at 
least some level of compatibility, I like the options ...

Red follows the REBOL model, with batteries included, where you need 
a strict standard. Red/System follows the C model, with a small languages 
that needs to be exttended with libraries, and where many C libraries 
are available that can be bound to Red/System

I thonk I would do it even with r3 extensions, but I am just old 
lazy dog :-)

ah, sorry for typos, typing on my htc using teamviewer connected 
to my notebook. So who said alme is not available on your cell phone? 
:-)

You could turn your Red/System binding into an R3 extension

Ah, correct, forgot about that, thsnks for the reminder ...

Fork said, that Carl said, that if he would be about to rewrite Rebol, 
he would took R3 aproach ..

 Fortunately I was there so I can give some contextual information: 
 Fork was saying to Carl his famous quote: "Rebol4 is Red". What do 
 you expect Carl to reply to that? ;-)

I hop Doc is not going to be (de)motivated after ReCode.
 No, it's the opposite in fact. ;-)

Red/System is a dialect of Red meant to address specific needs. You 
should see it as a feature of Red, even if it can be used alone (which 
is kind of side-effect of starting Red project by building R/S first).

Doc and/or Kaj, at what point will we be able to use Red and R/S 
to start things off by programming the MBR and jumping to a Red OS. 
What I am interested in is learning to use Red and R/S to build a 
native O/S from the ground up as this is the best way to truly understand 
computers. Also a PC that is Red and R/S from the ground up is a 
very exciting prospect.

Pekr: "alpha" means "feature-incomplete". See:
http://en.wikipedia.org/wiki/Software_release_life_cycle#Alpha


The alpha phase usually ends with a feature freeze, indicating that 
no more features will be added to the software. At this time, the 
software is said to be feature complete.

Why does Carl think you are going to be (de)motivated?