World: r3wp

For most of my code, it isn't interpreter execution time that makes 
REBOL more efficient. A typical REBOL program for me saves me days 
or weeks of work, sometimes more.

I agree Doc. But even when I wrote VB, I often supplemented it with 
DLLs written in something else, so I'm OK with having to do that 
with REBOL, but I need to be able to do that easily--more easily 
than I do today.

Rebcode could have been a solution, but it seems quite low priority 
for Carl.

I tend to think that JIT compiling block! values to native code before 
executing would be the best way (rather that rely on a very different 
dialect, like Rebcode).

Rebcode will come as a side-effect of user-defined function types, 
which require user-defined datatypes, which requires the plugin model, 
which requires modules, which may require changes to object!, which 
are partly based on changes to the core that result from his current 
VID work.

But I guess that even a JIT approach would require to give up on 
a few features of the DO dialect.

:-D

Brian, you're a good advocate for Carl's strategy, but Rebcode already 
exists without all that dependency chain and it's even usable, it's 
just a pity it didn't make it in 2.7.6 and Encap.

Yes, the compilable dialect would have different semantics than the 
DO dialect but could look superficially the same, and execute a lot 
of the same code (not mine, of course). We have done this before 
in the R1 to R2 transition when we switched from a Scheme-like engine 
to a Forth-like engine without changing the syntax (except for getting 
rid of ELSE). I already have some ideas about how to do this - it's 
on my to-do list.

What would be the compilation unit in your view of "compilable dialect", 
function! or block! values ?

I am well aware of how the old rebcode worked - I was the main beta 
tester. It had the same dependencies then as well, though the execution 
engine being internal made the chain a little different. It was also 
unstable, buggy and insecure.

The natural compilation unit in REBOL is the function. That is how 
the different function types have different execution models already.

It is only the function type that makes the data in a block considered 
code.

Function values

(sorry)

Right. Functions are values in REBOL, and how they are interpreted 
(or compiled) depends on their datatype.

By the way, DELECT uses some of the same techniques that rebcode 
did to be fast.

The new function binding model in R3 makes Rebcode not as fast in 
R3 as it was in R2, if it uses the same semantic model. In order 
to be worth including we would have to change the semantic model 
accordingly.

I would choose block-level for a JIT compilation in REBOL, that would 
allow to compile more semantics than at function level. For example 
[do append [print] "hello"] could be compiled using block-level JIT.

I would keep the DO dialect as is - it would be faster that way, 
because Java is only faster after you factor out JIT overhead. By 
having the compilation overhead at function creation time you could 
plan for it accordingly.

I don't agree for Java JIT overhead. Programs spend most of their 
time in loops where JIT overhead becomes rapidly unnoticeable (loops 
compiled code is cached).

Btw, I guess that Java JIT compiler can run in their own thread, 
so also being able to take real advantage from multi-core CPU.

There would be 2 things you would have to give up in a compilable 
dialect of REBOL, if you want it to be worth it:

- Code blocks that aren't statically determinable at function creation 
time (unlike your example above, which could be partially evaluated)

- Functions that could be edited in place, or hot-patched (already 
gone in R3)

If you don't give these up you would be adding compilation overhead. 
Admittedly, Java isn't the right language to emulate here - Forth 
or other stack languages would be better, as they are closer to the 
REBOL execution model and compiled Forth can be drastically faster 
than the best Java code.

There are several functions in REBOL that operate on their argument 
blocks following the DO model. If you make those functions require 
a literal block you could compile REBOL as-is.

Forth vs Java: well maybe it was very true 10 years ago, but since 
then, the gap is closing with some great  improvements in compilation 
like Java's Hotspot VM.

That's why I mentioned "other stack languages". There has been a 
lot of research in that camp too - they just name their languages 
other names than Forth. I think that some of the research in type-inferenced 
stack languages will eventually make Java and .NET faster too.

Remember, the JVM and CLR are both stack engnes.

Code blocks that aren't statically determinable at function creation 
time

. I agree, but if you look at most of the code written in REBOL (including 
mine or Carl's), it doesn't fall into that case. So, I guess that 
most of REBOL written code can be compiled. Maybe the compiler could 
be made smart enough to figure out what code can or cannot be compiled.

Yup (I've already given this some thought). Hand-optimized code may 
have to be reoptimized though, and this includes some of the optimizations 
that I made to some of the mezzanine functions. You would speed things 
up drastically by using explicit type checking or get-words to filter 
out theoretical function value evaluation.

The fewer possible interpretations of a particular piece of REBOL 
code, the faster the compiler could make it. Inflexibility is what 
makes Java fast, not compilation.

Inflexibility is what makes Java easier to compile. ;-)

I've also thought about all that quite often, it's a really fascinating 
topic.

Need to go to sleep, thanks for the nice chat Brian.

Java code that is as powerful as REBOL code is slower than REBOL. 
If you restrict what your REBOL code does to what Java can do it 
will be slower with the current interpreter. You only get speed out 
of REBOL by writing REBOL code.

Good night :)

the comicis great i was the first one to propose Carl to do something 
like that as presentation for R3 technos

what i like in the  comic is how they present the deferent technologies 
aspect how they are deal to day what is the problem and then what 
is the solution apported by the new point of view introdiced into 
chrome

for example java script -> slow because it's part of the asynchronous 
rendering system and because the javascript systeme reads over and 
over the same code to execute it

solution introduced in chrome javascript runs in a new VM  that read 
the code once transform it into hiden object and then into natural 
code wich is runed again and again  and the VM  is a speparated process 
to focus the resources where they are needed

This is annoying.  I used the Chrome options to make it the default 
browser, but when I use 'browse from rebol, it still invokes FF 3.

you have restart windows since you made the change ?

that's stroed into registry

oops .. let me try.

maybe too they didn't impact on the right registry entry that's a 
beta version ...  that's normal if there is some hum things missing

for me that work i set  chrome as default webbrowser and when i use 
the WWW key on my keyboard that calls chrome

every time you are running another wbebrowser they ask you if you 
want to change the default to the curent one

Nope... still is the default browser but rebol is calling FF

Does your start menu have a reference to your default browser? If 
so and it is Firefox, then Chrome is missing something.

start menu points to Chrome

haha, just read comics - it is kind of cool way to explain some features 
... except the fact, how they turned inability to have properly threaded 
app into advantage talking about processes. While they claim single 
process (and address space) app will not release memory properly 
on one hand, on the other hand they mention overhead of data copy 
needed for their task based aproach, and somehow mysteriously they 
claim that "overtime it means less memory bloat"