AltME groups: search

Indexing with a variable should also be possible: 
s: "hello"
c: 1

s/c or s/:c (haven't decided yet which one is the more appropriate)

Started a new blog : http://red-chronicle.blogspot.com/

And a Twitter : http://twitter.com/red_chronicle

Yes, I did a bad move with my git client and created two branches 
instead of one. Looking in github for a "drop branch" button.

For that matter, will Red/System be getting a module system, or some 
other kind of packaging facility?

I'll extend it to allow compiling several sources in a single executable, 
but I won't go past that. Red/System will live as a Red dialect, 
so will benefit from the whole Red environment. The only time it 
needs to work alone will be to produce the Red's runtime layer. But, 
as said in my blog, Red/System could be extended to a full-featured 
language if someone want to invest in it.

Red/System is a cross-compiler. ;-)

the helloworld.reds script exe opens a console, writes stuff and 
then closes. Is there a way to keep that wndow open so I can see 
the output?

amacleod: It's mentioned in the README file:

4) The resulting binary is in red-system/builds/hello.exe, open a 
DOS console and run it.

I've looked at TCC sources for inspiration (don't know about OTCC). 
Making a compiler is at the heart of the project, Red (as Red/System) 
are compiled languages.

could LLVM also be a target for the emitter, eventually?

Short answer: sure, but it's not in the roadmap, I don't have a need 
for it.

But you know, I woud prefer a DSL like emiter, something using parse's 
rules exclusively

I needed to prototype a direct native emitter for the upcoming JIT-compiler. 
So compilation speed was a critical.

thanks, I was just wondering if the compiler was structured in a 
way to make it possible.


as for when/how that's obviously not a priority if you're already 
able to spit out code for the various platforms easily.

was a critical
 => was critical

Yes, that's the idea. It's currently in a boostrapping phase, temporary 
relying on REBOL.

No, I mean writing each target emitters/assemblers (IA32.r) with 
a dialect.

In a way to ease porting

But it's true that it's a matter of taste.

Such dialect would be an IR (Intermediate Representation), I wanted 
to avoid that, for several reasons: simplicity, efficiency, performances. 
The porting effort is not so big with the current approach. Also, 
once I'll start working on the optimizing compiler version (next 
year), I would  use need an IR, and it would need to be a little 
higher level than that (emitter/ASM-like level).

If you set the compilation logs to 3 (-vvv) and take only the entries 
starting with ">>" you'll get a feeling of what such IR would be. 
In fact, just recording these steps instead of reducing them directly 
to native code, would almost give you a good IR to start making optimizations 
(other than the very trivial ones that I've included in IA32.r).

I remember reading E docs, but not coding...maybe I just did a HelloWorld 
app.

IIRC it would compile 10000 lines of code /second on a 7MHz cpu.

Max: the current supported types in Red/System are all of same size. 
Makes a lot of things easier, but I will need 8 and 16-bit sizes 
very soon, so the simplicity of implementation will probably suffer 
a little from that.

Or, you could write a script to post these to the google groups list 
too :)

the web public is just a convention

I don't see how the chat-oriented content here would not look like 
a big mess if copied to a web forum :-).

Just a suggestion ... to cc to mailing list.
Not everyone on the mailing list is on altme

And it would ensure a single source for discussion

The REBOL list? That was dead when I looked a while ago

Let's start with a simple announcement:

not a tech question about red .. but what is a code bubble?

I wrote a Syllable build recipe for Red:

There's not very much you can do with Red on Syllable yet, and the 
integration is awkward, but it's a start

Code bubbles have almost nothing to do with literate programming. 
For one thing, you can't add inlime docs beyond the comments in the 
language syntax. This is more like a more graphical version of the 
Smalltalk browser.

The original Java case benefits more from the concept than REBOL 
would because there are many addon standards like JavaDoc that need 
managing, but at least have been agreed upon by their community. 
We don't have that kind of agreement in the REBOL community. Also, 
the structure of the Java language is very limited, so it's a bit 
easier to parse it and have its structure just be in the background 
even though the language wasn't designed for that like Smalltalk 
was for its browser. For Red, since it's so early, things like integrated 
documentation can be developed along with the language, so something 
like this would make more sense. However, if Red is going to have 
even a large fraction of the power of REBOL then it won't be as structured 
as Java, making it a little more difficult to retrofit a Code Bubbles 
interface onto existing code. This is why you would need an IDE to 
understand code written in this kind of IDE: A Code Bubbles style 
interface doesn't generate code with story structure the way scripts 
are structured, so you can't just read the code without the context 
of the IDE.

Kaj: I'll have a look at ELF format this weekend, to see if it is 
possible to add it quickly on sunday.

It it requires more than a day of work, I'll postpone it for the 
end of this month.

Graham: I've posted a short reply to your code bubbles question here: 
http://groups.google.com/group/red-lang/browse_thread/thread/8ecea42063ee4e14/6f7364ebadc7291d?hl=en#6f7364ebadc7291d

I replied to that as well, but the word wrap corrupted my post a 
little. Whoops.

I didn't realize that the word wrapping was something it did; I thought 
it was something *you* did in that message. So I put in my own line 
endings, which ended up in the wrong place because they word wrap 
at fixed indexes as if they weren't rendering with a proportional 
font. If they are word wrapping that way, they should use an editor 
with a fixed-length font and a margin line.

What they are doing is using the Usenet message format in Google 
Groups, and that means ~78 character lines iirc. That format was 
designed for composing messages in terminals (like in R3 chat) or 
in special editors that use fonts like Courier when composing messages. 
It's surprising that they didn't relax the format a little for groups 
that aren't mirrored on the real Usenet, but when you "Show original" 
(in the "More options" section) the message is formatted for Usenet 
and email.

Brian, Google Groups still is a mailing-list tfrontend, so those 
messages actually go out via email.

Question: I created my fork.

And now I created a branch on my computer, but where am I supposed 
to work exactly ? 

I mean, I only see the source files in a sub dir called /red-system

Maybe you should have look at a Git documentation first?

Doc, do you see something ? 
I pulled a request.

Steeve: yes, got it, looks good to me. I'll pull it in a few minutes. 
Andreas is right, you don't need to comment the old code, just delete 
it (but keep the TBD comments).

Your pull request disappeared, I guess you'll publish a new one.

I repulled a request.

It was missing a to-integer conversion: power-of-2?: func [n [integer!]][if 
zero? n - 1 and n [to integer! log-2 n]]

well it should be a little little faster aswell ;-)

For now, it's a prototype code, it doesn't need to be much micro-optimized 
as it will be fully rewritten in a few months using the Red language.

I see that you use a lot, nested EITHER structures.
Personnaly I prefer flat CASE structures, more readable.
And i also think CASE could be faster.

It seems a ticket is opened for each pull request...

I just click ramdomly like a foul

Are you using a Git client or just github's web UI?

I made a clone of my fork on my PC

steeve, locally do a "git pull --rebase" from doc's repo

Thanks to Andreas' help, we now have a first experimental support 
for Linux/ELF for Red/System. It's still very limited (basically 
just being able to call a system function with an argument), but 
it's a good start. It should be extended in the next days to support 
compilation of the hello.reds demo script.

Nope, seems that a ELF support large enough to run the demo script 
could be doable tomorrow or in the next days.

libc support will come as soon as we get support for a loader done

Kaj: I had a quick look at *BSD syscalls, there are pretty much the 
same as Linux (at least for the most used ones). The calling convention 
is different thought, but can be supported by one or two more lines 
of code in Red/System emitter.

When I see how Carl fights with various libc versions...I wonder 
if syscalls are not an easier path even if it can have some minor 
porting costs here and there? Anyway, a libc mapping will be possible 
soon, so all options are open.

The issue R2 currently has with old Linux systems is with floating 
point. That's in the math library, part of GLibC, not the kernel, 
so there's no way around it unless you use a completely different 
implementation

That's more of a Red problem though. Red/System doesn't have floating 
point, just integers.

If the performances are close to classic floating point math operations, 
that would be a great alternative.

That is not to be expected, because this seems to be a software implementation

Still, the R2 problem with the math library is probably a fluke that 
can be prevented

On the one side you have a chaotic Linux ecosystem where most developers 
refuse to care about binary compatibility, on the other hand you 
have an isolated REBOL cave where Carl refuses to deal with outside 
complexity. This is a recipe for disaster. There must be some middle 
ground - as we have proven in Syllable

Download: that's strange, there was a download button under the title 
of the article, I've got it a few of hours ago, checking the licensing 
terms in the sources archive...

This IEEE 754R spec is a revision based on IEEE 754, but it seems 
to me that the decimal implementation in this library is in software, 
awaiting new FPUs (IBM already has a few (although already is not 
really a good term for 2011))

I agree that the library size is too big anyway for a direct inclusion 
in Red's core.

Hi, I added a Red to the Alternatives section in REBOL Wikipedia 
page.

Sure I could, but they were removed by some "purists" telling, that 
the Wikipedia was not a link repository, so I am afraid it might 
be contraproductive.

Brian: yes, for financial usage, so might differ a bit from REBOL's 
money! type.

Once Red is a bit more mature, it will be quite a bit easier to write 
bindings for Red than for R3

This has got to be the shortest time for a working rebol clone !

Doc claims to have been secretly working on it for a decade ;-)

while [yes = yes] 

 => this cries for a better logic values support ;-) I was working 
 on a TRUE/FALSE support in the train when coming to ReBorCon 2011, 
 but never finished it. I need to get back on it.

I can compile it with the last Red/System version (adding calling 
converbut I get a "zmq_err0 entry point not found". I guess, there's 
a regression in the compiler or an incompatible change. I'll check 
that after publising the new revision with extended Linux support.

Interesting that it works under WINE but not Windows. :-) I did have 
to install some Visual C++ runtime from 2008, but the lack of that 
produced a fairly clear error pointing in that direction

Did you install libzmq.dll? It's a binding with a dynamic library

Pushing the new revision in a couple of minutes...

So the 512 bytes binary pages (with seemingly 2048 bytes minimum) 
are a Windows thing?

ELF seems to be a bit smarter about page loading, it doesn't require 
explicit padding to page boundaries in the file itself, so can generate 
smaller exe. (It's possible with PE too with some hacking).

Andreas is supposed to give it a try this week.

very nice, doc. the ELF hello works like a charm here :)

This function differs in that it has no parameters, only a return 
value. Might have something to do with it

Actually, this name truncation is in the symbol table, so it's a 
bug in the Red code generator that doesn't disturb WINE if the function 
isn't called

The preprocessor is a bit too aggressive.

so sticking to the C convention of ALL_CAPS_DEFINES is probably a 
good idea (at least for now) :)

That would be safer, until we get a smarter one.

I thought about adding a full macros system, I think it will be useful 
until we can compose Red/System code from Red itself.

Once that definition fixed in %ZeroMQ-binding.reds, I can compile 
working versions of client & server...testing...seems to work ok, 
the server is receiving a list of Hello messages from the client. 
:-)

Is the preprocessor necessary at all? It's usually much nicer to 
implement this functionality at a more integrated level in a language

Currently, a default format is applied depending on the REBOL binary 
used.

You can compose Red/System from REBOL in lieu of a preprocessor, 
until the compiler is ported to Red.

I wanted to get back to the roots (80's for me) of computing, a time 
where an entire OS + programming langage could fit in a 16KB ROM 
;-).

Eh, you can do a lot in 510 bytes!