AltME groups: search

am I correct that there is no interactive console yet and you need 
to compile source code?

Pekr: I had fun too working on low-level with Red/System, but it 
takes a lot of energy while working at Red level is a lot more relaxing. 
;-)


But this is short holidays, once Red gets mature enough (I bet on 
a couple of months), we'll start working on Red/System v2 (rewritten 
in Red, with a new compiler & linker architecture). This will give 
up the opportunity to reboot Red/System, fix a few design decisions 
if required, extend it, and get a clean and lean new code base in 
Red. I plan to write some architectural specs about the target compiler 
before starting, so all contributors will be able provide me with 
feedback before we implement it. Trust me, you _will_ like the final 
compiler! ;-)

Sure I speak for many who are [silently] watching this and waiting 
for it to mature to the point where we can usefully contribute.

Ashley: that point is closer than you might think. Even at bootstrapping 
stage, once Red get enough Core features, you and any other reboler 
will be able to add new libraries or port existing one from REBOL 
(should be trivial in most cases). That's not limited to mezz code 
though, you'll be able to add bindings to pretty much anything, protocols, 
provide Red plugins for 3rd-party apps (browsers e.g.), even make 
a View clone if you want (that one could even be a community project). 
:-)

New macros system and Red/System fixes retrofitted from v0.3.0 to 
master branch.

We'll probably merge all in master by the end of the month and celebrate 
the first Red alpha release.

The output I'm seeing on both Linux and OS X is the same as on V0.3.0 
before you applied the patch.

All tests pass on Linux and OS X after latest master branch commit. 
Thanks.

For those who are excited about what Doc is doing, please remember 
to continue donating.  He's devoting all his time and work to Red 
at this point.

Doc, you mentioned that the problem with Paypal is that they'll limit 
your total donation amount per year ... for now that works.  To avoid 
large wire fees for those who want to donate, perhaps you could set 
up a US bank account, and then wire money to your account in your 
country, after funds have collected.  If you need help, please let 
me know:  reverse "g r o  tod  z r a t i u g  ta  codmorf"

Nick: thank you very much, I appreciate such help and "continue to 
work without interruption" is really all I desire. I'm afraid anyway 
that donation would not be enough with the current community size, 
so I will probably start searching for other ways of funding by the 
end of the year.

Has anyone here worked with OAuth and/or the etzy.com API in REBOL? 
 I'm currently looking through Christopher Ross-Gill's OAuth implementation 
for Twitter, and interested in writing a REBOL app using the etzy.com 
API.  I understand most of it, but don't get the "oauth_signature" 
spec.  Don't have much time for this, so would like to offer some 
$$$ for anyone able to instruct and or provide help implementing 
the etsy API.  Email reverse "g r o  tod  z r a t i u g  ta  codmorf"

Please remember we want to contribute but without a reasonable clue 
this is hard to do. (Besides the closed-source issue this is what 
Carl ran into when expecting others to contribute). Me and Github 
wil never become friends for example, I managed to get some source 
long ago but no clue how to update to the newest sources and github 
has informed me they do not wish to support their macosX tool for 
Leopard that I am running, nor remove the useless (?) check on OS 
number 10.5, and I am NOT updating my system and learning all the 
commandlines to upgrade etc is too much effort, (maybe someone can 
build a REBOL interface).

I don't think you should use syscalls. It's not the POSIX interface: 
that is implemented in the C library on Linux, and probably most 
other systems

I did write a ftp, smtp and hylafax protocol for R3

And imap, and a JDBC bridge

But they were just first passes waiting for Carl to have a look and 
give advice, which never came, so they never went past that stage

This is the ftp scheme Andreas and I did https://github.com/gchiu/Rebol3/blob/master/protocols/prot-ftp.r

I will probably host a server that will provide packaged and selected 
libraries for Red (with builtin support in Red for getting them). 
For sharing code, my plan was to built some support for that right 
into the IDE.

And that's what I use dropbox for ...

I use it mainly as way to share data between all my computers and 
my mobile devices.

I'd like to see SIP and secure SIP eventually, and the ability to 
use video streaming :)

and concurrency? Kind of what Carl have planned? Don't remember where 
he briefly described it, but we once pushed him to say few words 
about it on Altme? Or maybe you plan on more lightweight solution, 
like green threading?

It would be nice if we had something like apt-get to fetch and update 
both yours and 3rd party software

We'll probably have something like an "import" function that would 
work locally and remotely from an organized online repo.

I've sent money to europe by bank wire, and it's very expensive. 
 Best if you can setup a US bank account when you're next visiting 
the USA ( if that is possible for non residents ), or an E*trade 
account.

Race condition on return value from mmap call. If address was too 
high, it was failing the safety check (testing for negative values) 
and wrongly triggering the error. ;-)

Finally got around to cloning Red from github and doing the test 
system and Red compiles. I hadn't done so since changing machines, 
so it's great to have it all work the first time out. Great stuff 
Doc.

Also, if someone is willing to make such a list right now and maintain 
it updated, that would be nice.

You just need to screen through %runtime/actions.reds and %runtime/natives.reds 
for changes. You could even make a short script to notify yourself 
when those files are modified using github's API. ;-)

Wrapping it in extra contexts doesn't help, because #define's and 
other things are global

The website needs an introduction/instruction section and a downloadlink 
to a zipped version of Red souces, so people can skip the github 
stuff.

# char should not be used for anything else but - preprocessor. And 
if it works like a preprocessor, we should stop talking about the 
ability to use inlined Red/System code anywhere in the Red source 
code ... :-)

Arnold: Red source zip links are on github since the beginning. Maybe 
you can write such presentation/instruction section, submit it in 
a gist, put the link here and on the Red ML, discuss with others, 
and when it's ready send it to me so I can review and publish it. 
I need to advance on Red construction rapidly now, so the website 
is currently lower priority to me.

Doc - maybe what does Arnold mean is just simple addition of Downloads 
section, and providing just few links for particular branches - https://github.com/dockimbel/Red/zipball/master
... but - we can live without it if other things are more important. 
But - there might be some truth to the fact, that not everybody is 
skilled to fight with Github "complexity". It was an obstacle for 
me too, although I found my way thru ... but only because of your 
help :-)

Branches: no, they are volatile, and I certainly don't want to have 
to thing about updating them on the web site each time I add/remove 
one...

I'll finish my new CMS first, or I should say publishing system together 
with the scripts I put on rebol.org lately. Then I will be able to 
publish code and story easier within my pages. I don't want the massive 
make-doc-pro and makedoc2 isn't my flavor. The ancient version from 
Chris Ross-Gill looks good but has some choices I dislike. So I am 
struggling with it too make it easy to use and with it I want to 
be able to generate a pdf version using Gabriele's pdf-maker script.

So 1 source and generate goodlooking webpages or pdf with it.

Then create some howto's and in time change from REBOL driven site 
to Red driven site.

Links maybe, but branches are not, they are created, live and are 
removed.

It is just there might be some rebollers, who are not fluent with 
github syncing tools, and we loose them for testing. Even Gregg admitted 
here, that he finally got it synced .... and Gregg is an experienced 
user :-)

I admit git is not an intuitive tool and it can be a PIA sometimes...but 
Github is the place to be and it's an invaluable tool for collaborative 
coding.

It's fair enough that #system code runs within the RED context, to 
be able to extend it and write the application code - although as 
I said, it's hard to know which names from Red's internal implementation 
will conflict. However, I need another place to import the core part 
of the bindings, outside the RED context so they won't conflict

Ok, I've added (not pushed yet) a new directive for including Red/System 
libs outside of 'red context. Example:

	#system-include [%tests/hello.reds]


will load and compile the hello.reds script. Notice that relative 
include paths are resolved from Red/System root folder (%Red/red-system/).

Does that cover your need Kaj?

Yes, I use relative include paths of that form in all my bindings 
and examples

I need them to be able to install my Fossil repositories side by 
side in one main directory and then #include between them without 
changing paths

No, trivial, I would then just remove #system-include and add an 
option to #system to have the code loaded outside of 'red context...but 
semantically, it will be a bit inconsistent with barebone #system, 
as it means "inline the Red/System code here"...Maybe I should just 
rename #system-include to solve that.

I've changed it to #system-global, work exactly as #system but loads 
outside and before 'red context, should I push it?

For the defines, I think the best option (and cheapest) would be 
that I prefix the one I use internally for Red.

That would really butcher all my bindings. And it's too much work 
just to do temporarily for the demo

It's NONE, but I really wouldn't want you to change that in Red. 
And it's just the tip of the iceberg

Reading all the discussion about R/S source inclusion in the Red 
- it seems pretty complicated and confusing at best. Apart from the 
three options discussed on friday, it is the "least powerfull" one. 
It is not any kind of inlining R/S code into Red from the runtime 
point of view, hence I wonder, why it is not simply called an #include? 
I know you might want to two cases now:

#include %some.red
#include %some.reds


But that's distinguishable, and unifies the naming, as well as it 
does what the name suggests - it is just preprocessor kind of directive 
for including either the red, or r/s source into Red ....

About your proposition:


- #include is for including files, not for inlining literal code, 
which is precisely the purpose of #system* directives.


- you can't use #include to include directly two different languages, 
that would be confusing for everyone and it's a semantic mismatch 
(making users think Red/System code can be directly used in Red with 
no clear separation between the two).


- #include is a preprocessor directive, #system is a compiler directive 
(processed during compilation)


- #system* directive are not complicated nor confusing, they are 
pretty simple and should look intuitive to C users (having the habit 
to inline ASM code into C). Those users are the target users for 
Red/System (remember that most Red users will never program in Red/System).

Well, not coming from C kind of languages, I actually used code inclusion 
rarely. The preprocessing stuff in any language looks arcane to me, 
but that's just my feeling, as it is REALLY a long time ago, since 
I used code -> compile -> link technique (CA-Clipper - 1998 :-)


So I better wait for more "clean" way - the other method you described 
- simply what I am expecting is kind of Rebcode - writing any function 
in Red, using Red/System or C or ASM, whatever :-) But most probably 
I am confusing and create a mishmatch even in such case :-)

Inline ASM: we might add that at some point, but you can already 
access some low-level CPU/FPU features (like stack manipulation). 
I will extend that in the future to support CPU in/out commands and 
direct registers reading/writing, so ASM support will be less necessary. 
Also, there's a cheap way to support it, adding the option to inline 
machine code directly in Red/System code flow (you would have to 
use an external ASM for generating the machine code). Something like: 
inline #{....machine code...}

Well, when CPU I/O instruction will be added, you'll be already able 
to make kernel drivers for Windows or Linux....and an OS is typically 
90% made of hardware drivers.

Pekr, if you are interested what action!s and native!s are currently 
available, I wrote simple parser that goes thru %actions.reds and 
%natives.reds and outputs list of all implemented functions.

I've added Red versions of Fibonacci and Mandelbrot to my C library 
binding, but they're just the Red/System code inlined in Red, with 
the timing code stripped out because I can't import the C binding, 
and Mandelbrot doesn't compile yet

So it's going to be a traditional Red/System presentation, with little 
Red and contexts

I've been very busy since yesterday on a new tool for Red: I've built 
a proper REBOL code profiler! (I wonder why I haven't done that since 
a long time...). I went through the profiler scripts on rebol.org 
and couldn't one suitable for my needs or that works with complex 
code, so I wrote one. It is able to deal with complex code, all datatypes, 
recursive calls and it's very simple to use.


Here's a demo profiling Red compiler (output is properly aligned 
when monospace font is used):

-= Red Compiler =-
Compiling red/tests/test.red ...

...compilation time:     40 ms

Compiling to native code...

...compilation time:     10189 ms
...linking time:         60 ms
...output file size:     37888 bytes
>> profiler/report/time


Function                       Count      Elapsed Time         % 
of ET

------------------------------------------------------------------------

compile                        1          0:00:10.249          100.0

comp-dialect                   205        0:00:09.659          94.24

fetch-expression               7505       0:00:09.628          93.94

comp-word                      5668       0:00:08.209          80.09

fetch-into                     427        0:00:07.519          73.36

comp-assignment                597        0:00:07.049          68.77

run                            3          0:00:06.492          63.34

comp-context                   21         0:00:06.398          62.42

comp-with                      1          0:00:05.565          54.29

comp-expression                3172       0:00:04.479          43.70

ns-find-with                   24277      0:00:03.962          38.65

finalize                       1          0:00:03.327          32.46

comp-natives                   1          0:00:03.274          31.94

comp-func-body                 180        0:00:03.271          31.91

comp-call                      2775       0:00:02.732          26.65

comp-func-args                 2861       0:00:01.862          18.16

find-aliased                   9650       0:00:01.86           18.14

resolve-type                   8032       0:00:01.799          17.55

get-type                       10758      0:00:01.546          15.08

ns-prefix                      21765      0:00:01.518          14.81

check-enum-symbol              7509       0:00:01.241          12.10

comp-block                     283        0:00:01.05           10.24

comp-variable-assign           417        0:00:01.034          10.08

The overhead of the current implementation is about 5-6 times the 
program execution time, so it's very usable. I will publish it today, 
and I hope someone will pick it up to improve it and add features 
(like a GUI front-end for the reports, with sortable columns).

BTW, as I was thinking, the above compiler profiling confirms that 
aliases and namespaces support are quite costly currently (ns-* functions). 
So now I know where to improve the code for better performances (not 
that it matters for the users currently, but it matters to me as 
I need to run the whole test suite dozens of time each day, and with 
the addition of now Red compiler, it (and will) adds up to a lot 
of waiting time at the end of the day).

REBOL code profiler released: https://github.com/dockimbel/Red/blob/v0.3.0/red-system/utils/profiler.r


Should work with any REBOL app. Documentation, comments and example 
included in file header.


Hope someone will pick it up and improve it (like adding functions 
sub-tree stats and a GUI). This is github, so feel free to fork then 
fix/improve.

Can someone tell me why for example in https://github.com/dockimbel/Red/blob/v0.3.0/red-system/utils/profiler.r
to use 

set 'make-profitable func [][] instead of make-profitable: func [][] 

because the second kind of declaration is also use in this script 
and I do not see why both are being used; you have a preference for 
one over the other so you use one, not both?

This also was meant for Rebol-school. Closing down AltMe and restart.....

Thank you Pekr. It is a little to subtile for my mind and current 
REBOL knowledge, I will have to live with this ;-)

@Arnold: I've pushed an update to profiler and I've made nested functions 
exposition to global context more elegant. ;-)

Cool! (for FB group and pythontutor.com)

Really nice - I thought the examples were canned at first, and I 
was thinking how tedious it must've been to set these up, but I see 
that it's all generated on the fly.

You can certainly carry this data in the arg1, arg2 and arg3 words, 
but it's a bit awkward.

Line numbers: there are complicated and costly to handle in a REBOL-like 
language at runtime. The experimentation I did in Red/System confirms 
it. I'm not sure I will add them to Red unless we can come up with 
an efficient solution.

Dockimbel, well, maybe it's bad design, but what I do generally is 
make error! in the deepest part of the code. When such a user error 
happens (which is generated by a plain make error! "something failed"), 
I disarm it and display arg1 in a dialog in the higher level code, 
if that makes sense. This way, errors are easy to identify and I 
don't have to make up schemes for return values. When a REBOL error 
happens at the same level, I let the program crash.

Marco: besides coding in Red/System, I don't see what you could do 
currently to speed it up. Here are some ideas for the additional 
coding that will need to be done:


You can write in Red/System some of the non-trivial natives, like 
e.g. set natives: sort, union, intersect, unique, difference. Other 
natives or support code we will need are codecs for:

- compression supporting these algorithms: deflate, lzo

- cryptography: MD5, SHA-1, AES, ...(all the required ones for SSH 
and SSL support)


You can port C code to Red/System, there are tons of available C 
source code, you just have to make it right (crypto requires accurate 
coding, implementations need to be deeply tested for flaws).

ok, just like in REBOL of course. Still it looks strange because 
I expect it to be there because there always is in other languages 
and it is a loop until a condition is met. So somewhere that condition 
must be tested to be true or false but indeed this part is more the 
definition of how the statement as a whole should be formatted in 
a Red program. I'm back on track, thanks!

might be worth starting with a TextMate bundle for REBOL and simplifying 
that, for Red/System

I can live without the line numbers, even in a R2 like error handling 
:) A lot of programming errors are development related and should 
never happen again once correct datatypes are passed on between functions 
so after this is done no further need for extra debugging statements 
here. User input is always wrong, they give wrong data and should 
be punished hard for that (Oh no that's Googles point of view) but 
the point is it should be tested to be what it should be and in that 
 way REBOL errors should rarely be reported by users. (just my 2cents)

what are the restrictions if you read the code and port it to another 
language without running any of the original code with the exception 
of test suites?

Henrik: something that works. I don't know what you want to use SSL/SSH 
for, but Red/System has a cURL binding. cURL usually uses OpenSSL 
and does most things you would want to do with SSL and SSH

Well, Rebol/Red headers are extensible. Is that really a problem 
to have a 'credit or 'licence field, and mention authors of particular 
components?

Ah, there's maybe something that you could do: I need to port my 
current Red test script in Quick-Test (QT) form. I can send you the 
script (very very simple) and the expected unit tests format used 
by QT, you would just have to convert it and check if all tests are 
reported as passing in QT...it's not a big task, but you will save 
me some time for advancing on the code. Interested?

And looks like they'll even host it for you gratis

Auto-sync Git and Mercurial repositories from Bitbucket and/or GitHub 

This add-on is turned on by default for Atlassian On-Demand customer

Including videos about Red installation and the bindings:

Graham: I was thinking it could be ready for end of year of beginning 
of next year. Currently Red is not for end users, and won't be for 
a while. Red/System could be used in production though, but I don't 
have time to write users docs or tutorials for it.

The easiest way would be to use Topaz and "just" add a Red-to-Topaz 
converter.

That sounds like a lot of work. On TryREBOL, Red and Red/System will 
be used directly

Agreed. Also a great introduction like http://learnyousomeerlang.com/
would help using the REPL and compiling Red.

And with string auto-scaling from 1 to 4 bytes per codepoints. ;-)

I can think of using to-head and to-tail. My opinion is you should 
have a more descriptive name for your variable. So length-of-cityname 
instead of length. The length could be of anything and the variable 
could be reused. Besides native English speaking programmers have 
always faced the fact that their prime candidate for variable names 
were taken because they were a reserved word. Imho so is should stay 
length? and not be length-of though that last one saves me from pressing 
a shift-key.

Will you be studying RT's code to see how everything was accomplished?


Certainly not!! The GPL precludes me from looking at the code, the 
risk is too high to unconsciously write similar code and infringe 
the license. It is even worse than that, all Red contributions implementing 
a feature that exists in R3, will need to pass through a peer-reviewing 
process to determine if it is a derivative work of R3 or not. The 
reviewing persons would be able to look at R3 sources, but doing 
so, would not be able to contribute code to Red. So I strongly advise 
current and future Red contributors that wants to add REBOL features 
to Red from looking at R3 sources.

so C to Red/System rewrite would have to happen anyway ....

 No!! Porting GPL code to another language falls under derivate work 
 clause too. If it wasn't the case, it would be too easy to workaround 
 GPL terms by porting it from language A to B, then from B to A.


There is a reason why most big software companies prohibit their 
developers from looking at GPL source code.

Yes, that's how GPL can be bad to non-GPL world.

Because rebol/red are so different than anything else it might at 
the end help people learn about this coding mindset / convention, 
and then they have more choices. Sometimes lang choice is highly 
determined by runtime also (by my own exp).. in this case having 
many runtime options (red red/system rebol topaz) is a good thing.

It's ironic that we will have a GPL interpreter and a BSD compiler. 
It's much more logical to have a BSD interpreter and a GPL compiler...

The frontier between both architectures is blurry in modern language 
implementations. Red final compiler will be able to work both AOT 
and JIT, so BSD is the way to go.

Nice. And I am glad you are continuing your work Doc.

And now Red speaks Chinese too: http://static.red-lang.org/hello_unicode3.png

Hello World in Chinese should probably be .. world hello and not 
hello world

I don't get any chars for Chinese, and in the Greek string third 
char is incorrect too ...

hello.red is already UTF-8, I just added one line and saved ...

Above works ... but when I write it directly in Notepad (and the 
file claims it is UTF-8), it does not work ... strange then ...

I used no punctuation char, just "e", then changed it to "e" (with 
hook above it), and it added that strange chars to the end of the 
string ...