Well, certainly your feelings are not uncommon (and I share the opinion on the open source bit). Beyond that, it’s just generally hard to convince someone to give almost anything “new” a chance. People are busy.

For instance I haven’t learned to type on a Dvorak keyboard. Even though I type all day, I refuse to try it without serious incentive. Every time I go to another developer’s terminal to look at something and they have to go switch the keyboard settings back to standard I roll my eyes. It’s definitely points off my evaluation of a developer if they do that sort of thing (due to the fact that it’s all pseudoscience).

I’m willing to believe REBOL would fall in the category of things that will be perpetually off your radar. But this set of articles here are an attempt to explain why I find the novelty of REBOL interesting. Then again, I don’t demand something be completely practical to think they’re worth looking at. Turing Machines sure aren’t very “useful”, but everyone who programs should become familiar with them at some point.

If you don’t like weird language & platform projects (like Erlang and Squeak and such) then you’re almost certainly not going to like REBOL either. People who feel that languages which are “Java, more or less” stay out of their way and let them achieve what they want in software will not be motivated to learn REBOL…

Someone pointed me toward ORCA:

http://freshmeat.net/projects/rebol-orca/

Since you seem close to the REBOL community, I am wondering if there is an official stance on disposition toward a competing GPL interpreter kernel. Could it use the same mezzanine functions that the canonical version of REBOL does? Can an official statement be made on what is and isn’t allowed in terms of creating a clone, so people working on such an effort do not waste their time, only to face lawsuits when the project becomes big enough to be a “threat”?

Because many REBOL functions are written in REBOL themselves (they’re called mezzanines, while funcs written in C are called natives), it’s easy to change them to work how you want. That may make them incompatible with the standard versions, which is a problem, and getting a new version accepted as standard isn’t easy. An enormous amount of effort goes into the design and evaluation of even simple functions. On the plus side, the community loves to see new ideas and talk about the best way to do things.

I updated the article a little since last night and added some more information….and a picture. I’ve made a few better arguments, and did a little digging on LISP and contrasting it more accurately (see the section “Turtles All The Way Down”). While I was at it, I tried to say what I meant about the C++ iterators a little more clearly. So if you have time to re-skim you might find it got better!

Truthfully, I speak Bjarne’s moon language pretty well too. But I still remember before I used STL and how alien it seemed. Everyone I knew avoided it, so I figured I would too. (Though today when I meet people who don’t accept modern C++ I beg them to look at Guide To Learning C++ as a New Language.)

Bjarne has said “As I have often said, I consider not shipping a larger standard library my biggest mistake.” And the STL really did come onto the scene until late in the game. C++ started being known to the public by its current name in 1993, and had made it out of academia and labs to reach the mass market as Turbo C++ in 1991. The earliest version of the STL that was public that people could start trying for themselves was in 1994, but you had to download it off the Internet.

1997 saw the first version of Microsoft Visual C++ shipping the STL in the box, even while most of its documentation was still pushing their own MFC Collection Classes on developers. Today the same factionalization continues even in more open projects. Just look at the Qt Collection Classes, or the wxWidgets string type…Mozilla doesn’t use any of these in its internal code, and it’s one of the most prominent C++ programs!!! Everyone can’t be an idiot, so there must be something fundamental here.

On its native classes, REBOL does just about all the C++ iterators do and more, without needing an iterator class that’s distinct from the object being iterated. It’s interesting to see the LISP ideas meshed so artfully with the best aspects of C++ iteration. Not that REBOL doesn’t have crazy maddening things in it, but I’ll write about those in the next article.

Thanks for commenting!

#include <iostream>
#include <string>
int main(int argc, char *argv[]) {
    std::string s = "This is a string.";
    for ( std::string::iterator it = s.begin(); it != s.end(); ++it)
        std::cout << *it << std::endl;
    return 0;
}

Both iostream and string are part of the C++ Standard Library (the “default” installation, if you will). C++ can be quite concise and elegant.