World: r3wp

Thats what forth does with meta-compilers and squeak does with slang. 
Ugly, so a pretty good motive to do most in meazzines :)

Geomol, you've got competition - inspired by DeluxePaint, Lunapaint 
is new painting program done from scratch, or so is my understanding 
- http://sub-ether.org/lunapaint/

hmm, but maybe I already posted it in the past :-)

http://www.easy2remember.name/media/51/Spore-game-video.html<--- 
for gamers, this looks mightily impressive. An evolution game with 
a 100% dynamic world.

actually not just a world but an entire universe

For inspiration, Wright looked to the 

demo scene," a group of (mostly European) coders who specialized 
in doing a whole lot with a little bit of code. Their procedural 
programming methods were able to, for example, fit an entire 3D game 
in 64K, using mathematics to generate textures and music, etc. "I 
just found this incredibly exciting," Wright confesses, describing 
the kinds of work that he saw come out of the demo scene."


So here's what he did: he recruited an elite strike team of coders 
(who, if you were to believe his slideshow, dressed like ninjas) 
and put them in a 

hidden facility" to experiment with new ways of giving the user powerful 
tools and generating tons of dynamic content without armies of content 
creators. Best of all, he fired up a demo and showed his audience 
the results... "

this is almost a REBOL like way to create games :-)

Volker you are right. But I was thinking on Rebol bootstrapping itself 
and offering incremental compilation too. Just like Dylan or CL. 
Here is an excerpt from wikipedia. "Common Lisp has been designed 
to be implemented by incremental compilers. Standard declarations 
to optimize compilation (such as function inlining) are proposed 
in the language specification. Most Common Lisp implementations compile 
functions to native machine code. Others compile to bytecode, which 
reduces speed but eases binary-code portability. The misconception 
that Lisp is a purely-interpreted language is most likely due to 
the fact that Common Lisp environments provide an interactive prompt 
and that functions are compiled one-by-one, in an incremental way."

Unfortunately this is not easily accomplish with rebol, unless you 
throw away the CFG and with this you loss dialecting flexibility.

I thought about that a bit. IMHO it is not that impossible. But may 
need new core-features.
The idea is that argument-lists rarely change.

Rebol lets us inspect the last values a function used. So from the 
source i cant be sure 'append is really that global 'append. But 
after the function has run, i can look what the last append was, 
and see that it got two arguments. And then i can "insert parens" 
and process it like lisp.

Needs a profile-run, or would work really well with a jit. And the 
interpreter needs to stay in the background for very hart blocks.

Jaime - from my limited understanding - you would like to see rebol 
kind of grammar to be defined and used as a wrapper running upon 
another environment?

If so - would it be easier with other functional languages, or even 
possible (if such grammar would exist), in languages like Java?

Henrik - imo with more media friendly features and rebol overal extensibility 
(as was promissed earlier for rebol), we could see Rebol being a 
tool for some nice demos ....

You haven't seen Web 2.0 till you've seen the latest Framewerks.

Semantics is key.. just ask Sir Tim Berners-Lee

How about this, a single piece of code to handle any web form.. just 
add a new field to the html and you're all set... don't need to alter 
the DB or the serverside processing.

Let's see rails do that.

hear hear  for semantics!  love how REBOL is already half there with 
the lit-word - word - value.  it all ends up being triples anyway.

and TBL, although I think he's lost himself somewhere about 60,000 
feet

MY EYES ARE BLEEDING

3Tera's AppLogic - http://www.3tera.com/applogic.html

cool.  mine are burnt from all the white.

Terry, Rails already do that. It is called Migrations, a kind of 
versioned schema, and yes you just add a field and everything works.

Volker, compiling Rebol is not impossible, it is just very difficult 
exponentially difficult because " the order evaluation" for the a 
function call can change at any time. Depending on how the words 
in the body are defined. This is the CFG feature and problem.

>> test: func[][foo bar]
>> f1: func[][probe "foo first"]
>> f2: func[x][probe "foo first"]
>> bar: func[][probe "bar second"]
>> foo: :f1
>> test
foo first

bar second

>> foo: :f2
>> test   ;;; Surprise order of evaluation changed
!
bar second

foo first

This gets more complex as the body of the function grows, the problem 
of compilation becomes exponential

That is currently true. But makes it sense? What if  such things 
are simply forbidden for compilable code?

Now you could use fix the body of a function maybe not allowing for 
function! values to change dynamically, but this will limit the language. 
I think the best approach for getting closer to the metal is REBCode. 
But I am not sure you can hav a Metacircular Rebol.

I dont think it limitsthe language. I never used that  as a feature. 
Well maybe setting 'print to none, but i can live with "print: func[value][]"

For sourcecode that paren-saving is an advantage. But if i enforce 
that the number of arguments stays the same all thetime, i see no 
problems.

How about generators or dialects, they depend of such feature. I 
mean dialect that don't use parse.

The problem is that you can not assume that the environment hasn't 
change, because if you assumed the you have broken the semantics.

Can you give an example?

Example for which part?

Where changing argument-lists make sense.

APPLY

I can only imagine cases where that is a bug.

With a bit code around?

I can simulate lisp APPLY with a dialect. APPLY require variable 
number of args>

Same for lisp MAP.

In rebol i put those args in a block.

So some of the higher-order techniques.

Lisp does that too in a way, because it puts things always in parens.

Ah. But the point is not that you code in Rebol, the point is that 
if you implement a DIALECT that has different semantics and shares 
the value types! of rebol then you can compile such dialect.

So it would be 
  apply reduce[arg1 arg2]
istead of 
 (apply arg1 arg2)
Or do i miss something?

Yes. Lisp parens are its compilation unit.

And in lisp arg1 none of the args causes evauluation while in rebol 
the may.

I meant ".... value types! of rebol then you CAN'T compile such dialect."

And in rebol we have none when looking at sourcecode.

But actually, when a function runs, its "compilation-units" are always 
the same. Meanswhen a function is run, the lisp-parens can be inserted 
by reflection. (except of strange hacks)

Basically the eval form of lisp is fixed, it is part of syntax, and 
it is (func args ...)

And in rebol it is [func arg arg2 block-of-variable-args]