
Red Programming Language 0.6.3 - ZenoArrow
http://www.red-lang.org/2017/07/063-macos-gui-backend.html
======
throwaway7645
I'm always excited for a new Red release. I'm glad they're taking time to get
the GUI DSL right for 10 platforms, but I hope it doesn't come at the
detriment of enhancements to Red/System, Multi-Core, Concurrency, and all the
other promised goodies. The thing badly needed at this point I think is better
doc. I know it is ~95% compatible with REBOL, but honestly the REBOL doc is
very basic. It shows you how to do a lot of neat things with the built in
DSLs, but nowhere and i mean anywhere does it show you in any detail how to
implement your own DSL, while you frequently hear about how powerful the
dialects are. I'm still super pumped about this language and am thrilled for
each new release.

~~~
akavel
I also tried to learn the "PARSE dialect" (the DSL coding mechanism of
REBOL/Red), as this is what's often claimed to be the crucial differentiating
factor (the "main idea") of REBOL/Red - but I failed, because of what OP
mentions. The REBOL docs feel to me more like an example-based guide, than a
solid RTFM-grade manual. I find such a guide OK and valuable as a tutorial, a
starting point, and to teach idioms and mindset; but then I need a reference
manual to clarify all details and fully explore the topic. Also read some
third-party articles on PARSE, but none of them were comprehensive enough
(AFAIR, mostly being tutorial-like too). Lua and Go do it well in my opinion -
they both provide a solid tutorial-like experience, but then a full-blown,
well written reference manual too.

~~~
dockimbel
There are two third-party reference-like (but non-authoritative)
documentations that I know of [0][1]. A Red reference documentation for Parse
will be available later this year.

[0]
[https://en.wikibooks.org/wiki/REBOL_Programming/Language_Fea...](https://en.wikibooks.org/wiki/REBOL_Programming/Language_Features/Parse/Parse_expressions#Differences_between_R2_and_R3_parsing)

[1]
[https://github.com/gchiu/rebol.net/blob/master/wikipedia/Par...](https://github.com/gchiu/rebol.net/blob/master/wikipedia/Parse%20Project.wiki)

~~~
akavel
Thanks Nenad! :) The links indeed look interesting, at least at a first
glance, though it seems not quite clear to me which keywords are R2 vs. R3
(proposals?) vs. Red, especially in the link marked as [1]. Still, at least
that's something, will certainly be very useful if I try to understand PARSE
again at some point in future. And I'm very happy to hear you're planning some
more comprehensive docs for Red!

~~~
throwaway7645
Good to see I'm not the only one that has trouble transitioning from playing
with Rebol to actually using it in non-trivial programs. Sure they have a form
of OO, but I'm not sure if it is really idiomatic to use it a bunch or if
coding should be more like C. I'm prepared for Red zealotry though if they can
provide the experience that they're aiming for along with good doc.

~~~
draegtun
If there's any issue in particular you're having with Rebol then do pop by to
either...

* chat - [https://chat.stackoverflow.com/rooms/291/rebol](https://chat.stackoverflow.com/rooms/291/rebol)

* forum - [https://forum.rebol.info/](https://forum.rebol.info/)

... and we'll do our best to help.

~~~
throwaway7645
Thank you for all the help and kindness.

------
axaxs
Am I reading this right? A single binary, less than 1mb in size, that handles
GC and cross compiles? Color me impressed. Looking at platforms, does it not
do 64 bit?

~~~
throwaway7645
You're correct. It's crazy what you can do when you don't bundle 8 zillion MB
of C in your install. Rebol is the original parent language, but it doesn't
have a system language to compile to, just a < 5 MB interpreter that you could
do a lot with. Neat little languages. The creator wanted to take Rebol and
write a version that would be the first true "Full Stack" language covering
everything from desktop GUI to building OS, to highly advanced parsing, to
robotics. If you google it, there is a nice interview with Red's primary
author Nenad Rackocevic (forgive spelling) that is from ~2015, but still
should be accurate.

Interview:

[https://notamonadtutorial.com/interview-with-nenad-
rakocevic...](https://notamonadtutorial.com/interview-with-nenad-rakocevic-
about-red-a-rebol-inspired-programming-language-681133e3fd1c)

~~~
ASipos
Offtopic nitpick:

I never understood stuff like writing "forgive spelling" or "sp?" when the
correct spelling is a Google away.

~~~
rendall
I'd rather have misspelled information than not have it.

Some folks might be on a mobile device with an interface that makes it
difficult to switch to another window. Or perhaps they are offline when
they're writing it. Or perhaps they have mobility / accessibility issues that
makes switching a challenge. Those are off the top of my head.

To my mind, worrying about someone's spelling when I can understand them
perfectly is one of those "life's too short" issues, speeking personaly.

~~~
coldtea
> _Some folks might be on a mobile device with an interface that makes it
> difficult to switch to another window. Or perhaps they are offline when they
> 're writing it. Or perhaps they have mobility / accessibility issues that
> makes switching a challenge. Those are off the top of my head._

There's also momentum. They want to go write a quick comment and type their
thoughts as they come -- not stop and Google things.

~~~
greggirwin
This is certainly how I am sometimes. I will stop to check things, but it
breaks the flow. And, as comments here point out, docs are a big issue. What
isn't always clear is how much effort they take to create. With a small team,
it's a constant struggle for where to allocate resources. Right now, Red's
priorities are based on deliverable functionality.

~~~
throwaway7645
Thanks Greg! That is well understood and fine by me. I just don't want to see
Red's doc to end up like Rebol's. Honestly, it is probably a non-trivial
factor for why it never took off.

~~~
greggirwin
Still, [https://doc.red-lang.org/en/](https://doc.red-lang.org/en/) has some
nice docs, and more are in the works.

------
tgb
Non-mobile link which has more links to other content: [http://www.red-
lang.org/2017/07/063-macos-gui-backend.html](http://www.red-
lang.org/2017/07/063-macos-gui-backend.html)

------
Buttons840
Red looks like a good language. They seem to be supporting Linux last though,
which has kept me from trying it personally.

~~~
ncx
Linux supports everything that Windows and MacOS supports except for GUI.

As for GUI,

[https://gitter.im/red/red/welcome?at=595f60f50de4d2545e026e5...](https://gitter.im/red/red/welcome?at=595f60f50de4d2545e026e52)

> No timeframe until we find someone to work on it. Though, we should be
> presenting Red at the GNOME global conf in China on October, so I hope we
> can find someone motivated and skilled enough there to work on it.

So Linux GUI _might_ come not too late.

~~~
vanderZwan
That sounds a bit like a chicken and egg problem to me

------
tbirdz
Very Cool! I've got to try this out! I'm definitely picking up a bit of a Tcl
vibe here, which is another language I've been wanting to try out. Especially
with the integrated GUI toolkit, it's giving me some Tk vibes as well.

Does anyone know if there was any direct inspirational link from Tcl to
Red/Rebol, or was it just by the nature of the idea of making an extensible
langauge suitable for making lots of DSLs in?

~~~
greggirwin
Rebol/Red (a.k.a. Redbol) languages inherit from Lisp, Forth, and Logo, along
with Self for the object model. Tcl was not an influence as far as I know.
There will certainly be other minor influences, as Sassenrath, Ousterhout, and
Cowlishaw were all important designers in that era.

------
SeanDav
Looks interesting, almost too good to be true! How viable is the Android path
and is the plan to fully support Mobile features?

Just trying to get an idea of where Mobile development fits into the scene.

~~~
ZenoArrow
Android GUI support is planned for 0.6.5. iOS support is planned but not
started. Can get some sense of the maturity of different features by looking
at the feature and version roadmaps:

[http://www.red-lang.org/p/roadmap.html](http://www.red-
lang.org/p/roadmap.html)

[https://trello.com/b/FlQ6pzdB/red-tasks-
overview](https://trello.com/b/FlQ6pzdB/red-tasks-overview)

It is possible to compile console apps that run on Android right now, though
AFAIR this feature isn't fully stable yet.

It's also worth noting that Red can be used as an embedded language. So for
example, after 0.6.5 is released, you could have an Android app where the GUI
was written in Red, but code managing phone features like GPS could be written
in another language.

As for supporting mobile features directly, I imagine some of this will be
managed by libraries rather than baked into the language runtime. Worth noting
that the module system is planned for 0.8.0. However, it should be possible to
write feature rich mobile apps long before then.

------
agentgt
When Rebol first appeared it reminded me very much of new language that appear
at the same time called Curl (not be confused with ubiquitous HTTP tool).

The similarity, goals, and timing of release of both languages is in
interesting convergence. Curl unfortunately tried to go to commercial and died
a quick death. I'm glad Rebol and now Red are doing well.

~~~
greggirwin
Indeed, Curl had a number of common goals with Rebol. Good insight.

~~~
vram22
Such as? Interested to know, please see sibling comment by me.

~~~
greggirwin
The main one was that having a single language was a win, compared to mixing 6
or 7 of them, and their associated cognitive overhead. Red expands this in
both directions, with Red/System as the low level dialect and metaprogramming
at the highest level.

------
_mhr_
Could I use Red in a manner similar to Awk for record processing?

~~~
greggirwin
Yes, absolutely. Red has a `parse` function, that uses EBNF-like rules, but
someone has written a nice regex translator if you need that bit. It's also
possible to write a nice AWK-like dialect that handles things at a higher
level. I've done that in the past. One of the current limitations is that the
I/O model is simple, and there is no GC yet. Those will come in the relatively
near future, but if you have large files, or need long running processes, it
will be more work for a while. Still doable, just not as easy.

------
get52
why not blue lanG? XD

