World: r3wp

Just got an email about this:
Micro Focus COBOL acquires Acucorp COBOL: http://www.acucorp.com/

Maybe it's time to do that COBOL dialect in REBOL!? ;-)

are there any language clones done with dialects at all?

I think %prolog.r from the library may count.

Didn't Gregg make a Logo dialect?

Jaime, How about a Scheme dialect in Rebol ?  ;-)

or Rebol dialect in Scheme? :-)

anybody volunteering to test a new Include version?

I'll sign up.  I was looking at your include.r just last night.

the new version is at: http://www.fm.tul.cz/~ladislav/rebol/include2.r

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

Snagged.  I'll be learning as I go, but I was doing that anyway.

No breaks yet.


include/only let's you include the source script.  Kinda cool, as 
it lets you

inspect preprocessor encapsulated #includes.  Not for real work, 
but nice on the learning
curve.

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.

Ladislav; as I mentioned before include/only is really really handing 
for interactive
exploring...awesome.

I started on a Logo interpreter, mainly just to do turtle graphics. 
I don't know how much value it has, but I'd be happy to send it to 
anyone that wants to pursue it.

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.

Seeing different languages implemented, even naÏvely, in a single 
language like REBOL would be a great learning tool IMO.

How do lang "dialects" get round the loadable REBOL value restriction?

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.

Gregg;  I've been keen to get the REBOL console into an immersive 
mode, like I was

used to in polyFORTH.  The line editor vocabulary means parsing random 
string input.

p [


would place an open square etc...  String parsing seems so, umm, 
not the way.  A CLI

dialect is tricky if everything has to be loadable.  p "[" is not 
immersive, it becomes

a little disruptive to the "stay in the context mode".  Anyway...not 
on the table today.
Just unparked   peoplecards.ca  :)

Interview with Mozilla's CEO Mitchell Baker - http://apcmag.com/6054/firefox_ceo_speaks_out


There are also some off-line app support information (they call it 
web 3.0)

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.

You certainly gain in expressivity, but the reason Scheme abandon 
dynamic binding for lexical scoping is due to the problems that can 
arise with the former in programming-at-large.

R3 requires modules to address this.

I like Rebol syntax. I even started to get into creating a clone. 
But I like Scheme semantics much more. So I side with clean semantics 
over pretty syntax.

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

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.