AltME groups: search

Nice Doc, you could afford to get  your own robot to play with - 
and I agree it's unpleasant having to pause playing with it so long 
 - more often than we can afford to - for now, at least. Keep up 
the good work ...

I know I asked in the past, but - what is the minimal HW requirement 
for Red to be ported onto, and still being efficient? I mean - we 
were looking into Ubicom chipset replacement, and specifically at 
some PIC32 controllers, as well as ARM M controllers. I know some 
commercial development tools, which span across various chipsets 
....

The minimal requirements for Red would be something like: a 32-bit 
CPU or MCU and 1MB of RAM. 


For Red/System, a 32-bit CPU/MCU and 32KB of RAM (at least 1KB for 
stack) would be enough to run some small programs. A 8-bit version 
is still possible though.


ARM Cortex-M controllers: no problem for running on them as long 
as we implement a Thumb instruction-set backend (could be merged 
with current ARM backend).

Depend on what you mean by "debug version" and what debugging tools 
you're thinking about. My plan for Red is to deeply integrate it 
with the IDE, so that you'll be able to have advanced debugging capabilities, 
like step-by-step debugging. Such feature could maybe also be ported 
to the console version, so you'll be able to use it even without 
the IDE installed.


Also, I have thought the Red execution architecture to be as reflective 
as possible in order to try to support memory image loading/saving 
and stopping/resuming (think Smalltalk). It's very tricky (not sure 
we'll have it in the end), but if we can achieve it, you'll be able 
to get a snapshot of a running Red program on file, transfer it and 
resume it somewhere else....ideal for reproducing exact bugs occuring 
conditions. EDIT: the right expression for that is "Image-based persistence".


In the meantime, we already have some "debug mode": -d switch for 
Red and -g switch for Red/System (we'll probably adopt -d for both, 
-g will be reserved for gdb support). It's mainly intended for internal 
usage for now, the Red/System one can be useful to locate runtime 
errors in source code (usable, but still needs some fixes though).

As long as I don't have to tug the IDE around, then it all sounds 
great. :-) Sometimes you just want to spend 10 seconds installing 
Red and then quickly run a script, just like REBOL.

Yes, all actions and natives work from the stack. Sometimes they 
are just wrappers other equivalent functions that pass arguments 
in a classical way, so they can more easily be called internally 
by other parts.

Strange concept

 It looks pretty classic to me, but there are some specific reasons 
 behind such choice, that I will detail them in a future blog entry. 
 Basically, it simplifies the tracking of Red values on stack (making 
 the work of the GC easier) and stack serialization becomes almost 
 trivial (to memory, for continuation support, or to file, for image 
 support). I think that R3 doesn't do it that way, but probably uses 
 recursion, passing all R3 values on C stack instead. It's a faster 
 approach but less flexible.

Kaj, I just watched your talk. It was great, but you can probably 
benefit by putting in a diagram or two, showing the relationship 
between REBOL, Red and Red/System.

Thanks. I know, I'm low on glitz. It's because I don't want to take 
the preparation of those talks more time than they already do. I 
prepare by making sure that as much as possible works, and then I 
do a guided tour of it on the machine itself

It's the same reason why I have written only limited documentation. 
I have to prioritise my time to do the things that I need myself, 
and I don't need the documentation and the presentations that are 
a goal in themselves

R2 and R3 use their own stacks, though recursive PARSE may use the 
C stack. The stack frames of R2 and R3 are different, but I wouldn't 
be able to tell you how.

Thanks Arnold, all donations count and are much appreciated. I'll 
see what we can do for "numbers representing money", but anyway they 
will be less flawed than in REBOL (no approximated internal representation). 
;-)

Pekr: your remark about the stack made me think about it. I might 
change a bit the current internal API, collecting arguments from 
stack in trampoline functions (actions.reds) instead, and then calling 
datatypes-specific actions passing them the arguments directly. This 
would reduce the runtime code size a little bit and might simplify 
the construction of the future public API. I need to see first if 
they are drawbacks before deciding to refactor the code in that way.

I have finally recovered after my credit card fraud. I (hopefully) 
sent 50 EUR, Doc. Please let me know if it arriwes, as for the first 
time, the last name on my Card contains czech char, and my Paypal 
profile does not have any. Hopefully it all resolves well ...

Perhaps some discussion about forming a Red foundation would be helpful 
to organize anticipated future actitivies involving community relations 
or other activities that will keep Doc and other core developers 
from focusing on code.

Thanks for your work and vision Kaj.  It's so appreciated!

Nick: thank you very much for this initiative, it certainly helps 
me keep focused on Red and not have to worry about how to pay my 
bills next month! I hope others will continue to donate, so Nick 
won't need to take all the burden on his shoulders.

Weren't you running bare Debian? That would probably expect you to 
install and configure more yourself

Arnold, the Raspberry is just a motherboard, you'd need a power supply 
and cables at the least :-)

All I can run is empty.reds, Fibonacci, PeterPaint and SQLite

And hello.reds, but not hello.red

Also saw a typo, I read the document further tomorrow and note all 
typos I see.

Maths op missing in BNF rules: good catch. You can add them and submit 
a pull request on the master branch.

Well I changed some text in this file, I changed it online in a black 
background box where I could not see my cursor nor the arrow pointer, 
so it sucked :( 

I thought it would be possible to edit the file offline but that 
is something to find out how to do next time ;)

Now I added a comment and it says I want to commit 182 changes into 
the master branch, which is not what I want, but Github says I want 
that. Including my comments it could be I typed in total 182 characters 
including the ones I deleted (?) but the 182 are the commits from 
the 0.3.0 branche I think. 

Me and my friend Github >:|

:-) They are plenty of git / github tutorials online, you might want 
to go through one of them. Having basic git understanding is required 
if you want to contribute code to Red, otherwise, it would take us 
much more time to review and accept it. Anyway, I agree that git 
is unnecessarily complicated, even Linus says it's not for everyone. 
We'll see how Red can solve that once it is mature enough.

Agreed did one today but it was for git not for github. As github 
doesn't support OSX10.5 with her github for mac program I am temp 
stuck. maybe a REBOL script can take over the git commandlines for 
me. I go and try that to take me over the githurdle.

I can't accept your pull request, it's a complete merge of different 
branches (you're probably mixed up several branches, or you haven't 
rebase before submitting the pull request). You need to submit only 
the changes you did. For that, you need to have a clean codebase 
and up-to-date wrt the branch you're modifying.

I managed to get it via the terminal but only the master not the 
0.3.0 

I want the 0.3.0 version of this file for that one contains the corrected 
typo you fixed, no need to manually correct then. 
And I want to give it then back to the 0.3.0 branche but no way. 
I'll mail my file to the mailinglist :(  github g=sh ;)

Arnold: the changes you did that were accepted have been pushed to 
master branch too and are now published on red-lang.org. For documentation 
changes, the master branch version is the one that gets published 
on the web site.

btw - once 0.3.0 is out, what about a blog post, summing what is 
already available? Maybe a short script? btw - do we have conditions/branching 
and loops yet?

Yes (both modulus and remainder operators). Of course, this is for 
Red/System, Red doesn't have yet floats support.

Red [] 4.0 // 2.0  compiles and runs.

Sorry - Red/System[] 4.0 // 2.0 compiles and runs.

And also - do I need to know, which platform I need to support, or 
support can be in one exe, for both worlds?

We'll provide compilation options and various additional targets 
to deal with those different ABI.

Same here, a little tour would be nice. (That is why I picked up 
a documentation check to start with). 

e.g. In actions.reds most of funtions are only present as 'name* 
and some are present as both 'name and 'name*

Fixed the math library in the C library binding; should now also 
work on OS X and Android

Kaj: do you have a simple callback case that's failing on ARM and 
not using floats at all?

Hi Doc, did you plan to integrate some Open CL programming acces 
to Red in any future ? Here is a summary of kernel programming with 
OpenCL - and to me this seems accessible to Red, some day : http://www.manning.com/scarpino2/ch04sample.pdf
 for a larger picture summary of the beast here is the link to the 
book I referred to :  http://www.manning.com/scarpino2/(this is 
the Manning's publiaher deal of the day ,,, that's why I talk abotu 
this now). May be just a new binding and some extensions are required 
- but I would like to know more about the actual modifs required 
- when a small time is affordable for you to answer ?

OpenCL: yes, I have that in mind too, but it's most probably for 
a later version of Red (> v1.0). Also I have other plans to give 
Red access to GPGPU, by directly having a GPU machine code assembler 
and a dialect on top of it. It would be mainly for compiler internal 
use, but such dialect could be exposed for user code if some are 
willing to implement some fast GPU-powered routines.

If you're doubting about such approach, read this article:

 http://www.geeks3d.com/20110317/low-level-gpu-programming-the-future-of-game-development-on-pc/

In between, here is the PyOpenCL lib link for those interested to 
see how the OpenCL API is accessed by other languages - and this 
could pave the way for some Red binding ... http://mathema.tician.de/software/pyopencl

I'm working on it, the fix is fine, but it seems it doesn't work 
with __libc_start_main call (and only that one).

Both cURL and SDL audio test are now working fine on my RPi.

I'm now running my RPi headless and using it remotely through VNC 
and ssh. Maybe the error is related to that?

Kaj: for debugging the GTK issue, we need a minimalistic app. Could 
you re-implement the hello-GTK-world using only direct GTK calls 
and not going through typed functions? We could at least see if it's 
related to GTK calls or not.

so, are ARM fixes almost complete now, and is 0.3.0 going to be oficially 
out soon? :-)

Some blog article about what 0.3.0 brings to the table, would be 
nice then, to show ppl what is implemented, what one can do already 
in Red (eventual list of supported dtypes, natives, actions?), and 
what comes next? That would keep ppl motivated ...

Elapsed time is reporting a weird number in Fibonacci and Mandelbrot. 
I suppose that's due to running ARMEL code on an ARMHF platform

They base themselves on Squeak, the traditional Smalltalk educational 
track, with Scratch on top, and Python thrown in to appease the rest 
of the world

Get Cyphre to do a modern View like engine, and we will be kings 
- just believe me :-)

I am in a hurry, I want to report them before release

 drive faster so you will be home before you are out of gas.  "But 
 yes, it's the domain I always wanted to target with REBOL" the domain 
 you want to target is the world isn't it?


I am studying the Red and Red/system sources these days to get more 
of a feeling what is going on.

It looks like there are only function and context definitions. WHere 
does the code start?

Not exactly, I read rsc.r as if system-dialect is not set then start 
with the compiler.r script. (after that or else the rest of the script 
follows) but then is has some do other scripts and a modular part 
and the other scripts are modular too. It look all very sound bu 
somewhere <there must be/I expect> a first action or function call.

With Red we can target the world, before that with REBOL we had to 
be more limited. And also, one targets domains that others haven't 
satisfactorily addressed yet. New land is easier to inhabit than 
occupied land

I really can't understand how the UI stacks nowadays can dare produce 
slow results, with CPU and GPU thousand times more performant than 
the poor A500.

There's something deeply wrong in the way most so-called "modern" 
OS/desktops are designed. My 133MHz Bebox with a poor PCI video card 
was able to provide a very responsive UI, even under heavy load.


The RPi feels like dying as soon as you launch the lightweight (no 
kidding!) web browser Midori...Of course, the browsing is very slow...I'm 
quite disappointed by that and it's not the hardware fault, the RPi 
is a great platform, but the software stack sucks a lot.

Inlined printing fix confirmed working on ARM with Fibonacci and 
SQLite

The thing is that they made software so complex, that it has become 
extremely hard to point your finger at where exactly it goes wrong. 
We had to build Syllable to get an idea of some of those things, 
and then nobody wants to believe you

Doc, quick license question: Was the BSL chosen because it allows 
you to distribute a binary without requiring that you distribute 
the license, unlike MIT and almost all other open source licenses? 
Would it be a problem if you incorporated Apache licensed code, which 
doesn't distinguish between source or binaries in this? You probably 
wouldn't have to actually include the license with the product, only 
in a web site or help file somewhere...

No, just "given". And the requirement to provide copyright and license 
notices only applies to source distribution.

Sure, but if you don't include the licence and don't code into the 
program where to get it, you're not "giving" it at all

If I put a link on my web site then I'm giving it. I don't have to 
include it, just give it. With BSD and MIT licenses you have to include 
it though.

BrianH asked: "Was the BSL chosen because it allows you to distribute 
a binary without requiring that you distribute the license, unlike 
MIT and almost all other open source licenses?"


With the sole 3-clause BSD, users would need to provide a copy of 
the license with each compiled program, because of the runtime code 
included. So to avoid that, we chose to publish the runtime parts 
of Red and Red/System, under the more permissive BSL terms. The binaries 
that include the compilers (currently that would mean encapped version 
of Red and Red/System compilers) are still under BSD.


When Red will be self-hosted, it will include a JIT-compiler that 
will need to be released under also BSL or similar terms.

Then there's also the class of unlicensed code. It used to be that 
things were sold, not licensed. Software wanted to put that on its 
head, but other things are still simply sold, and so can software

Or rather, our grandchildren might, barring further extensions of 
the copyright terms. I suppose that Ada Lovelace's work and maybe 
Jaquard loom programs have fallen into the public domain, but the 
rest of the public domain code was released to the public domain 
explicitly. Almost the entire history of computing is more recent 
than Steamboat Willy.

If you see the amount of scripting that's been done for Algodoo, 
you'd be impressed - and that language has nowhere near Rebol's strengths.

No, haven't looked myself, but I know from reading things here and 
there, that Emil has the idea of re-working/re-thinking the scripting 
language.

If you can speak with him, and get some technical details, maybe 
there's some potential, especially if he gets help from the group.

And they seem to have some marketing savvy

I'd urge you to just download it and try it. If you love Rebol, I 
guarantee you'll love Algodoo.

Algodoo, is pretty slick. Both in what it does and in looks.

And probably fun :)

The other reason I brough it up now is that community sharing is 
a pretty big part of Algodoo and so a chat/collaboration feature 
would be great to have.

I'm reading and downloading right now :)

My daughter married John Resig's brother.  Long conversations.  John 
is a good guy, a human-centered technology sort of guy.  Saw the 
DOM and went yuk.  I've got to do something about this.

As for me, I can see it as a chat. I am not sure it scales well to 
replace Altme like product, but maybe I am wrong. I liked IOS model 
with pluggable handlers, and I would also probably made the back-end 
SQLite based ...

He would in the past however accept fixes to it, and posted a guide 
on how to extract the sources.

Congrats NickA on the nice and big work!

@NickA: About enhanced r3 chat, have a look to %wchat.r in the %OpenMe/ 
folder of this Altme world.

Basically its %chat.r but it act as a proxy between the Devbase server 
and the browser. The goal is that the browser replace the CLI interface 
: not typing command in CLI but cliking link in the browser.

Its just a start. There is some work to do to handle POST request 
and then allow posting. + enhancing HTML presentation.

And that's what @rebolbot sees too now http://chat.stackoverflow.com/transcript/message/8019099#8019099

Kaj: it works now from command-line on Win7 and an icon for an hidden 
window appears in the task bar.

Thanks, Doc. After fighting for a day and a night with the XP machine 
to keep it from self-destructing, I could test that audio playing 
also works on XP now - but no task bar icon...

But that is such a minor nit to pick, that you should ignore it and 
just hear the part where I say "Go Kaj Go!". :-)

Ah, now that I click them--and remember--I get it. My gut said that 
Available Words would give me a matrix with the languages at the 
top and a list of words available in each.

e.g. col 1 would be a union of all available words, and each row 
would have a check if lang-x supports it.

My objective is to move forward and spend as little effort as possible 
to be able to fight another day. So I must try to ignore the legacy 
languages as much as possible

This is fantastic Doc. I know it's still very early days, but you 
are making great progress and it's very exciting to see it come to 
life. When I copied the commands from the new blog entry, to build 
the console, and it worked the first time, perfectly, it made my 
day. Then, even doing just simple things in the console was fun.

But if you define a routine in a Red script, and then DO it, it will 
work. You can also build a custom console by writing a Red script 
and adding at the end an %include %<path-to>/console.red.

if you define a routine in a Red script, and then DO it, it will 
work.
 => the script needs to be compiled for that to work.

I will do it myself if nobody else steps in, once we get the target 
console implemented (Unicode LOAD, EXIT and RETURN supported,...)

And it's just a S3 bucket confiured as a website which keeps my costs 
down.

Andreas has pointed out that the http scheme uses several async handlers, 
and tcp level handler can create events to send to the outer http 
handler :(

@GrahamC: No, they are still running stock.  Seem to be quite reliable, 
much more so than most access points and wireless bridges out there. 
 They've been running for almost 6 years with no maintenance, and 
both units are outdoors.

I guess that you did not do make make and make prep?

make make and make prep are already strongly suggested anyway

And because it's not needed. The Linux-configured source - and even 
the binary Linux library - work fine on Syllable Desktop

Builds are not byte for byte compatible across Linux platforms, because 
they depend on compilers, headers and startup fragments from the 
compiler and possibly the assembler

I see. Thanks. I also tried to get the android version to run on 
my Nexus 7.No luck there so I went back to trying the test that was 
originally posted and I can't even get that to run. Sorry, you'll 
need a more experienced test. :-(

Just a request. If you do not want the default, you can use INCLUDE/ONLY 
and save it as you see fit.

OK, good. Next question. Why not make the new behavior the option?


I only use the linked files directly on rare occasions. I'm just 
wondering what the benefit is. And, at first glance, INCLUDE/FLAT 
seems clearer.