AltME groups: search

Like the piece of paper, the information is persistent the moment 
you write on it.

  This is the same in Qtask...we spend our time right now making it 
  faster, and much better (simpler) UI.

When you put something in the Scratch pad on Qtask's home page, no 
saving or loading.  It does it for you, and it is instantly availble 
on your Cell phone.

Don't people here see REBOL in line with this very thread.  I use 
REBOL for all kinds

of things, that could be an application, by why?  Use blocks.  Write 
a one-liner for the

task at hand.  That's why I was very interested that Carl may allow 
LOAD/RELAX

(although I would actually prefer a junk! or gibberish! datatype) 
in R3.  REBOL is my

non-application application.  I use this model when coding solutions 
to the

construction site bosses problems.  Use a block and write a script 
that suits the

problem.  Site managers need a button to "make it go" (the UI), but 
each

problem gets its own solution.  I'm not going to sit and try and 
write an accounting

package for a guy that just wants to invoice customers, and show 
his profit/loss.

If the user needs to export data to an actual "app", write a quick 
export etc.etc.etc. 

I don't call them Reblets per say, but it's the headspace I've been 
in for years now.

the problem is, with 3.0, we are discussing vapor yet. There are 
3 new OSNews posts re Amiga and ppl start to react negatively to 
it - because all those years anything amiga related was maybe announced, 
but never delivered ...

even cooler one would be to start viewtop and run few demos, as particles, 
calculator, showing its short source code etc :-)

Intel have announced a new low-power processor and chipset architecture 
which will be designed to allow full internet use on mobile Internet 
devices. To fulfil the aims of our mission and in response to the 
technical challenges that these devices pose, we are announcing the 
Ubuntu Mobile and Embedded project.


https://lists.ubuntu.com/archives/ubuntu-devel-announce/2007-May/000289.html

Paul: we've had this argument before, and I guess Jaime will not 
agree with me; also I've not read the posts on amigaworld, so i'm 
just talking in general about rebol and macros (sorry); anyway... 
rebol does not need macros. the reason is that lisp is a compiled 
language, so there is a difference between compile time and runtime. 
macros in lisp execute at compile time, functions at runtime. in 
rebol there is no such difference. you can write control functions 
in rebol without the need for macros, for example.

Jaime, it's probably too late now, but a person on Amigaworld.net 
wanted to know some of the main differences between REBOL and Scheme, 
as his first though was that REBOL looked a lot like Scheme without 
the parantheses.

Gabriele, Paul was asking for the difference between macros and dialects 
as he thought they were the same.

actually there is no relation. a macro is some code that is executed 
a compile time, and returns some other code (that is then compiled). 
basically, before compiling, lisp expands macros, like the C preprocessor 
expands text macros (of course, since lisp macros work at the list 
level instead of the text level, they are more powerful).

in rebol, the internal representation is values, and you can do what 
you want with them.

Some more thoughts on the MS DLR http://vistasmalltalk.wordpress.com/
   His other entries particularly the Ironpython and Smalltalk ones 
are also very interesting.

The question is will the DLR as implemented on .Net and Mono provide 
a level playing field?

Will Rebol be able to play in this arena, and make use of Python, 
C#, Ruby, JS code?

Gabriele, Even though there Scheme uses two stages the line between 
compile time and runtime is not the same as in C. You can write macros 
during runtime that get compile on the fly and avaialbe without ever 
stopping a program. So in this sense the two phase is just process 
is not really important. The feature that macros brings is syntactic 
abstraction. Also in Rebol you can not do low level control structures. 
That is you can not add foreach without having a looping construct 
already in place. So the mezzanine is slow. Compare to delimited 
continuations of Scheme where is  only control structure and recursion 
and optimized goto. You construct other control syntaxes on top of 
that.

The form use to introduce a  macro is define-syntax. Which allures 
the their syntatic abstraction function. Macros in Scheme are extremly 
powerful and complete. I understand that dialect in Rebol can be 
as powerful, but the techniques required in Rebol for good dialecting 
fall in the interpreter construction realm, which depending on the 
dialect can require more or less effort from the programmer than 
a macro. Context protection in Rebol is something that is importat 
to consider.

Jaime: that is debatable. continuations are the control structure. 
so it's hard to say that in rebol you need a native control structure 
while in scheme you don't - of course you do. :) also, be it JIT 
or not, compilation is still compilation. it requires knowledge about 
the code before evaluation. which means, that there must be a syntactic 
difference between code and data.

also, if you accept to have a syntactic distinction between code 
and data, it is easy to add a macro preprocessor to rebol that works 
just like in scheme. (so easy that there's no need to have it in 
the language itself. try a scheme without macros, and try to add 
them in scheme itelf... ;)

main differences:

- /only refinement added (to only make a Rebol block containing the 
code)

- Parse usage to speed the implementation up and to shorten it a 
bit

we need a smalltalk dialect and an erlang dialect. then everyone 
must agree that we rock. ;)

Ladislav;  I can't give you much of a 'technical' report, but I tried 
to break the

include sequences and failed.  I'm starting to feel the power of 
this.  I like the fact that
scripts can end with 
context [#include %libfuncs.r]
to let endusers pick their own name with
mycon: do %libouts.r

after an include/link   Very nice.  An easy grok, and I'll say I 
"get it" already and

won't have to read your docs over and over to actually use it.   
(Well except maybe

to refresh the #do [[  and (#do [false]) tricks, if I don't use them 
soon.)  This really needs

to be promoted.  Here's hoping the DevCon talk gets this into the 
fore.

Since finding REBOL, I have thought it would be a nearly ideal tool 
to teach language and interpreter design and development, because 
you can do so at a very high level. I think Lisp, Forth, and Logo 
would be a great place to start, but there is no reason I know of 
that would prevent us from doing Smalltalk, Erlang, Icon, and others. 
I would LOVE to see that happen.

Brian: thanks for testing and for the kind words as well :-)

They don't. :-) If you *can* do something as a dialect, and parse 
it as blocks, that makes things much easier, but you don't have to 
make them dialects, they're just interpreters; that's why it's important, 
I think, to start with lanugages that have simple syntax rules. Otherwise 
the grammar may dominate and distract from learning.


I should also say that the interpreters don't have to be complete. 
That is, you could do a Ruby interpreter, but not support the full 
spec of the language. You just do enough to get an idea of how you 
might implement something like Ruby, and see how it works internally.

Ladislav;  No problem...learned a new bag of tricks today.  :)  And 
I'll be sure to report
any problems if they arise.

Gabriele, We have this debate before. You are quick to disregard 
macros as nothing. Data and Code are the same in Lisp and in Rebol. 
As matter of fact Rebol borrowed this feature from lisp, so did smalltalk. 
It is call homoiconicity. And it has nothing to do with compilation 
or interpretation.

Rebol is an interpreted language and with the current syntax it can 
not be made into a compilable language. At least with the current 
stage of CS development. That is drawback, because you pay for this. 
Either in performance or in memory footprint.

An while Scheme has continuations and tail recursion optimization 
as only control structures. Rebol has more that 10 nitives just dedicate 
to control. So one feature plus macros gives you the 10+ features 
you need to implement outside of the language.

Scheme  JIT is cool, but it doesn't have to do anything with DATA 
as CODE. Even rebol code needs to eventually schedule  the bits and 
opcodes required by the hardware. So that imo has nothing to do with 
Programming Language Design (PLD). It has to do with how the Programming 
Language carries out a computation. So the debate of interpreter 
vs compiler is pretty arid for me. The important thing in a PL is 
how expressive it is?  How can you enhance it? The beauty of LIsp 
and SmallTalk is that the ng of Lisp and SmallTalk is writting in 
themselves and that for me is beauty.

For example. For years the Haskell community has disregard Scheme 
beacuse of it lacks static types, and it uses eager evaluation instead 
of lazy evaluation, strongholds of the strict PLs like ML, Ocaml, 
Haskell and others.  But one year ago the wizards at North Easter 
University, added lazy evaulation and types to scheme. So you can 
pick during different parts of your code the style of evaluation 
(lazy or eager) and the to type or not your values (static vs dynamic 
typing). This enhancements are thanks to the *hygenic referential 
transparent  macros*  feature of Scheme. Also not that Common Lisp 
macros are not as powerful as define-syntax, nor Common-Lisp can 
support continautions without making a quagmire.

So a language that was not intended to have certain features can 
added later on, without losing performance or expressivity and remaining 
backwards compatible. I think that is power. Some days ago Sunanda 
was appealing to an R2 compatibility mode in R3. I hope this example 
shows the power in Scheme.

The power in Rebol is different. I think Rebol is good for KISS, 
where simple things are simple, hard things are hard. Like adding 
co-routines. We added this feature to BEER. It works but they require 
careful programming of your routines. Otherwise you get blocking. 
The solutions is R3 tasks. Similarly situation has happend with other 
features, like the FastCGI request that I see sometimes, or callbacks 
for C routines which was dormant inside the interpreter for years 
until discover by cyphre and later released.

Now writting rebol code is a pleasure and I hope the language keeps 
growing, the balance that Carl is trying to strike is hard, but worthy. 
For those of us that are anal there is always alternatives ;-)

Jaime; Did you ever try Icon?  http://www.cs.arizona.edu/icon/

Very high level.  It has that "get 'er done quick", to "holy crap, 
what the....".  Many

angles of Computer Science are covered, and well IMHO.  If you do 
check, make

sure to read The Icon Analyst.  Last issue was June 2001.  Every 
issue has the
holy crap, what the...
, but are very good reads.  The Icon books are all online.

I have a lot of respect for the late Dr. Ralph Griswold.  Unfortunately, 
Icon is far

too brainy for wide spread adoption, but your last thread leads me 
to believe you
may relish it.  (As would most rebols IMHO).

F3 is renamed as JavaFX. http://www.sun.com/aboutsun/pr/2007-05/sunflash.20070508.2.xml
 Now we have Silverlight/WPF, Apollo, and JavaFX .

Jaime, I only object to two things: 1) what makes rebol not compilable 
is not the syntax alone, but the fact that semantics and syntax are 
not tied; you can define your own semantics, and unless you provide 
syntax (or grammar) for a compiler to figure out your semantics, 
a compiler cannot exist. 2) sure, data and code are the same in lisp/scheme 
BUT there needs to be syntax/grammar for the compiler to distinguish 
them - (f a b) is always a function call with two arguments in lisp, 
while it could be whatever in rebol. of course if you have the compiler 
available at runtime you can compile some of your data, but again 
the data is compiled according to grammar/syntactic rules.

There is also talk about JavaFX and Java FX Script, which should 
be used for mobile devices market, content creation ...

Gabriele, (f a b) in the macros context is not always a function 
application. Regarding PARSE, Scheme also has many parsers and lexesr 
on in the  yacc/lex style and parser combinators.  So you can assing 
any semantics or any syntax just like rebol. The fact is that any 
Turing complete PL can reproduce any other. I can easily see how 
to write a C compile in Rebol, and obviouly Rebol is written in C. 
The same holds for Scheme. Or any other language. So that is not 
a valid point of discussion imo.  The thing with interpreters is 
that the tower of languages grows with each level and performace 
takes a hit with each layer of interpretation. The beauty of compilers 
is that once bootstrapped they can eliminate on layer, therefore 
gaining speed as they go directly to the hardware.

Jaime;  I get the impression you may really really like the challenge. 
 It goes way deep.

And check out the books.  The Implementation of Icon book goes nitty 
gritty into PLD.

Excerpts: A syntax-case macro can perform arbitrary computation (using 
Scheme) on the results of a pattern match. A syntax-case macro does 
not manipulate plain text, or even plain symbols and lists (as does 
a Lisp macro). Instead, the macro manipulates syntax objects, which 
encode the lexical context and source locations of program fragments. 
Consequently, just like a syntax-rules macro, a syntax-case macro 
respects the lexical structure of the source program (by default) 
and it plays well with source-correlating tools.

Syntax objects enable the implementation of most any little language 
or language extension. Using syntax-case, we have implemented a Java-like 
class system for Scheme, lex- and yacc-like forms for building parsers, 
and constructs for defining and linking program components. Programmers 
using these constructs do not reason about them in terms of their 
expansion. Instead, syntax objects allow the expansion to be hidden 
behind abstract definitions of the constructs, just as the inner 
workings of any compiler are hidden behind a language definition.

A language's concrete syntax need not be parenthesized to make use 
of syntax objects. In particular, we are currently developing implementations 
of Java and ML for our programming environment, DrScheme (see "Fostering 
Little Languages," DDJ, March 2004). Since our parsing tools produce 
syntax objects, we can treat Java and ML like macro extensions of 
Scheme. These macro implementations resemble typical Java-to-Scheme 
and ML-to-Scheme compilers, but little additional work is needed 
to adapt our entire programming environment to new languages.

Jaime; I'm a little confused by your use of fringe.  I was not trying 
to say Icon was

fringe.  Far from it.  It is the most complete, complex programming 
language on the

planet IMHO.  I only mentioned that it was not popular, because it 
includes features

that are over the head of most programmers.  Unless you also include 
Scheme as

fringe, then I take back what I just said, and yes by number of adopters, 
Icon is
fringe as well.  :)

Brian, Do not worry. I put Scheme, ML, Rebol, SmallTalk and Icon 
in the fringe category. Java, Python, Perl, C, etc are not fringe 
for me.

Brian;  Cool.  I'm still in BooBoo land when it comes to parse, but 
I can read and mod
dialects now.  Just not ready to write one.  :)

I never had any problem with the backtracking - that's where much 
of my understanding of PARSE control flow came from. The problem 
came when there was a real error, not an expected "failure", and 
it just backtracked like normal or worse, ignored it.

I'm still going to push for LOAD/RELAX.  It'll help make UIs that 
construction workers

can feel empowered working with.  I've seen it.  A boss typing his 
own data in 

notepad, they get a real sense of being in charge, and not lead by 
the nose...Boss

type personalities like to feel in charge of their surroundings. 
 No other language I've
seen even comes close.

I still prefer the opposite. Did you see the discussions we had on 
the blog? If you modify my proposal for the additional parse operation 
in the way Volker suggested, by getting rid of the LOAD keyword, 
you can unify the block and string parse dialects. That way you can 
leverage the REBOL loader right in your parse rules but still fall 
back on string parsing if that doesn't work.

And by fall back, I mean backtrack in the Icon sense.

Both.  Line by line for the simpler, then I'll code a few lines and 
wait to see if they ask
what the sequence is doing.

It puts them in a very comfortable zone and in a head space where 
they can think
about and request very specific options and outcomes.

And I don't have to write UIs that don't attack the problem at hand 
(their problem at
hand, not the one I the coder nerd might be thinking).

Btiffin, from previous discussions, I'm probably with BrianH on this 
one. But I'd like it if you could come up with some scenarios from 
real life. Then each of us could try our approach to solving the 
problems and compare.

Volker; Not sure.  This type of thing happens when bosses type their 
own data...They

don't really really need to type their own data, but it empowers 
them.

10-Mar-2007 $12,002.34 "Home Hardware" "Tile Saw"
1--Mar-2007 $12002.34 "Home Hardware" "Tile Saw"


It's the fact that REBOL "knows" it's a syntax error, that got me 
to thinking about 

gibberish! or the invalid? test in the first place.  I'd like to 
be able to show the user

where the data failed, call notepad and let them try again.  Now 
I just say
try again
 and call notepad,  can't help them much.

based on that you can build your own load (add code to collect stuff 
in blocks) and add "spellchecking" in the gibberish-part.

if you are willing to give up the advantage in expressivity, you 
can just use a compilable dialect and compile to rebcode or even 
C etc.

i think self and its "childs" could do it.

Remember, too, that REBOL is not first and foremost a programming 
language. If that had been the main goal for REBOL, I have no doubt 
that Carl would have designed it to be compilable, and probably provided 
a compiler from the beginning.

One of the tricks you would need is to realize that there is no "REBOL" 
language. Each dialect is semantically a seperate language, with 
a different execution model. You can't treat REBOL data as a particular 
dialect until you know which one, and you often don't know until 
runtime. Because of this you would have to compile at runtime, or 
at least function build time. Any attempt to compile ahead of time 
would change the semantics, in a similar way to how prebol does.


Even at runtime the semantics would be different, but not as different 
as you think. Few people realize that while the DO dialect looks 
a lot like a Lisp or Scheme clone, its underlying semantics are quite 
different - and yet they still are able to program in REBOL just 
fine. You could change the underlying semantics to a completely different 
model and keep all but the most guru of programming similar enough 
that most people won't notice the difference. The only main change 
would be to make the code blocks of compiled functions unchangeable 
once the function is built - so no more patching running code.

Don't expect too much of a speedup though. REBOL is really fast already, 
and runtime compilation has some overhead itself.

Yes, compilation must be done on block-level, and preferably after 
the block has already been interpret. to find function-boundaries. 
but self could go half as fast as c, and hotspot even faster. while 
switching back and forth between compiled and interpreted code.

and for scripting there would be a slowdown, except if the vm could 
store the results of the compilation as exe, with the original interpreter-code. 
kind of quick loadable memory-dump.

Volker;  Thank you.  Your parsing data code made me and REBOL look 
like heroes

today.  :)  Another happy boss, less afraid of his computer.  We 
all win.  Thanks!

I really would like to see some of my functions compilable, using 
rebcode or something else... Since I'm now working on a new version 
of my rebol/flash dialect, I found very difficult to bind functions 
into another (recursive) function's context. At this moment I still 
have to define these "inside" functions in the recursive function 
always when I call it, so it must be slower. Maybe it would be enough 
form me, just to have some more easy and fast way how to get such 
functions into specified context. But maybe I just have bad approach.

(f a b) *must* be quoted or be in a quoted list (maybe using the 

funny" way of quoting available for macros ;) for it not being a 
function call." This is simply not true. Not with syntax-case macros. 
You need to know that Scheme Macro system is different and a lot 
better than the one used by lisp as pointed by the article.

See example 6. That introduces a macro for setters and getters, and 
depending the position of the variable it behaves one way or another.

And regarding quotation, every block in rebol is quoted in the sense 
that it is just data. It only acquires meaning when passed thru some 
form of evaluation. Like DO or a Func eval on a block.  Square Bracket 
become the form (quote arg ...) of Scheme.

Regarding the conclusing I find this base less. There is nothing 
missing in Scheme. The first Rebol interpreter was written in Scheme. 
I already said this both languages are Turing complete so they can 
perform the same computations. As I said the topic of compilation 
vs interpretation is arid regarding PLD. But compilation vs compilation 
is important for performance considerations and for bootstrapping.

There is nothing missing in scheme, but there is something missing 
in rebol :)

Lots of parens for example. To solve such situations, rebol needs 
runtime-informations. Which function do i have here at this moment, 
with how many arguments? Without that information the meaning of 
some code is not clear, and it is only available at runtime. So early 
macros have no chance here.

Then there are dialects. They are data with rebol inside. Which parts 
of a parse-rule can be compiled to rebol? Could work if 'parse is 
a macro, up to some point.

But then there is vid. A macro would need to write a lot [ make face[] 
]. Such things grow big. And even then, look at [text a b] . At runtime 
this is easy, [a: 60x24 b: "Hello Scheme"], no problem. At macro-time 
no chance IMHO.

Scheme can be compiled to rebol, because a scheme-programmer has 
to give enough informations at compile-time. Rebol can not be compiled 
to scheme because rebol lacks that information. Making the life for 
the programmer easier, because more can be implicit.

Scheme could interpet dialects too, but then its no longer compiled. 
ANd it can not as good, because rebol-data can reference locals. 
Symbols with context. And scheme can not AFAIK, symbols are only 
unique strings. (i still hope i miss something, maybe a schemer would 
use little closures?)

(MY first counter: making to much implicit actually makes life for 
programmers harder, when he reads it. But that holds for large programms, 
and rebol is optimized for small.

the first rebol interpreter was written in C (not Scheme) by a Schemer... 
and indeed it was *not* rebol and Carl had to rewrite it from scratch. 
:)

do you expect me to do that overnight? ;) also, i think it's very 
easy to do. (a translator does not mean that all the function are 
then available, just that you translate code, and as long as you 
define the functions in rebol, then you can evaluate it)

and anyway, i don't think jaime will ever be able to do a rebol>scheme 
so there's no problem ;)

although I'm not an expert on languages (even if I have been fiddling 
with antidote a bit) the binding of code in REBOL seems to be the 
compilation killer.  the fact that any data only gets meaning when 
a particular part of code is reached and depending on the current 
state of the whole heap, means its impossible to compile by default.

but wouldn't the bind command and any internal rebol binding, be 
in fact where the JIT calls are made?  aren't these explicit points 
in time where a JIT could be applied?

It is Relative Expression Based... :)  Human hinting in source code 
may alleviate some

of the late binding issues, but I'd think a REBOL compiler would 
always need access

to the interpreter at runtime (or JIT compile component like you 
said), or restrict use

of external code loaders in compiled code and a myriad of other features.

Let me restate the problem with rebol and compilation is not that 
is impossible. It is just not practical without given some dynamism.

Let me rephrase my sentence...  ;-)

can't be pre-compiled...

  only a JIT could detect that and then make a copy of the (new) compiled 
   function and start using its new pointer.

A compiler works at the expression level. Thats the reason in Scheme 
anything between parens is considered a compilation unit. The same 
for C anything between  not white space and the semicolon.

Not only because the expression maybe cryptic but also because you 
need to keep track of context and state in your head.

Gabriele, "brainfuck is turing complete, but don't tell me it's the 
same as scheme".  Well it depends on what you mean by sameness. I 
am using Turing Complete as the base of the definition. Because if 
the language is Turing Complete you can construct an emulator of 
any other language. After all that is needed is bits, memory and 
register to carry out any computation. It maybe hard to make a Rebol 
interpreter in brainfuck but it is certainly possible.

Nah. You make the compiler of C to brainfuck. Take Orca's C source 
compile to brainfuck and you are done.

Jaime, again, that was a REBOL 1.0 to Scheme compiler, and it was 
not even complete!!! REBOL 1.0 was sooo limited compared to REBOL 
2.0 that it's even hard to call it REBOL. Just consider that BIND 
took one argument. (Which implies that it had the notion of scope!) 
It had no ports...

brainfuck... so, if it's the same as Scheme, why are you using Scheme 
instead of brainfuck? See, there is some difference, as there is 
some difference between Scheme and C. I'm interested in precisely 
that difference, so if you rule it out in your definitions then we 
have nothing to discuss about.

I wonder what would happen, if someone registered 1 and 0 :-)

I can see Microsoft attempting to tie the smaller companies up in 
court and then Microsoft bail them our of the their financial troubles 
by means of majority investment.

235 patents -- actually that's a claimed 235 violations: they might 
all be of the same patent.

Until MS names the patents and the infringing applications no one 
will know.


But MS probably don't know either -- Ballmer was quoting from a (non 
MS) report that said a survey of (some) open source code showed *no* 
(as in zero) violattions of any patent that had been tested in Court, 
and a possible 235 violations of _untested_ patents.

well, if they are going for it, who will they sue? and do they expect 
to make more than a few bucks on it?

Special unique clever ways of cooking, feeding childs and so on.

And no money to challenge a claim

One patent I'd like to see some "spirit of common good" applied to 
is turning off the

mouse pointer when it approaches an active text cursor.  Apple wanted 
to charge

MS large for it (iirc).  So we all get to flick the mouse around 
every time we type in a

field.  It is a nice feature of the Mac...but come on...RSI and carpal 
tunnel for what?
A nah-nah-nah-nah-na between two rivals.

Volker; Can Microsoft handle alpha?  giggle.  They caused me no end 
of grief with

transparency layers and .png files with IE.  I think it might seem 
a little beyond them.

I mean, maybe someone has the patent and they didn't want to infringe. 
 I'm trying

not to bad mouth anymore, man, it is working out to be harder than 
I first envisioned.


In tune with that, check out http://www.ctrlaltdel-online.com/comic.php?d=20060513
Just to play fair.  Personally I love the Mac ads.

Nany-style Person comes, "i am a virus-checker", and tries to carry 
ActiveX away. hard job^^

Gabriele, Shereman is not Rebol 1.0 it was writting after Joe left 
RT. It is a different language than rebol and it is no R1.0.

I don't use brainfuck, because I prefer Scheme. But I am not a religious 
follower that believes that my doctrine is the best and only one 
with certain capabilities. Your dismissal of Scheme sound like that 
rethoric.

I am know the shortcoming of scheme syntax, but I put with them in 
favor of having access to the source code, the ability to have clean 
semantics, the ability to have first-class closure, the hability 
of adding tasking with first-class continuations, and the ability 
of creating any syntax for my dialect using macros. Besides of having 
functional programming style that shields me from side effect and 
having to keep state or context in my head. For me those are more 
important than having a "nice syntax".

This are  the expresive capabilities that I like. But others here 
prefer a different set of expressive feature mainly based on syntax. 
Things like ports, vid, etc. Are not features of language imho. They 
are features of an OS or library. I do like the set that rebol offers, 
but such facilities exists in other languages thru modules or libraries. 
If we are going to compare the language based on their ecosystem 
then we need to count IDEs, Debugger, Profiler, Steppers and Library 
of Modules. But that is not as interesting conversation imo.

So simply claiming that you can't write REBOL in Scheme is irrational, 
because what then makes C so special, as REBOL is not written in 
REBOL. Putting up a *challenge* is childish and side-steps the issue. 
 That is why I resorted to Turing Completness as explanation.  The 
original issue was your dismisal of the power of Scheme macro system.

well..webbrowsers have "none" vision....as do the browser developers... 
browsers are only products enhanced by the need started in 1994 but 
none of the current developers has asked himself "What does a browser 
actualy do/is for? And is the way we use the the medium (Internet) 
not a little outdated with the current browser?!?".. well with that 
mindset you endup with a product that is reinventing the wheel..and 
eventualy they developed themselfs away, just because the product 
became 1 out of many with nothing new.... Seems none of the current 
developers "Think's!" they all just do what they have learned in 
the classroom.. they all stick with Java C++ and .NET because they 
are told its "good"... (its not.. its clumpsy..big.. Over-orientated 
and eats 50 Gig of memory for a "hello world"... I hope they continue 
doing that ;-) that way Rebol has a real big advantage over the rest 
when they see they ended up at a deadend..

It's interesting to watch the evolution of browser technology. Originally 
the only purpose was to view documents with links (hyper-text). That's 
the main purpose of a browser. Then it was changed to do so many 
other things. Think of products outside the computer industry. What 
happens to products, that are changed to do more and other things, 
than was first the goal? Sometimes it may work, sometimes not.