Red Programming Language: Plans for 2019

> The Red Language has always described itself as functional imperative

I dont think that is accurate. All data items in red actually have attributes. Red has prototype-based OO. It's a very powerful language. I just wish they had better web app and ORMS...

> > If anything, it sounds too easy, making me think "what's the catch?

> This is rude and uncalled for.

I think she/he raise a fair point about how the Red language is advertised, and it's actually a rather friendly to assume that it's due to language barrier.

Many posts about Red/Rebol are unequivocal praise with very few details or any acknowledgements of short-comings or limitations of the languages.

Just to dig up some random ones:

Here's a speed comparison between Rebol and Python[0]: Rebol is faster (surprise!), but the post doesn't contain or link to any of the code used for the comparison

Here's some grand self-praise from the Why Rebol/Red[1] on why it's just better than all other languages:

> You may be familiar with Clojure, Python, Ruby, Lua, frameworks like Ruby on Rails, or any of the multitude of Javascript frameworks which are purpose-built to "ease" particular types of development work. Such languages/tools/environments are certainly productive compared to traditional tools like plain old C++, Java, etc., but they are absolute behemoths when compared to Rebol. Virtually every other well known development tool in popular use is built upon bloated layers of existing technology, and encumbered by mainstream language syntax and development procedures which introduce an extraordinary volume of unnecessary complexity at many levels. Most developers have just never experienced the sort of self dependent architecture, lightweight tooling, bare language and data structure syntax, composability, and reduced code volume, which Rebol prioritizes as its most important purposes.

(Are Red/Rebol creators seriously claiming that Clojure's syntax is complex?)

Of course there are sometimes programs about which you could make grand claims, like when SQLite claims to be "35% Faster Than The Filesystem"[2], yet they also clearly describe its limitations[3].

Edit: Even in this thread we get this kind of praise:

> Isn't Red a great language to teach children? I just tried Red and it's amazingly simple to get started.[4]

About a year ago I did try out Red and Rebol, and I couldn't get any of the examples to work, or figure out what the syntax meant, because there's just so many cool examples of how few lines it takes to do X but very little explanation. It made me feel a bit inadequate, because if this language is soooo easy to use, and yet I somehow fail to grok it, then I'm just not smart enough, right?

Here's one of the examples linked to in Why Rebol and Red, with hardcoded IP, no comments and all:

    REBOL [title: "Live Camera Video Stream"]
    for i 2 27 1 [append b:[] rejoin [http://207.251.86.238/cctv i ".jpg"]]
    view w: layout [
      i: image 320x240  text-list 320x200 data b [forever [
        set-face i load value wait 1 if not viewed? w [unview break]
      ]]
    ]

It's great that someone found that so easy to write, but it looks like one-off write-only shell script, and is certainly not useful for "teaching children".

I know it might seem a bit harsh that I'm suggesting that Rebol/Red is being promoted in a somewhat dishonest way, but I'm mentioning this so that you could hopefully improve, not to make you upset.

Edit: More over-the-top praise.[5][6][7][8]

[0]: http://blog.hostilefork.com/rebol-vs-python-performance/

[1]: http://redprogramming.com/Why%20Rebol%20and%20Red.html

[2]: https://www.sqlite.org/fasterthanfs.html

[3]: https://www.sqlite.org/whentouse.html (See the section Situations Where A Client/Server RDBMS May Work Better)

[4]: https://news.ycombinator.com/item?id=18844770

[5]: https://news.ycombinator.com/item?id=18844002

[6]: https://news.ycombinator.com/item?id=18844185

[7]: https://news.ycombinator.com/item?id=18844746

[8]: https://news.ycombinator.com/item?id=18845102

I'm not the OP (and not associated with red an anyway, other than being a fan of REBOL), and I agree the wording deserved to be called out. "cult" and "Czech wizardry" aren't exactly positive framing words. Hopefully this doesn't spiral into a discussion about PC comments, because red looks to be cool and deserves a good technical discussion; but I don't think 9214 was off base calling out the comment.

Okay, but just an FYI that was probably a complement.

Wizardry and magic has positive vibes in American culture. I can see how that might not be the case in others.

Articles you linked are fairly old, unofficial (that is, don't represent opinions of Red designers and developers) and are written by more-or-less experienced Rebol users. That is, it's hard to talk objectively when you have a tunnel vision accumulated over time. These languages are great, and deserves all the praise they get.

As for shortcomings and limitations, here I can speak only form my experience. If you want an open discussion about it with other developers, consider to visit our community chat [1].

"No dependency" goal - whole toolchain is written from scratch and heavily relies on a native functionality provided by underlying OS. This is cool and ambitious, but there are problems:

* developing a compiler on a par with existing state-of-the-art (e.g. GCC or LLVM) ain't small potatoes. Currently there's no optimization layers, and emitted code might left much to be desired. Perfomance of Red/System IIRC is 2-3 times slower than C (again, without any optimizations). Red is 6-7 slower than C.

* As I said, emitter and linker are written from scratch, and signature of compiled binaries doesn't match common ones, which leads to Red toolchain and compiled applications being flagged by AV vendors as a "generic malware". [2] Language adoption suffers because of that, users are baffled, and vendors don't provide a single clue on how to resolve this issue. It's an uphill battle.

Implementation details:

* Red is its own data format, and structure of this format might be considered as sub-optimal by someone - each value is represented as a boxed structure 4 machine pointers in size. On 32-bit systems that's 128 bits, on 64-bits 256, but can be squeezed down to 160, AFAIK.

* Red/View strives to provide a set of native widgets supported across all OSes, which means that more sophisticated widgets (e.g. tables, Android-like swithes, tree-list) ain't included in the box. That doesn't mean that you can't implement custom version of them - but this process isn't trivial and requires some experience.

* Red is currently limited to 32-bit. As stated in the blog post, 64-bit support will likely come next year, but will require a dedicated rewrite of runtime.

* Compiler and R/S toolchain are written in a closed-source (and officially dead) Rebol2, which is a no-go for FOSS enthusiasts. Self-contained Red toolchain executable relies on Rebol SDK, which requires a paid licence which is not selled anymore - this means that no one can build Red toolchain as the one provided on official website by themselves. This isn't critical, as you can always use code in repository to compile from sources, but, well, there's a fair share of nay-saying here.

User experience:

* Learning curve is steep. Documentation is being worked on, but lefts much to be desired, esp. if you are a programming newbie. We compensate it with strong community presence though.

* Obviosuly, decision to go blockchain generated much controversy and became a major source of gossips. Crypto community is highly polarized: toxic brain-dead speculators on the one side, and extremely smart, dedicated individuals on the other. The former cause us major pains and headaches, the latter keep inspiring us to keep going.

* We also get a lot of harsh critics regarding a pace of development. People go as far as to say that "development is frozen", without considering all the details. Currently there are 12 team members, before that there were 4-5. Rebol never became a mainstream, so it's kinda hard to search for experienced employees, capable of writing production-quality code and contributing to the main development branch.

Your criticism has a point, and I do agree that we need to post more objective, real-world examples in the main blog, and also mention language limitations and short-comings from the designt standpoint.

I also agree that bold claims about Red being easy to pick up are largerly unfounded, albeit serve as a good PR bait.

[1]: https://gitter.im/red/red

[2]: https://news.ycombinator.com/item?id=18348938