World: r3wp

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

Jaime, I appreciate your posts on this subject. I still have Scheme 
high on my list of languages to check out. I also regard Gabriele's 
points highly.

Ladislav, remind me in some time to check out your include system.

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.

when you use parse in rebol to parse a block, you are creating a 
new grammar (not a new syntax). usually you tie the grammar to the 
semantics so you can easily compile or interpret it. but there is 
no requirement to be so.

also, about your control natives point, i think that rebol needs 
1 (or 2 at most) to be native. we have more because of performance 
only.

eg. you can do all control functions just using while.

Sun releases sources to the community - http://www.eweek.com/article2/0,1895,2127458,00.asp

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

hmm, that scripting language has VID like declarative aproach - https://openjfx.dev.java.net/Getting_Started_With_JavaFX.html

maybe we can steal their GridPanel widget  for View  ;-)

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.

Brian, I have not look into Icon, but I can put in my list of fringe 
languages to check ;-)

Anton, Thanks. I engaged on this debate because it helps me to understand 
better some concepts in PLD.

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.

All, I suggest you read this article from DrDobbs. It does a good 
job explaning syntax-case macros of Scheme.

Building Little Languages with Macros

 or "Picking up where language designers leave off" http://www.ddj.com/dept/architect/184405618

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

Icon is nice. I was using Icon before coming to REBOL. What it lacked 
for me was communication abilities.

Yeah, Dr. Ralph was writing the language before "icons"  :)  The 
internet was still in
the gopher phase.

For a POSIX layer of Icon with easier TCP, check Unicon
http://www.drones.com/unicon/

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.

Thought so.  :)  Just had to be sure.  For me fringe always means 
'requires an
uncommon form of thinking' leading to low adoption rates.

I used to use Icon as well, mostly for the things I use the REBOL 
parse dialect for now.

Where I see REBOL, scripting will always be the domain of the computer 
programmer,

but the data model is so close to being the domain of everybody, 
I think we are one
small (yet huge) step away.

Icon is an awesome learning step for anyone thinking of languare 
design.  But it does
require being 'smarter than the average bear'  :)

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

It was harder to debug Icon than any other language I've used. Not 
because the language required you to be smarter, but because error 
handling was badly designed. It always seemed ironic to me: In a 
language where "failure" was the name of a common control flow, real 
failure wasn't handled very well.

True...it could get pretty hairy, tracking the backtracking .

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.

Brian;  That's because you seem to be accepting of 'uncommon forms 
of thinking'.  :)

Ain't that the truth :)

Like most rebols...

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.

:)  It's why I mentioned it...  I like that approach...but I'd still 
like to be able to explain

the scripts I write (in front of bosses) without going too techie. 
 Maybe we'll get both :)

Do you have to do a line-by-line explanation, or can you give an 
overview?

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.

load/relax can be written based on this: http://www.rebol.net/cookbook/recipes/0042.html
;)

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.

text: {
10-Mar-2007 $12,002.34 "Home Hardware" "Tile Saw"
1--Mar-2007 $12002.34 "Home Hardware" "Tile Saw"
}
parse text blk-rule: [
    some [
        str:
        newline |

        #";" [thru newline | to end] new: (probe copy/part str new) |
        [#"[" | #"("] blk-rule |
        [#"]" | #")"] break |
        skip (
            either attempt [
                set [value new] load/next str
            ] [
                probe :value
            ] [
                new: find str " "
                print ["GIBBERISH" copy/part str new]
            ]
        ) :new
    ]
]