AltME groups: search

If it still doesn't work, we'll have to get your hands dirty by diving 
in Windows guts using WinDbg. ;-)

I mean - now we can make wrapper libs, coding almost in REBOL (syntax), 
no need to become dirty with C, and hence get more libraries to work 
with R2, via a wrapper libraries written in Red/System?

yes, to get one binary.

For static libs linking, if someone could contribute by providing 
a .lib and .a file reader/parser, that would help get that feature 
implemented sooner.

some kind of brige is required, if we want to get into an Android 
API. Ditto for .NET?

Porting / binding R3 GUI to Red shouldn't be hard to do. It's a lot 
of work but we would get a simple and fast to use GUI. One of the 
major USPs of Rebol. I don't know any other simple to use interpreter 
that gives you a GUI out of the box. And, in these app days, it's 
no longer so critical to support native look & feel in all aspects.

The callback attribute is added automatically to a function when 
passed as get-word. But there are some cases where  it needs to be 
manually set, like for the ***-dll-entry-point function from the 
runtime.

There are still a lot of details to work on, but the core part is 
there. The bootstrapping does had several complications (like literal 
series handling) that will vanish once we get Red compiler rewritten 
in Red.

There is a bit that is worth learning from R3's Unicode transition 
that would help Red.


First, make sure that strings are logically series of codepoints. 
Don't expose the internal structure of strings to code that uses 
them. Different underlying platforms do their Unicode APIs using 
different formats, so on different platforms you might need to implement 
strings differently. You don't want these differences affecting the 
Red code that uses these strings.


Don't have direct equivalence between binary! and string! - require 
conversion between them. No AS-STRING and AS-BINARY functions. Don't 
export the underlying binary data. If you do, the code that uses 
strings would come to depend on a particular underlying format, and 
would then break on platforms where the underlying format is different. 
Also, if you provide access to the underlying binary data to Red 
code, you have to assume that the format of that data can be corrupted 
at any moment, so you'll have to add a lot of verification code, 
and your compiler won't be able to get rid of it.


Work in codepoints, not characters. Unicode characters are complicated 
and can involve multiple codepoints, or not, but until you display 
it none of that matters.


R3 uses fixed-length encodings of strings internally in order to 
speed things up, but that can cause problems when running on underlying 
platforms that use variable-length encodings in their APIs, like 
Linux (UTF-8) and Windows/Java/.NET/OSX? (UTF-16). This makes sense 
for R3 because the underlying code is compiled, but the outer code 
is not, and there's no way to break that barrier. With Red the string 
API could be logical, with the optimizer making the distinction go 
away, so you might be able to get away with using variable-length 
encodings internally if that makes sense to you. Length and index 
would be slower, but there'd be less overhead when calling external 
API functions, so make the tradeoff that works best for you.

However, the part of the concurrency model that was designed so far 
affected the design and implementation of the system model and module 
system. You'd be surprised how much the module system was affected 
by the system, binding and interpretation model of R3; very little 
of its design and implementation was arbitrary. You might be able 
to get the syntax the same for Red's module system, but given the 
different system/binding/execution model there wouldn't be much of 
the implementation in common.

One hypothetical advantage you have with Red is that you can make 
the logical behavior fairly high-level and have the compiler/optimizer 
get rid of that at runtime. REBOL, being interpreted, is effectively 
a lower-level language requiring hand optimization, the kind of hand 
optimization that you'd want to prohibit in Red because it would 
interfere with the machine optimization. This means that, for strings 
at least, it would make sense to have the logical model have a lot 
of the same constraints as that of R3 (because those constraints 
were inherent in the design of Unicode), but make the compiler aware 
of the model so it can translate things to a much lower level. If 
you break the logical model though, you remove the power the compiler 
has to optimize things.

If you support different internal string encodings on a given platform, 
be sure to not give logical access to the underlying binary data 
to Red code. The get/set-modes model is good for that kind of thing. 
If the end developer knows that the string will be grabbed from something 
that provides UTF-8 and passed along to something that takes UTF-8, 
they might be better off choosing UTF-8 as an underlying encoding. 
However, that should just be a mode - their interaction with the 
string should follow the codepoint model. If the end developer will 
be working directly with encoded data, they should be working with 
binary! values.

Brian: implementing an abstraction layer over string encodings is 
a trivial task. The intended datatype model is very similar to REBOL's 
one, even more since recentl,y as I moved to an hybrid dynamic/static 
type system. I'll commit the new code in a few days, so you'll see 
how close to REBOL it can be.


I hope that this hybrid model will help us get the best of both worlds.

Wow!!! awesome .. from print "hello worl" to print "<html>...</html>" 
to make webapps is not that long way, I was just afraid you would 
never get to RED, Awesome!

Thery are called nono-credits because everywhere you want to exchange 
them you get to hear "nono"

I do not bother to obtain bitcoins. Vague draining of computational 
powers of my tiny computer to compute some hashes(????) to unknown 
benefit to get by chance(???) ome 50 bitcoins of a limited(who controles 
this, I have serious doubts here too) supply of them. I am a real 
bitcoin sceptic, sorry. But again I think the Red group is not the 
place to discuss this matter, not that I have much more to say about 
this.

About the paypal issue I have the same doubts about paypal as well, 
for this 2500 Euro limit is (I do not get any gifts) really restricting, 
when going to a bank that cooperates with the paypal organisation, 
you can set up a business account where you are no longer bound by 
this limit but then 'you' need to become a business.


Yes you can just exchange your currency, but there was NO return 
prestation delivered for the original bitcoin.

Doc, Services like Plimus or Fastspring probably have option to get 
you wire transfer or at least check (or some send you prepayed visa). 
Not eactly meant for your case, but if you don't find anything else. 
You could (I hope) make a "products" with them and then. I used them 
for similar transactions when nothing else could come into play. 
Paypal wasn' working here either and even now it's very clunky to 
retrieve the $$ from it.

I'm looking for the first "trivial to implement" to get started as 
quickly as possible

I would prefer Red to compile either to the directory, where the 
source is by default or at least not to the system/options/home path, 
but to the path I get with pwd

I got math ops for integers working, but I think it's time we get 
a better macro system.

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! ;-)

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). 
:-)

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).

Note that you need to get the system page size with sysconf():

Syscalls: given how much a programming language has to call OS services, 
I don't see why we shouldn't try to avoid an unnecessary layer. But 
I'm pragmatic, if we get more troubles than benefits, we'll adopt 
a more classical approach.

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

just one link - to the github red site ... then user should orientiate 
himself there ... nowadays visiting Red-lang.org does not suggest 
clearly, where one could get Red to give it a try ....

But - sort your priorities yourself, no reason to get distracted 
....

It's worse than that. The first error I get is on one of my #define's 
that's a struct! later in Red

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

Their stance is clear. The whole world has already complained, so 
this is what you get

I don't understand following syntax - is that just a word? 

s: GET_BUFFER(data)

Then I am dumb - R2 does not allow being it a word, nor is it a function 
... so, what's that? Well, some tests, uh, surprised :-)

>> GET_BUFFER: [1 2 3 4 5]
== [1 2 3 4 5]
>> GET_BUFFER: [1 2 3 4 5](escape)
>> data: 4
== 4
>> GET_BUFFER(data)
== 4
>> GET_BUFFER/:data
== 4

>> [GET_BUFFER(data)]
== [GET_BUFFER (data)]

;-)

Pekr maybe try this instead of with 1 2 3 4 5 
>> GET_BUFFER: [a b c d e]
== [a b c d e]
>> data: 4
== 4
>> GET_BUFFER(data)
== 4
>> GET_BUFFER/:data  
== d
>> GET_BUFFER/(data)
== d

how to get a free license for any of their listed products http://www.atlassian.com/software/views/open-source-license-request

Agree something is needed ... there is no easy guide to get started

The next step would than be to get the REPL for Red.

I'm talking about eventually, when/if you get real runtime word types 
:)

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

going to lunch, willing to debug, if I can get any instructions ....

third char in Greek HelloWorld is still not resolved ...
 What do you get instead of the "i"?

doc - in the greek case I get just a square ...

Not yet ... deleting all the repository. I deleted hello.red, and 
no way I can get tortoisegit to get it sync - it just keeps telling 
me I am uptodate

Are you sure you're not using Lucida? When I switch to Lucida, I 
get that 3rd greek character issue.

The one thing R3 was bereft in was custom conversion functions. We 
had some ideas, but for the most part didn't get around to implementing 
them.

well, as for BB 10 - we should get there imo - QNX based, old Amiga 
friends :-) And maybe it is good to support lower market, than crowded 
iOS developer's base? We will see ...

Agreed. And it will be easier to keep an API clone updated for future 
SQLite changes, so we can get the benefits of future improvements 
to the storage engines.

Hi guys - I am trying out Red/System and all seems very good until 
I try out Kaj's fibonacci and mandelbrot functions. I downloaded 
the c-library -sorted the paths and locations and tested the library 
on simple things and all compiles well. When I try to compile fib 
and mandel I get the following compilation error:

Kaj, downloaded the Zip file from Fossil and re-ran (after sorting 
paths to files) and get the same problem as already posted. The problem 
is not file locations as that results in a different compiler error 
which is easily sorted. It seems to me in the problem I have posted, 
the compiler thinks there is already an alias called str-array! - 
however I have searched every reds file and there is no other with 
that name! Anyway, it is not urgent but I just wanted to feed back 
my findings to you.

I hope that a lot more Rebol coders get on-board with Red to help 
Doc and speed development - Red is the future I think, not interpreted 
Rebol, as brilliant as that has been in the past.

My goal with the bootstrapped current version was to try some experiments, 
as all the current REBOL code will be trashed at the rewrite in Red 
stage. I wanted to see how far I could get with very simple design, 
so I can test how REBOL features can help or get in the way for writing 
complete compilers.

This coming saturday october the sixth,  Kaj will show his work (in 
progress) to get the Red Programming Language running on the Raspberry 
Pi.

REBOL publishing libraries and tutorials like this for other popular 
web APIs.  Get a bunch of big web sites linking to REBOL sites, and 
their developer communities all taking a look at REBOL, and there 
will be curiosity and added traffic.

For testing some of the bindings, here is information where to get 
the C, cURL and 0MQ libraries:

To get a clue which binding/library an example program uses, look 
in build.r

Rebol [Purpose: {make wikibook entry}
Author: "Max Vessi"
version: 1.0.0
]
my?: func [
    "Prints information about words and values."
    'word [any-type!]

    /local value args item type-name refmode types attrs rtype temp
][       
    temp:  copy ""
    if all [word? :word not value? :word] [word: mold :word]

    if any [string? :word all [word? :word datatype? get :word]] [
        types: dump-obj/match system/words :word
        sort types
        if not empty? types [
            print ["Found these words:" newline types]
            exit
        ]
        print ["No information on" word "(word has no value)"]
        exit
    ]
    type-name: func [value] [
        value: mold type? :value
        clear back tail value
        join either find "aeiou" first value ["an "] ["a "] value
    ]
    if not any [word? :word path? :word] [
        append temp reduce [mold :word "is" type-name :word]
        exit
    ]

    value: either path? :word [first reduce reduce [word]] [get :word]
    if not any-function? :value [

        append temp reduce [uppercase mold word "is" type-name :value "of 
        value: "]

        append temp either object? value [ reduce ["^/" dump-obj value] ] 
        [mold :value]
        exit
    ]
    args: third :value
    append temp  "= USAGE: = ^/ "

    if not op? :value [append temp reduce [ uppercase mold word " "] 
    ]
    while [not tail? args] [
        item: first args
        if :item = /local [break]

        if any [all [any-word? :item not set-word? :item] refinement? :item] 
        [
            append temp reduce [append mold :item " "]

            if op? :value [append temp reduce [append uppercase mold word " "]
	    value: none]
        ]
        args: next args
    ]
    append temp  "^/" 
    args: head args
    value: get word
    append temp "^/= DESCRIPTION: = ^/"
    either string? pick args 1 [
        append temp reduce [first args]
        args: next args
    ] [
        append temp "^/''(undocumented)''^/"
    ]

    append temp reduce [ "^/^/"uppercase mold word " is " type-name :value 
    " value."]
    if block? pick args 1 [
        attrs: first args
        args: next args
    ]
    if tail? args [exit]
    while [not tail? args] [
        item: first args
        args: next args
        if :item = /local [break]
        either not refinement? :item [

            all [set-word? :item :item = to-set-word 'return block? first args 
            rtype: first args]
            if none? refmode [
		append temp "^/= ARGUMENTS: =^/"
                refmode: 'args
            ]
        ] [
            if refmode <> 'refs [
                append temp "^/= REFINEMENTS: =^/"
                refmode: 'refs
            ]
        ]
        either refinement? :item [	   	  
            append temp reduce ["*'''" mold item "'''"]

            if string? pick args 1 [append temp reduce [" -- " first args] 
	    args: next args]
            append temp "^/"
        ] [
            if all [any-word? :item not set-word? :item] [
                if refmode = 'refs [append temp "*"]
                append temp reduce ["*'''" :item "''' -- "]

                types: if block? pick args 1 [args: next args first back args]

                if string? pick args 1 [append temp reduce [first args ""] 
		args: next args]
                if not types [types: 'any]
                append temp rejoin [" (Type: " types ")"]
                append temp "^/"
            ]
        ]
    ]
    if rtype [append temp reduce ["^/RETURNS:^/^-" rtype]]
    if attrs [
        append temp "^/= (SPECIAL ATTRIBUTES) =^/"
        while [not tail? attrs] [
            value: first attrs
            attrs: next attrs
            if any-word? value [
                append temp reduce  ["*'''" value "'''"]
                if string? pick attrs 1 [
                    append temp reduce [" -- " first attrs]
                    attrs: next attrs
                ]
                append temp "^/"
            ]
        ]
    ]
    editor temp
    exit
]

After the mirror game and the chessboard interface, the Red compiler 
script and various cgi scripts and showing all how radio buttons 
work in VID, I can now introduce to you the application to play checkers 
(10x10 international, in dutch dammen). Not bad for a REBOL newbie 
right? Wait a moment with all of your nominations please, because:

There is a tiny issue left with the moving of the pieces when playing 
against the computer but it is minor compared to all other issues 
I have already fixed ;-)


You can download the zip file with the program here http://arnoldvanhofwegen.com/stuff/damscripts.zip

Program is started with do %damb.r and you can play after setting 
the color the computer has to play with on the panel you get when 
you click the top-left button. You can look under the hood and see 
the values the program gives the legal moves. You can put your own 
positions on the board and continue from that point.
Enjoy!

Updated our R3 version. Changes:


- no longer links libstdc++ dynamically but statically. You get an 
error that libstdc++-6.dll is missing from your computer.

- changed startup procedure to support correct stdio redirection 
in console mode (used if you start R3 with a command line argument, 
else GUI mode)

Posing this question to them now. Will get back to you.

Well, now on to creating a new "save-the-world-open-source-license". 
Why is it so hard to just pick one like MIT and release the code. 
Every day we loose, we can't get back. I expect this licensing thing 
to take at least 12 months. It's just waste of time.

Maybe you can get the columns the same height again? No I just wrote 
it to point this out in case someone doesn't notice.

until something is tested in court (in your country) its dangerous 
to assume.    Goggle's recent java API court issues shows how you 
can get in trouble over things which even seem pretty clear.

Here is the FSF FAQ entry relating to interpreters and their libraries: 
http://www.gnu.org/licenses/gpl-faq.html#IfInterpreterIsGPL

Pretty much the whole entry is applicable. The first paragraph would 
apply to data passed to DO, PARSE, DELECT, DO-COMMANDS, or other 
dialect processors.


The second paragraph would definitely apply to extensions, and could 
apply to built-in functions unless we get an exception like GCC's; 
or we could get a FAQ entry declaring that the functions built into 
R3 are "part of the interpreter" rather than "library code", despite 
R3's actual system model. Note that PARSE's built-in operations are 
more unambiguously "part of the interpreter", and the same could 
be said for other similar dialects.


The last two paragraphs apply to mezzanine code and embedded modules. 
If they are GPL'd and your code uses them, it would be affected.

...could apply to built-in functions unless we get an exception like 
GCC's;

 - again, wrong. The built-in functions are related to the functionality 
 of the program, which is unrestricted. The problem with GCC (why 
 there is the need for the exception) is that the functions needing 
 the exception are the ones provided and statically linked in the 
 extra libraries.

Ladislav, most of what Andreas and Maxim are saying here is true, 
but it doesn't matter. Reading comprehension requires reading the 
whole thing. The relevant part you missed is:

    or we could get a FAQ entry declaring that the functions built into 
    R3 are "part of the interpreter" rather than "library code", despite 
    R3's actual system model.


I am actually an expert on R3's system model as it relates to dynamic 
linking of code, and how code is bundled, since I wrote most of the 
code that does that. The mezzanine code is dynamically loaded and 
linked in the startup code, and is statically linked as data into 
r3.exe, so as far as copyright is concerned it is linked two ways. 
At least in the laws of the country of origin of REBOL, the code 
vs. data distinction is irrelevant to whether the code/data is covered 
by copyright, or the GPL, which only relaxes copyright. All that 
matters is that the mezzanine data is statically linked into the 
program. For that matter, it's not even bundled as a resource, so 
it's really hard to make the "mere aggregation" argument even if 
they weren't explicitly in the same program. Embedded extensions 
and embedded REBOL code are both statically linked into the program, 
and are both dynamically linked at runtime.


Nonetheless, that system model doesn't have to matter. A published, 
official FAQ entry (or even a blog post) can be used as evidence 
in a trial, so a FAQ entry that clearly states that all bundled native 
and mezzanine code is "part of the interpreter" would be sufficient 
to make it so our scripts whouldn't be affected by R3's GPL at runtime. 
Without such a FAQ entry it could be plausibly argued in court that 
your code is dynamically linked to GPL'd code, which would then extend 
GPL requirements to your code. With the FAQ entry, it's unambiguous.

'or we could get a FAQ entry declaring that the functions built into 
R3 are "part of the interpreter" rather than "library code"' - that 
is where I do agree with you, except for the fact that we do have 
such an indication:


1) the functions *are physically/* part of the interpreter, they 
are "linked into it" (I would say "statically", since the interpreter 
does not need to look for them "elsewhere in the system", they are 
"inside")

2) the functions are a part of the interpreter, the interpreter documentation 
specifically mentions the functionality of the interpreter (the documentation 
mentions that the "ordinary version" of the interpreter "understands" 
FUNC, DO, PARSE, whatnot...)

when I execute these, I get no output

Kaj, Installing relevant libraries? So how do I get dyld: Library 
not loaded: /usr/lib/libgthread-2.0.dylib
for RedSystem/hello-GTK-world

Rebol [Purpose: {make wikibook entry}
Author: "Max Vessi"
version: 2.0.0
]
my?: func [
    "Prints information about words and values."
    'word [any-type!]

    /local value args item type-name refmode types attrs rtype temp
][       
    temp:  copy ""
    if all [word? :word not value? :word] [word: mold :word]

    if any [string? :word all [word? :word datatype? get :word]] [
        types: dump-obj/match system/words :word
        sort types
        if not empty? types [
            print ["Found these words:" newline types]
            exit
        ]
        print ["No information on" word "(word has no value)"]
        exit
    ]
    type-name: func [value] [
        value: mold type? :value
        clear back tail value
        join either find "aeiou" first value ["an "] ["a "] value
    ]
    if not any [word? :word path? :word] [
        append temp reduce [mold :word "is" type-name :word]
        exit
    ]

    value: either path? :word [first reduce reduce [word]] [get :word]
    if not any-function? :value [

        append temp reduce [uppercase mold word "is" type-name :value "of 
        value: "]

        append temp either object? value [ reduce ["^/" dump-obj value] ] 
        [mold :value]
        exit
    ]
    args: third :value
    append temp  "= USAGE: = ^/ "

    if not op? :value [append temp reduce [ uppercase mold word " "] 
    ]
    while [not tail? args] [
        item: first args
        if :item = /local [break]

        if any [all [any-word? :item not set-word? :item] refinement? :item] 
        [
            append temp reduce [append mold :item " "]

            if op? :value [append temp reduce [append uppercase mold word " "]
	    value: none]
        ]
        args: next args
    ]
    append temp  "^/" 
    args: head args
    value: get word
    append temp "^/= DESCRIPTION: = ^/"
    either string? pick args 1 [
        append temp reduce [first args]
        args: next args
    ] [
        append temp "^/''(undocumented)''^/"
    ]

    append temp reduce [ "^/^/"uppercase mold word " is " type-name :value 
    " value."]
    if block? pick args 1 [
        attrs: first args
        args: next args
    ]
    if tail? args [exit]
    while [not tail? args] [
        item: first args
        args: next args
        if :item = /local [break]
        either not refinement? :item [

            all [set-word? :item :item = to-set-word 'return block? first args 
            rtype: first args]
            if none? refmode [
		append temp "^/= ARGUMENTS: =^/"
                refmode: 'args
            ]
        ] [
            if refmode <> 'refs [
                append temp "^/= REFINEMENTS: =^/"
                refmode: 'refs
            ]
        ]
        either refinement? :item [	   	  
            append temp reduce ["*'''" mold item "'''"]

            if string? pick args 1 [append temp reduce [" -- " first args] 
	    args: next args]
            append temp "^/"
        ] [
            if all [any-word? :item not set-word? :item] [
                if refmode = 'refs [append temp "*"]
                append temp reduce ["*'''" :item "''' -- "]

                types: if block? pick args 1 [args: next args first back args]

                if string? pick args 1 [append temp reduce [first args ""] 
		args: next args]
                if not types [types: 'any]
                append temp rejoin [" (Type: " types ")"]
                append temp "^/"
            ]
        ]
    ]
    if rtype [append temp reduce ["^/RETURNS:^/^-" rtype]]
    if attrs [
        append temp "^/= (SPECIAL ATTRIBUTES) =^/"
        while [not tail? attrs] [
            value: first attrs
            attrs: next attrs
            if any-word? value [
                append temp reduce  ["*'''" value "'''"]
                if string? pick attrs 1 [
                    append temp reduce [" -- " first attrs]
                    attrs: next attrs
                ]
                append temp "^/"
            ]
        ]
    ]
    append temp "^/= Source code =^/"
    append temp  reduce ["<pre>" join word ": "]
    if not value? word [print "''undefined''" exit]
    either any [native? get word op? get word action? get word] [
        append temp reduce ["native" mold third get word]
    ] [append temp reduce  [ mold get word "</pre>"] ]
    editor temp
    ;write clipboard://  temp
    exit
]

Installed Fossil on Windows, now I get why you keep claiming itl 
is easier than Git. ;-)

Ok. I don't get that, when I seek App Store / iTunes Store, here 
where I live. I'll wait and see, what Apple say about it.

Ah, I didn't get that.

:) It's hard to get the best wording. When I read "the iPhone default 
compression is 85%", I would expect the JPEG file to be 85% the size 
of the uncompressed TIFF file. This is not the case. An uncompressed 
TIFF file from GCam is 23.9 MB, a JPEG is 10x smaller at around 2 
MB. The quality is 85% meaning you loose 15% information, if you 
save as JPEG and not TIFF.


I went with "The JPEG format is compressed at 85% quality setting, 
as is customary on the iPhone."

Thanks again, guys.

To get Unicode output on Windows, you need to switch the command 
prompt to Consolas font

Connected with WiFi on Android 4.0 on Motorola Electrify 2, trying 
to run the test script, I get the following:

Nice work Kaj. I'm working on Unicode support for the tokenizer, 
so the console should get at least Unicode support for the DevCon. 
I plan to write a real cross-platform console engine as nobody has 
stepped out to build one so far, I guess it should be ready for the 
DevCon.

debug builds: maybe. i'd like to get this added to the mainline sources 
first. once that's done, i'm still not so sure if they really are 
that useful at the moment, as I think they won't help much without 
a build environment set up.

well, with the basic build farm in place and the website launched, 
i'll maybe get to some more build process revisions (including debug 
builds) soon.

We might even get basic /View building with the open source mainline 
at the moment. Needs someone to investigate.

Pekr, I suggested R2 because there is an enormous pile of useful 
code, and productive applications, that will likely never get ported 
to R3.  R3 will be great for developing new apps, but it's a darn 
shame to throw away all the work that's come before.

We haven't needed one yet. Foundations tend to do better when they're 
for well-established projects, since otherwise they don't tend to 
get enough funding to cover even their own overhead. So the first 
part of a foundation-building plan would be to grow the community 
to the point where a foundation would be a good idea :)

Maxim. This + alot. But it is more than empowerment, it's other-mindedness 
with empowerment.  You can empower nacisistic people and get dysfunction.

Do you get any messages?

I'm sure of that too. However, that is his day job. Hopefully he'll 
eventually get to use Rebol there.

also you can type LB to get the messages content into browser but 
there is small glitch in the local file URL handling so you need 
to correct the URL string in the browser to see the messages. Will 
be fixed in next release.

I'm past that now - R2 code exists, but we'll never get it.  Let's 
move on and make all new contributions permanent.

How much do we need to get chat going?

This is the kind of trouble we get when taking extra infrastructure 
onboard

Qtask also needs cookies to get into a public file listing

Waited a minute, watched ads, says download will take 61 minutes, 
answered captcha, got popup ads, chose downloading, get same popup 
ad over and over, no download

I was just wondering how I can get a popup. Firefox is supposed to 
block them, but they put them under the download button

and you still get all that crap?

I'm curious - how much traffic do you get from the image downloads?

I wonder how most people come to it - if you search for compact/small 
Linux distributions, does it come up in the results? I would think 
most people looking to get something lightweight would look at linux, 
not some completely different OS

We get hits from many of the same search phrases as Linux, since 
most of the same software is in Syllable, and we have an extra Linux 
system

Yes, I wanted to do that even before EC2 opened up, to get a business 
model going. But regardless of their promises, after all these years 
they still don't support their payment system outside the US

And that will get you all the trouble of running a US company