
REBOL Shell Interface - bryanrasmussen
http://www.rebol.com/docs/shell.html
======
soapdog
REBOL was such a fun language to use. I wish it was open sourced earlier, then
it might have made a larger impact. RED is a spiritual successor that deserves
a look as well: [https://www.red-lang.org/](https://www.red-lang.org/)

~~~
rgrau
Both REBOL and Red feel magical to me. How is this simplicity achievable?
Where is the trick?

I never could dig too deep into those, and couldn't find much info on the net.
Is there a set of seminal papers/articles on the principles which those are
based off?

I imagine there's Logo on one side of it, but I'm not sure about the bootstrap
story, the toolchain, etc... Meta-II? Smalltalk, Lisp?

I recently found this book
[https://subscription.packtpub.com/book/application_developme...](https://subscription.packtpub.com/book/application_development/9781789130706)
which I'd like to read if it talks about that holistic approach. Any comments?
other pointers?

~~~
9214
Historically, Rebol family takes roots in the ideas of symbolic programming,
denotational semantics and distributed computing. It never was an academical
project (so you won't find any papers or articles), but rather a mix of
pragmatism mixed with nonacceptance of the current state of software, so
there's no magic to it: you reject the bloat and keep things simple.

The core idea is that, in Red/Rebol, you don't write "code" in the usual sense
of the word, but rather load a data structure in memory that
interpreters/compilers then process.

This data structure is a concrete-syntax tree (CST), a product of lexing
syntactically-rich data format (think of a human-centered, futuristic JSON
with unique literal forms for things like IP addresses with RGBA tuples, dates
in various ISO formats, monetary values, URLs, e-mails, etc). The result of
evaluation, then, is the end game of interpreters/compilers "walking" this CST
— and each one can interpret the same tree differently.

So, Red/Rebol is both a programming language and a data format, there is no
distinction between code and data. Rebol called itself "messaging language"
because this CST, coupled with semantic rules for its interpretation,
constitutes an embedded DSL (aka dialect), a message that you can exchange not
only between machines (as a data structure), but between machines and humans
(as a readable format).

Implementation-wise, the leverage comes from the runtime library that reuses
what OS provides, high degree of polymorphism, everything being a first-class
citizen, and above-mentioned syntactically-rich homoiconicity with general
orientation towards linguistic abstraction.

With all of that we end up with a tool (speaking of Red) that covers the whole
spectrum of software development, from metal to meta: user-land functions that
seamlessly operate on CST values and enable meta-programming at run-time
without macros, and a set of dialects that process said CST and encapsulate
the problem domain's complexity, like e.g. VID for declarative GUI
specification, Draw for raster drawing, Parse for creating other DSLs (think
of it as Meta-II on speeds, wearing jet-rollers) and Red/System for low-level
programming. All packed into a few megabytes.

These are the principles. Rebol was an interpreted language bootstrapped from
C, Red is both compiled and interpreted: runtime is written in Red/System, and
bootstrapping compiler with Red/System toolchain are written in Rebol2.

So, Red is written in itself, Red/System and Rebol; Red/System is a dialect of
Red; Rebol is 90% compatible with Red (roughly the same data format and
language semantics). Let this meta-circularity sink in.

Balbaert's book is IMO a very shallow explanation of the language basics,
often plain wrong and technically incorrect, so I cannot in good faith
recommend it, especially if you are a newcomer to Rebol family with ambitions
to go advanced and master the tool.

WRT pointers toward design-centered discussions around Red/Rebol, consider to
join community Gitter channel and read wiki articles. E.g. one of them
(shameless plug) goes a bit more into conceptual underpinnings that I
described above.

[https://gitter.im/red/red](https://gitter.im/red/red)

[https://github.com/red/red/wiki/%5BDOC%5D-How-Red-
works,-a-b...](https://github.com/red/red/wiki/%5BDOC%5D-How-Red-
works,-a-brief-explanation)

~~~
rgrau
Wow, thanks so much for this answer.

I'm just going to add this link here to another explanation of yours I found
around that expands on some of the unique aspects of Red:
[https://www.reddit.com/r/redlang/comments/aebxct/contrast_re...](https://www.reddit.com/r/redlang/comments/aebxct/contrast_red_with_racket/)
.

Thanks again

------
enduku
There was a REBOL clone named Sherman [0], written by Joe Marshall. He co-
authored REBOL 1.0 and wrote Sherman after he left Rebol Technology. REBOL is
such a powerful and simple language, it's a shame it wasn't open sourced
earlier.

[0][https://web.archive.org/web/20000303130911/http://www.vsf.ca...](https://web.archive.org/web/20000303130911/http://www.vsf.cape.com/~emergent/sherman.htm)

------
glofish
the fundamental problem with Rebol was cultural,

the creator had an ancient/dinosaur mentality where he thought selling the
language itself was the business proposition, hence the licensing and limits
that ultimately killed the language

------
pyuser583
This makes me really happy.

I've been watching REBOL/RED anticipation, and recently, frustration.

At first they looked amazing. Then it was clear they weren't being adapted.
Now I'm just hoping other languages will be inspired by them.

~~~
9214
Rebol died as a siloed tech and a late-bloomer in the age of open-source, Red
is chugging along, but the rub is that everyone appears to be watching and
anticipating from afar, while very few of the followers help the project to
achieve its goals and gain the adoption that the public seemingly wishes for.

I don't know if this is a historical/cultural problem with the language family
itself, or if it's a matter of project's priorities and community incentives.
What I do know is that lack of initiative won't bring your dreams to fruition.

------
elfgoh
Total newbie here: Are there any similarities between Elm and Rebol/Red?

~~~
9214
None or very few surface-level resemblances. Both projects live on the
different planes of abstraction, have different goals, and take different
paths in achieving them.

------
mucholove
2 questions:

A) is Rebol 2 open source? If no, why?

B) What are the big gotchas?

~~~
oofoe
REBOL 3 has been open sourced, at least to some extent:
[http://github.com/carls/R3A110](http://github.com/carls/R3A110)

As usual with this kind of conversion there were things they couldn't open
source or otherwise include.

The biggest problem (for me) with R3 is that they decided to redo REBOL 2's
incredible compositing GUI environment, but ran out of runway before they
could finish. It needed a rework -- people expect more from modern apps. But
R2's GUI stuff is just so good, simple and orthoganal. It has completely
spoiled me for any other GUI platform. I even wound up implementing a chunk of
their GUI SDL in Python so I could bear to work with Wx.

However, it's still a pretty small language and has some really nice
capabilities. It's very different from a lot of other languages, but it's also
one of the faster ones to develop in. Using R2, I was able to provide and
support rich GUI apps for a department at my company that I wouldn't otherwise
have been able to help. These weren't typical line-of-business electronic
forms either, but graphical editing tools with fullscreen interfaces, database
connectivity and heavy parsing.

I really miss using REBOL...

------
unixhero
Is Rebol related to Red and REXX?

~~~
Jtsummers
Red was inspired by REBOL and based on it. Since Carl Sassenrath helped
develop the Amiga, I would imagine ARexx could've influenced his design of
REBOL.

