World: r4wp

Ok, but Rebol is better than html5. You write your script and it 
works on MacOS, Windows, Linux, in a browser. "write once and use 
it every where" better than Java.

of course, better than JAVA. But generally it does not work in a 
browser - you still need a plugin for each platform. Don't forget 
mobile devices, etc. But - that is a bit offtopic here in a RED group

We shouldn't forget the idea of ReBrowse, which is Carl's idea of 
a browser written in R3 and is mean to replace the Viewtop. It's 
true that it doesn't run inside other browsers or leverages HTML, 
but it will still be a great technology demonstration of what a webbrowser 
should be.

yes, and it would be cool to run rebrowser in real browser. Remember 
- making a NS plugin is wrapping something like 20 function calls? 
Not a problem for C skilled coder. I am even willing to start a bounty 
for that :-) But - first things first - R3 has to have a future first, 
so waiting for Carl's next step ...

I have personally entirely different ideas for using Red as a basis 
for a new kind of desktop, but I'm not sure if I'm skilled enough 
to build it. We'll see.

for most purposes HTML5 will be good enough for desktop applications. 
 And that's all it needs.

Does #221 change #192?

No, it's not the same issue.

#221 is about keeping the x87 FPU stack clean in case of a nested 
`either` expression.

But #213 and #192 are partially related.

Thanks

Issues #222 and #223 fixed.

Doc - typo in 4.4.1 Doc section - "provindg" ... probably should 
be providing ....

btw - what is the 0.3.0 branch? I forgot what it was about?

I can still reproduce #223 with slightly modified code - see comment.

Where's the bugbase, please?

https://github.com/dockimbel/Red/issues?sort=created&direction=desc&state=open

I know nothing about RED, so, would anyoe be so kind to tell me in 
a nut shell where it stands?

Reichart - I suggest general About page, there is nice presentation 
Doc did for Reborcon - http://www.red-lang.org/p/about.html

But in short - Red is going to be compiled language, and it will 
probably get some kind of JIT too, to allow interactive stuff like 
console. Red language compiles down to Red/System, which is kind 
of VM for it. In fact, it is REBOL-like low level wrapper to C, allowing 
some bindings. Red/System apps recently run even on ARM, eg I am 
able to run it on my HTC Sensation. But that's raw ARM Linux, no 
Android API linking yet ....

Very cool.

So, is there a guess when it will "run" most of the scripts in the 
REBOL public library?

Doc wants to keep certain level of compatibility, but due to Red 
nature, full compatibility will not be possible imo. Red currently 
does not exist yet, Doc worked on some other stuff for 4 months or 
so. I don't know, how long it can take to have Red layer in alpha 
version finished, hopefully this year ....

Very cool, thank you for info.

Yeah, Red seems to have the greatest momentum right now. It will 
be very interesting in a few months, hopefully.

I'm ALL for it!

No VID support at this moment, but there is growing interest in it.

Red/System is not VM or wrapper to C, it has compiler that creates 
executable files.

Reichart: thanks for your enthusiasm! :-)

@Rebolek: fixed #223 again, I hope that this time the fix will hold. 
;-)

Thanks, I hope so too :) I will test it and see.

Doc, you won't like my report :) I used 7 as loop count in my last 
example because it was smallest number to trigger the bug. This now 
works, but increasing the counter to at least 8 (I used 10, as it's 
length of allocated array) will trigger the bug again. See comment 
in #223 for example.

:-)

I found the cause of this new FPU stack leaking (x87 stack has 7 
slots) and fixed it (it was a regression).

Wonderful! My test now runs without a problem. Time to try something 
more complicated :)

Pekr: "btw - what is the 0.3.0 branch? I forgot what it was about?"


Initially, it was for completing the Red runtime but, as it was not 
possible for me to achieve that without implementing the Red compiler 
itself (even in an alpha state), it's now dedicated to Red compiler 
first alpha. So I guess that v0.4.0 will mark the completion of Red 
compiler (in the bootstrapped form).

Does this mean that Red will from 0.3.0 lose it's dependency of REBOL/Core?

Nope, it still relies on REBOL/Core for the compiler until we rebuilt 
it in Red itself.

ok

Rebolek: "Thanks, I hope so too :) I will test it and see." - it 
would be really helpful if you could use qutick-test.reds to wriite 
your tests. We could then add them to the Red/System test suite which 
would allow Nenad to discover regressions before he relaeses fixes.

qutick-test.reds -> quick-test.reds

My tests are bit random, they test just what I need but I will add 
them, it's probably better than nothing.

Also I've run into some weird problems with float32!. I try to separate 
the code and write some simple examples.

That's fine, regression tests are supposed to be for very specific 
situations that occurred

Hi Doc and everybody, since I'm studying the opportunity to create 
myself - in a loooong future - a test  version of Red/system running 
over the JVM - I asked myself, after reading some doc titled "Create 
ypour own programming language" by Marc-Andre Cournoyer, if in any 
case Doc had thought about this way of doing things for his future 
implementation of Red (not Red/system), as described by this excerpt 
from the doc itself under the section :  PROTOTYPE-BASED

Except for Javascript, no Prototype-based languages have reached 
widespread

popularity yet. This model is the easiest one to implement and also 
the most
flexible because everything is a clone of an object.

Ian Piumarta describes how to design an Open, Extensible Object Model 
that
allows the language’s users to modify its behavior at runtime.

Look at the appendix at the end of this book for a sample prototype-based

language: Appendix: Mio, a minimalist homoiconic language. For a 
follow-up about these concerns here is the URL related to the Extensible 
Object Model upon which the author has based his own Mio language, 
itself inspired by the IO language  -  http://piumarta.com/software/cola/objmodel2.pdf

Prototype-based: certainly, that's the REBOL way, so that will be 
the Red way too.

I've put some (I think) useful functions to https://github.com/rebolek/user.reds

There are things like int-to-float and float-to-int conversion and 
some string support functions.

Thanks Rebolek! I like the ** power function. :-)

It's unfortunately integer! only, I need float! version, so maybe 
for next release I find something :) i'm most happy with float-to-int 
and int-to-float, I was really missing it from Red/System.

I was planning to add them as intrinsic ASM functions in the backends, 
but in the meantime, your implementation will certainly be useful.

Hi Doc, I didn't express correctly in my last post and you missed 
the point - I already know that Red will be prototype-based but the 
question is : will the object model implementation you'll use be 
flexible enough to permit you and/or the end-user  to easily extend 
  Red with other  new types, or change primitive functionality and 
semantics at some later time. The author of this article has done 
some studies and experiments about this fact and within his 16 pages, 
he explains how it could circumvent these possible limitations without 
sacrificing efficiency - even if I'm not advanced enough to take 
his word as truth per se. I thought it would be useful to you to 
see such writing before you committed to much material, based on 
your current architecture and internal implementation details - about 
which I don't know anything, I must confess. Sorry if this is more 
of an annoyance than a useful tip but I thought it could be useful 
as a reading to anyone interested in implementing some programming 
language - be it not fully Red related.