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

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

Kaj, we need to get you funded too.

Arnold, you want me to give a list of things that you would need 
to get a Raspberry going?

You don't need a VGA monitor, to the contrary, it's hard to get a 
VGA monitor connected, you need an HDMI or DVI monitor

Still surprised that you still needed to buy additional stuff to 
get it working.

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

I've dropped the C library dependency from all bindings that don't 
strictly need it, to minimise the code base. However, the only binding 
I could get to work somewhat inlined in Red is SQLite, because it's 
little more than the imports

I simplified many of the bindings by using the new get-word functionality 
in Red/System 0.2.6 for getting the address of variables

Ok, it seems we'll have to return to an explicit callback declaring 
syntax. In cURL, the callbacks passing (get-word! syntax) occur after 
the callback declaration, so when the compiler is creating the callback 
prolog, it has no way to guess that this particular function will 
be used as callback later....

The compiler is using two ways to encode the fact that a function 
is used as a callback:

- through the CDECL attribute presence (destined to be called by 
external code)

- through the internal CALLBACK flag that is assigned to all functions 
that get their pointer passed as argument (get-word! syntax).

The stack fix has degraded the behaviour. I now get an access violation 
on all programs

For GTK demos, I get an Xlib error: 

Xlib: extension "RANDR" missing on display ":1:0"

I think it will take me one or two days for the 0.3.0 release todo-list 
to get done.

:-) to do list to get done means, to implement all to-do items :-)

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.

rsc: context

 does contain "fail-try "Driver" [main]" that looks like a starting 
 point but it is within the context. So in my mind that does not get 
 triggered.

What we'll probably get first on Raspberry is RISC OS. I was using 
that in 1987, so looking forward to use it again with Red

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

Not with it, they just have to provide it somewhere the recipient 
can get it. The NOTICE thing in the Apache license is weird though.

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

Brian, where do you get that the Apache licence doesn't require a 
copyright reference be included unless the product is distributed 
in source form?

Also, when you try to build an operating system with Red, you'd get 
into GPL 2 territory in kernel space, and you'd have a problem with 
the many GPL 2 drivers. The media codecs and some networking protocols 
mirror that situation in user space

The big win is the command dispatch model though, because it basically 
lets you get dispatch to JIT-compiled functions for free. The dispatch 
function can manage changes between execution models completely without 
R3 even noticing. Lua has similar separation, though since it doesn't 
have to support anywhere near as many datatypes it can get away with 
a stack-based interface.

I need one HTC sensation, press of a shooter, one button press to 
get jpeg into my email or facebook. Just throw your workflow to the 
trashcan, you can do better nowadays :-)

If people check out the repository, you get all programs at once 
and you can keep them up to date very simply for new test versions:

Oh, the particular quality of the R3 extension dispatch model that 
makes it well-suited to JIT compiler implementation is that a command 
function contains an indirect reference to the dispatch function, 
and an index integer. When the command is called, the runtime calls 
the dispatch function and passes the integer and a marshalled stack 
frame. For a JIT compiler dispatch function, the index of the command 
can be an index into an array of function pointers or something like 
that, and the dispatch function can just pass the stack frame to 
the appropriate function, then return the results. This means that 
the hard part of JIT compiling - getting the regular runtime to call 
the created functions - is something that you essentially get for 
free with the existing command mechanism.


You could also use the dispatch function to marshall arguments into 
another runtime with a different call model. You could, for instance, 
have a dispatch function that pushes the contents of a marshalled 
stack frame onto a Lua stack and calls Lua functions. Or you could 
do something similar for LLVM functions, or ActiveScripting languages, 
or V8, or ODBC queries, or even Red's JIT.


This all depends on having a good marshalling model in the first 
place that can handle the datatypes you need to support, and it would 
also help if there was a good task-safe callback mechanism that actually 
works (R3's needs a bit of work at the moment). Still, the principle 
is sound.

I get a new error on GTK on Linux when it tries to load the Red-48x48.png 
logo:

It's helpful to make a conceptual distinction between the host interface 
and the extension interface, even though for R3 they are currently 
related to each other and share a lot of the same code.


For the host interface, the host is the OS (more or less) and provides 
an execution environment that the R3 runtime runs on like a program 
(this is all metaphorical, but I'm sure you get it). The OS in this 
case could be something like Windows, Linux, some microkernel, whatever, 
or it could be an application or application plugin like Eclipse, 
Visual Studio, Notepad++, Excel, Firefox, whatever.


For the extension interface, R3 is the OS, the extension-embedded 
module is the program that runs on the OS, and that program calls 
the extension's native code like a library. The program source is 
returned by the extension's RX_Init function, and that program then 
wraps the native library code. The module source is loaded like a 
normal script (slightly hacked after loading to make it a better 
wrapper), so the script could be embedded in binary data along with 
non-Rebol stuff just like with normal scripts. You could even have 
Red and Rebol scripts in the same file (if they use the same embedding 
method) so you the data the init function returns can be like a Red/Rebol 
fat binary, metaphorically.


Given this, Red could either be (or compile) a host for R3; or it 
could be (or compile) a runtime library that implements the same 
host interface as r3lib, making it a drop-in replacement for R3; 
or it could be (or compile) an extension that R3 is a client of, 
returning R3 code that calls calls the compiled Red code; or it could 
be an alternate extension container, for extensions that return both 
Red and R3 code from the same init function, which would call the 
Red code returned, which would in turn call the same native code. 
The two languages could be integrated at any point in the stack, 
along with other languages.

Assuming that Red will be compiled (even JIT), the actual semantics 
will be different even if the outside behavior will appear to be 
similar enough that it won't matter for most people, hence the "fake 
it" phrase. It would be a disservice to us if we got a compiler, 
which has definite if minimal disadvantges over an interpreter, without 
getting the advantages of a compiler such as a practical optimizer. 
The behavior of R3 and Red could be quite similar to an outside observer 
that doesn't look closely, but they would require different optimization 
strategies to get the most efficient code. In that way I don't expect 
them to be compatible - they would likely be even less compatible 
than R2 and R3. But that's not really a problem :)

In a couple of days, I'll release the first Red alpha with a blog 
entry to describe it, you'll be able to get a better picture of what's 
in Red already and where it's heading.

With compressed scripts, you can either have raw compressed data, 
or binary! syntax compressed data, after the header and an optional 
trailing newline. If you have raw binary data and a length header 
then it is only decompressed until the end of the length (with DECOMPRESS/part). 
The option of binary! syntax is useful for block-embedded scripts 
or scripts posted in a text environment, and it doesn't really combine 
well with the length header so that is ignored in this case; one 
of them had to take precedence (until I get TRANSCODE/part) so I 
picked compression. It is more likely that the length header and 
raw compressed data would be combined, anyways, For compressed scripts, 
the checksum applies to the decompressed binary data.

Freddy reports a number of strange problems with the MSDOS and Darwin 
versions of the test binaries. I'll relay more when I get more info 
from him

I get virus alerts all the time from red. I just turn it off. The 
only thing that ever got as many hits as red was rainbowforth which 
was another very minimalistic program. AV programs seem prejudiced 
against small executables :(

I've sent a few info requests to various AV vendors, I hope to get 
some clues about what's triggering their heuristics.

Thanks Peter! Your early unit tests helped it get out without too 
many bugs. ;-)

Run-All    v0.8.2
Quick-Test v0.9.1
REBOL       2.7.8.4.2
Red/System Test Suite

ok - logic.............................81 / 81
ok - byte..............................40 / 40
ok - c-string..........................20 / 20
ok - struct...........................116 / 116
ok - pointer...........................69 / 69
ok - cast..............................88 / 88
ok - alias.............................23 / 23
ok - length............................11 / 11
ok - null..............................11 / 11
ok - enum..............................19 / 19
ok - float.............................60 / 60
ok - float32...........................55 / 55
ok - lib...............................13 / 13
ok - get-pointer........................5 / 5
ok - float-pointer.....................61 / 61
ok - namespace........................109 / 109
ok - not...............................44 / 44
ok - size..............................37 / 37
ok - function...........................6 / 6
ok - case..............................64 / 64
ok - switch............................85 / 85
ok - exit...............................9 / 9
ok - return............................25 / 25
ok - modulo............................29 / 29
ok - math-mixed.......................114 / 114
ok - infix..............................2 / 2
ok - conditional.......................13 / 13
ok - common............................16 / 16
ok - byte-auto.......................3636 / 3636
ok - integer-auto....................2778 / 2778
ok - maths-auto......................1661 / 1661
ok - float-auto......................1617 / 1617
ok - float32-auto....................1023 / 1023
ok - alias-compile......................3 / 3
ok - cast-compile......................16 / 16
ok - comp-err...........................2 / 2
ok - exit-err...........................3 / 3
ok - int-literals-err...................1 / 1
ok - output.............................3 / 3
ok - return-err.........................5 / 5
ok - conditions-required-err...........23 / 23
ok - inference-err......................1 / 1
ok - callback-err.......................2 / 2
ok - infix-compile......................3 / 3
ok - not-compile........................1 / 1
ok - print..............................3 / 3
ok - enumerations compile..............12 / 12
ok - pointer-compile....................2 / 2
ok - namespace compiler tests...........5 / 5

ok - Red/System Test Suite..........12031 / 12031
       in 0:00:42.94891

Daniel, thanks for testing. The GTK error is recent; I reported it 
last week or so. But I didn't get the float error with it, which 
makes me think I need to add back FPU initialisation to it

Anti-virus: should I suspect that we have to submit every build of 
every version of every program to all anti-virus vendors to get them 
recognised?

I've just got an answer from F-Prot, they just whitelisted the sample 
binary I've sent to them but didn't send me any info about their 
heuristics... So I think that in order to avoid loosing my time trying 
to get any info from those AV vendors, I'll just add a specific signature 
to Red generated binaries, so that they can be whitelisted by all 
AV vendors (when possible). I can't see what else I could do, except 
warn users about some crappy AV software.

Kaj: I get a lot of type casting warnings since the last commit on 
GTK-widget.reds, could you please check if they are legitimate or 
not?

I get one on the GTK binding and one on WebKit. I haven't seen them 
before the 0.3.0 merge

Question for everyone: I was thinking since a while to publish on 
red-lang.org the donations I get, including donator names (unless 
they want to remain anonymous). Is that ok? Are they best practices 
for doing that?

My concern was to be transparent about the donations I get, so that 
people know how much I receive each month.

IMO, the only way to get a new good replacement ID for "MSDOS" is 
to change all targets ID and adopt a different naming convention 
(one that is easy to remember).

Kaj, it would be helpful to make it easy for ppl to get. I am an 
average user, and I can't locate the executables:

- esperconsultancy does not provide any link

- red lang does provide link to fossill (which UI I find terrible)

- I go to Files section, examples subdir - no executables there ....

Click click click click, nonsense timeline, nonsense hashes, then 
you finally get to the point, where you can download a ZIP file, 
and it is named like a crap, subdir's name is weird too. I am really 
upset anytime I have to go to such an interface. It is not imo normal, 
in order to get a clue how to get a file, to twiddle around for a 
minute!

OK, red works, as for Red/System demos, where do I get all the dependecy 
libraries from? Any previous chat you can point me to?

Things will get much better once I can make GUIs in Red

Windows (whatever)/ARM support: I would love to see that, I just 
need to get access to such platform first....Anyone know if there's 
a virtualized option for that OS?

Doc - the less time I have, the less I am willing to spend my free 
time, just to get around various things, where I need to get to the 
point. Multiplexing on 2zone advertising, new 2zone project, initial 
works for my new photo studio, X-zone wifi network, doing some charity 
for children next week, and my primary work, Walmark, I am being 
put on 5 new projects :-)

Kaj - maybe something wrong with your config? I get following zip 
archive naming:


System) Testing-4d2b660531ddd6fc(1).zip / Red( / Red(\System) Testing-4d2b660531ddd6fc

Why the parens in there?

The issue! type was changed from a string-like type in R2 to a word-like 
type in R3, but the R3 behavior isn't completely final. It will continue 
to be a word-like type, but the syntax might get some tweaking and 
some string-like operations might be added back where possible, perhaps 
in a similar way to how tuples are series/like at times but actually 
immutable.

GiuseppeC: Red/System is a language to build other languages using 
a similar syntax as REBOL, one of which is Red. R3 is based on C. 
There is no way for R3 to tap directly inline into C's performance, 
while Red will be able to. I think this is quite a feat that might 
make Red much more flexible than R3. You also get encapping right 
out of the box with the current compiler. I can't come up with an 
appropriate car analogy.

Jerry: when I find time to write it. :-) Probably when I get back 
to memory manager code to add the few missing parts, like GC and 
allocation of big memory chunks, that should happen in the next weeks.

AdrianS: the output of the lexer is nested blocks of Red values, 
same as REBOL with its own lexer (LOAD). The AST is not stored anywhere, 
AST nodes are created and consumed on the fly during the compilation. 
So the closest thing to an AST you can get currently is the output 
of the lexer.


For the needs of a code editor, maybe you could just invoke it on 
the currently edited line (though you would need to deal with unmatched 
opening/closing delimiters). I haven't yet though how I will achieve 
it in Red IDE.

So, we get both worlds. If we manage to call R3 code from the Red 
section and vice versa, that would be great. We could use the compiled 
speed for inner loops and let the interpreter do all the non-speed 
relevant things.

Pekr: the difference between AOT and JIT compilation is much thiner 
than you think. Just load Red/System compiler code to your R2 app, 
pass it any source code at runtime, use the link?: no option and 
you get compiled code and related data in form of binary! values...and 
voilà! :-) The rest is same as for Cyphre's JIT, you need a way to 
call native code in memory, something that is hardly possible in 
R2, but maybe Cyphre found a hole to achieve it anyway.

It's available but not documented as it is only used by the compiler 
internally for now. You can add it to any of the target definition 
block in %config.r for testing (or create a %custom-targets.r file 
instead). It will put the compiler in an "incremental" mode (it can 
compile incrementally as many source file as you want). Once compilation 
has finished, no file will be generated and compiler state will not 
be reset. You can then inspect the result of the compilation from 
console using:

>> probe system-dialect/compiler/job
>> probe emitter/symbols
>> probe emitter/code-buf
>> probe emitter/data-buf
>> probe system-dialect/compiler/imports


You can basically get most of these data in logs when compiling using 
-v 9 option.

I would like to get rid of the compiled C part, but never found the 
time to recode it in Red/System. It would also needs some addition 
to Red/System, like interruption handling (already planned) and other 
non-planned features, like a way to initialize RAM/SRAM from Flash 
memory (basically, it needs to copy the firmware data section from 
ROM to RAM), or initialize properly the timer clock (which should 
be doable with the hardware I/O support I've planned already).

Recent Red tweet: "All path datatypes (path!, lit-path!, set-path!, 
get-path!) implemented. "

From ~Links group: "Could Red eventually become a contender for #6? 
 How strong will support for parallel processing be, eventually, 
in Red?"


#6: yes, that is one of the goals I want to achieve with Red. For 
parallel processing, the model I have in mind is the "parallel collections" 
from Scala. This means that when you are looping over a series, Red 
should be able to parallelize the loop code over n (CPU and/or GPGPU) 
cores at the cost for the user of only a change of the loop function 
name (in Scala, they use a "par." prefix for such functions). This 
requires that the compiler do a deep static analysis of the loop 
body to determine if it can be parallelized (e.g. iterations not 
dependent on results from previous ones). Now, if you also add SIMD 
support in the equation to leverage intra-core parallelism, you get 
a good picture of what I want to achieve. ;-)


So, I think a semi-assisted parallelization/vectorization of loops 
in Red is doable. To what extent and which final efficiency, I'm 
not sure before we build some prototypes.

Remind me to start a space ship building company when I get to that 
point. ;-)

Path notation preliminary support added: you can use it on any series 
with integer! or get-word! values as accessors (nested word! values 
need SELECT action to be implemented first).


See changes in demo script: https://github.com/dockimbel/Red/commit/88fd1ff1da855a383e91566903fe373ea4d41eca

The problem with no meaningful index 0 is that potentially meaningful 
index values are no longer isomorphic to integers. And as REBOL has 
no actual datatype for indices, all we can compute with are integers 
while relying on a correspondence of those integers to indices.


If you only ever compute indices for series positioned at the head, 
you get a nice correspondence of integers to indices, because meaningful 
indices for this series correspond to the positive integers.


But if you also want to compute indices for series positioned elsewhere, 
this nice integer-to-index correspondence breaks down as you suddenly 
have an undefined "gap" for the integer 0, whereas negative integers 
and positive integers are fine.

I also think that an ordinal! (or index!) datatype may be an intriguing 
possiblity to get the best of both worlds.

I use pick ONLY in case where I don't want to get error if I'm out 
of bounds

I think that what we are seeing here is the frontier between academic 
and practical design choices. I am all for following academic principles 
as long as they are not "too" detrimental to practical usage. I would 
draw the line at the point where most users would get lost. I believe 
that this is a dangerous pitfall in language design if you aim at 
a widespread use.

Just erroring out on index 0 is ann improvement.

 That's my intention for Red until we get a consensus on a better 
 overall solution.

We won't get consensus on this.

The problem with keeping most of R2's behaviour much longer is that 
switching to something different will only get harder.

We should write a short-list of possible options that would solve 
the whole issue and see if we can get a large consensus on one of 
them. Anyone kind enough to extract the different options we've discussed 
and put them somewhere online with the main pros/cons?

I use computed indexes for computed lookup lists, such as for precomputed 
intermediate results of computations, translation tables, etc. If 
the computation uses signed numbers, you have to do an offset base 
position to get the results from the positions less than 1. Having 
a hole slows down the computation because it has to be handled in 
mezzanine code. PICKZ/POKEZ would actually be better for most of 
these situations because the computations work better with 0-based 
numbers (modulus, for instance). It's pretty common in code that 
actually *needs* to use PICK/POKE on series.

For that matter, in R3 (where I don't get caught by the 0 hole for 
PICK/POKE, just for AT) I have to do an offset-forward-by-one reference 
to avoid having to add 1 to every calculated index reference. Doesn't 
help in R2 though.

I think that what we are seeing here is the frontier between academic 
and practical design choices. I am all for following academic principles 
as long as they are not 

too" detrimental to practical usage. I would draw the line at the 
point where most users would get lost. I believe that this is a dangerous 
pitfall in language design if you aim at a widespread use."

Well, really difficult to settle, any way you think abou the topic. 
I can think about 0 as about in-between, non real value - like Max 
mentioned vectors, simply first element in series to the left, or 
to the right. Then I can think about 0 as about real value - if I 
look outside, there is -1C temperature. And in order to get to 1C 
temperature, 2 grades are needed, hence 0 is real value here. And 
finally - if I will have some real series in front of me, e.g. 10 
ppl, I can pick first, second, first to the right, first to the left 
(-1), hence no zero or negative index here ...

Whereas s/2 could be conceived as shorthand for `first next s`. And 
there you already get a glimpse at the problem:

- s/2 is first next s, s/-2 is first back back -- why is there 1 
next but 2 backs?
- what is s/0?

Testing your implementation with:

1 = index? head s
0 = i
2 = index? s

i get:

1 = head-index? s i

, which is incorrect

I really don't care about path syntax with computed indexes, it's 
ugly and awkward, and broken because of the 0 hole. I'd really rather 
use a function. As long as we get PICKZ/POKEZ, I'll be good. We already 
have SKIP to act as a non-broken AT. But at least plug the hole with 
a triggered error, so it won't mess people up silently. It's a huge 
failure, at least make not fail silently.

(what is interesting is the fact that when you rely on this, you 
get "kicked in the butt" like Carl was)

...outside the range of validity of the function

 if you mean the AT function, then it actually is "inside the range, 
 so you get bitten in the ass, eventually, as Brian noted

(what is interesting is the fact that when you rely on this, you 
get 
kicked in the butt" like Carl was)"


I respectfully disagree. :-) You are right in that my proposition 
doesn't exactly match the requirements, because the requirements 
imply a 0-based reference that I've missed. So, here's a corrected 
version that matches your requirements:


    head-index?: func [s [series!] i [integer!]][(index? skip s i) - 
    1]


I am probably too influenced by the way Carl designed R2, but I still 
think that a 1-based index system has value. (Let's save the 0-based 
vs 1-based debate for another day)

BTW, 0 is the reason why many arithmetic algorithms work, so getting 
rid of 0 helps only to get back in time before 0 was invented, to 
the time when those algorithms did not exist. (the word algorithm 
itself is actually pointing to the city where a zero proponent and 
matmenatical giant Muhammad ibn Musa lived).

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

Sure. There are different milestones for a language integration. 
The first, to get the language hooked up to the API is probably not 
a huge effort. The second, to make existing projects work in the 
new language, is a different matter.

Better to get the attention of the Gates foundation ;)

Get/install the version I linked in Languages - 2.1 beta8

Nice, Nick!
Need to get that added to RebolBot!

Thanks for posting Nick. I hope to get time to read them in the next 
few days.

Graham, I haven't tried to grab a cookie or anything yet, but just 
running the SO bot errors out first thing:

** Script error: lastmessage-no has no value
** Where: get ajoin case ?? do either either either -apply-
** Near: get :name

What optimizations are you looking for?

There is only so much Cyphre that we can apply to the projects, alas. 
I hope that we can get some other talented people to take on perhaps 
individual Cyphre-class projects so he doesn't have to do so much 
overall. Hopefully the new open source projects can attract more 
people, or even have some come back (Hi Maarten!). Fork's efforts 
may help here.

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.

I'll be pleased when we get it just for Red

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

, i.e. if you really get identical builds when getting identical 
system/version

I am especially curious whether any of your 0.4.4 is really what 
I get when building r3 on Linux?

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

Did you get any response?

Did you get any response?