6 ms·

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

9214 8y ago
Although Logo is said to be an ancestor to Rebol (which in turn is an ancestor to Red), there's more it than an apparent "childish" simplicity on the surface. http://www.rebol.com/article/0103.html http://www.rebol.com/article/0103.html Language that hits the sweet spot between Forth and Lisp might be a good fit for some kids, but its scope is way outside of mere scripting and toying, and demands a respective approach - something that only grown-up engineers can fully appreciate. YMMW.
- Izkata 8y ago
  It's been 19 years since I started learning to program with Rebol, it's still my go-to language for personal projects.
- vanderZwan 8y ago
  > its scope is way outside of mere scripting and toying, and demands a respective approach Maybe I misunderstand where you are coming from, but to me this appears similar to saying that using acrylic paint demands a respective approach because the great paintings of the last century were made with it. To which I would say: no, not really. Acrylic paint only demands a respective approach in the sense that it may be toxic and you don't want kids to finger paint or risk swallowing it. But people can paint whatever they want with it. Similarly, Red demands a respective approach because it's powerful enough to shoot yourself in the foot (oops, some kid deleted half of the files on the SSD by accident). Maybe that is what you meant with "scope", but it's not what I made out of it upon first reading. Besides, the solution for that is simple enough: make a child-safe dialect.
  - 9214 8y ago
    My point is that Rebol and Red are extremely good chameleons - they hide all their power behind the approachable facade, and make a false impression of "oh it's just X, nothing serious". I saw a fair share of people who, based on that first impression, dismiss Red as a quirky alternative to Python, or a GUI-building kit, or a pretentious academical toy, you name it. But that doesn't mean that these languages child-safe by default, and indeed, foot-shooting starts as soon as you begin to harness that power - that's where the real fun is, which IMO kids can't appreciate fully. As you said, it's anything but a finger paint. But if it clicks in kid's brain from the get-go and grows over him, then the world is ought to see some great paintings ;)
    - vanderZwan 8y ago
      Ah, so we were more or less on the same page from the beginning. BTW, is there a child-safe dialect for Red? How easy or hard would it be to create an environment like Processing or p5.js, without the foot-shooting risks? https://processing.org/ https://processing.org/ http://p5js.org/ http://p5js.org/
      - 9214 8y ago
        That kinda a broad question. Easy - you can create a live-coding IDE in 20 lines or so, Draw and View a pretty capable for interactive Processing-like demos, bottlenecks can be rewritten in R/S. Hard - hit the academical papers and define what can be considered a "child-safe programming environment". Then implement a separate toolchain for that.
        vanderZwan 8y ago
        I was thinking more along the lines of [Somewhere between Easy and Hard?] - make the dialect operate in a safe sandbox that can't destroy your computer ... plus optionally convenience functions fitting for the creative problem domain like how Processing removes a lot of Java boilerplate, and p5 does similar things for using the various JS APIs. One can just look at the APIs of Processing, p5 and OpenFrameworks to get an idea of what works there, though.
        9214 8y ago
        Safe sandbox: Rebol had Protect and Secure dialects [1, 2], which are planned to be implemented in Red. Language is very dynamic though, so there's a certain limit on what kind of safety can be enforced at runtime. Creative problem domain: that's what Red is all about in my point of view - slapping domain-specific languages one on top of another to pin down the exact problem space. Draw for 2d vector drawing, View for GUIs, Parse for, well, parsing and metaprogramming, et cetera. The crux is usage of same data format and common notation at every abstraction layer, be it low-level programming or high-level scripting. I don't think that Red can handle large-scale projects the way language workbenches do (yet), but it can be used for moderately small embedded DSLs. Does that answer your question? [1]: http://www.rebol.com/docs/words/wsecure.html http://www.rebol.com/docs/words/wsecure.html [2]: http://www.rebol.com/docs/words/wprotect-system.html http://www.rebol.com/docs/words/wprotect-system.html
decomposed 8y ago
It is "amazingly simple to get started" but also amazingly difficult to go much deeper. Some of this, imo, is because the preferred introduction to Red/Rebol is commonly the view (GUI) subsystem. Gradual documentation or other structured paths to the deeper end of Red/Rebol appears to be non-existent. I've seen Red compared to Lisp, Smalltalk, and Forth and other concise languages. But Smalltalk syntax can famously be fully represented on a postcard. (https://pharoweekly.wordpress.com/2018/06/02/all-pharo-syntax-on-a-postcard/ https://pharoweekly.wordpress.com/2018/06/02/all-pharo-synta...) Lisp syntax is even more simple and orthogonal. (Lisp BNF http://cuiwww.unige.ch/isi/bnf/LISP/BNFlisp.html http://cuiwww.unige.ch/isi/bnf/LISP/BNFlisp.html) I didn't find a good, common BNF for Forth in a quick web search but the stack is exposed and complete, standardized implementations are historically common; I did one myself once upon a time. What about Red/Rebol? Where is the BNF? Anyway, the road to Red/Rebol deep mastery is heavily shrouded at present. All that said, the Red project is amazing and pretty much unique in ambition and I, for one, am certainly hoping it makes it through to a solid 1.0. At that point, I hope, strong effort will allow the language to be fully grokked by, at least, the folks who are comfortable with the likes of Lisp and Haskell. Let's keep our fingers crossed and support the 2019 roadmap.
- 9214 8y ago
  > Where is the BNF? Here [1]. Red and Smalltalk syntax look similar, but semantics are very different. They only relation to object-oriented languages Red / Rebol have is through prototype-based OOP, e.g. Self [2]. Forth doesn't have any grammar specification AFAIK - any space-separated string of ASCII tokens is a valid Forth program, but it may vary from dialect to dialect. It's more of an idea than programming language. [1]: https://github.com/meijeru/red.specs-public/blob/master/specs.adoc https://github.com/meijeru/red.specs-public/blob/master/spec... [2]: http://www.selflanguage.org/ http://www.selflanguage.org/
  - decomposed 8y ago
    It is good to see there IS a specification; I - and I think some others (see the Temple OS comments) - had concern Red/Rebol might actually be too ad hoc (throw things against the wall and see if they stick). Is there means to access the lexer directly as a means to explicate how, exactly, Red is interpreting? The use of blocks in Red, and the layout in general, did remind me of Smalltalk but in Smalltalk I could at least rely on really simple syntax rules including some really useful grouping tools to break things up into more human friendly chunks (parens; semicolon; and period). The spec says "* As a first operation of the toolchain, the text file will be subjected to lexical analysis which will break the text up in a series of lexemes, i.e. textual representations of Red single values, interspersed with grouping tokens. The grouping tokens should occur in properly nested pairs, and are the following: ( ), [ ], #( ), #[ ]. A sequence of lexemes enclosed in matching grouping tokens represents a Red grouped value of a certain type, and this construct may again be enclosed in grouping tokens etc. Note that the token pairs " ", #" ", { }, #{ } and < > each delimit a single value, they are not grouping tokens...As a rule, lexemes must be separated from each other and from grouping tokens by one or more whitespace characters.*" Anyway, I think trivial access to the lexer output, so one might SEE exactly how the Red interpreter is viewing things, would go a long way toward dispelling the "Temple OS" concern and providing that on-ramp that IMO is otherwise missing. Any help on this front?

9214 8y ago

Although Logo is said to be an ancestor to Rebol (which in turn is an ancestor to Red), there's more it than an apparent "childish" simplicity on the surface. http://www.rebol.com/article/0103.html http://www.rebol.com/article/0103.html Language that hits the sweet spot between Forth and Lisp might be a good fit for some kids, but its scope is way outside of mere scripting and toying, and demands a respective approach - something that only grown-up engineers can fully appreciate. YMMW.

Izkata 8y ago
It's been 19 years since I started learning to program with Rebol, it's still my go-to language for personal projects.
vanderZwan 8y ago
> its scope is way outside of mere scripting and toying, and demands a respective approach Maybe I misunderstand where you are coming from, but to me this appears similar to saying that using acrylic paint demands a respective approach because the great paintings of the last century were made with it. To which I would say: no, not really. Acrylic paint only demands a respective approach in the sense that it may be toxic and you don't want kids to finger paint or risk swallowing it. But people can paint whatever they want with it. Similarly, Red demands a respective approach because it's powerful enough to shoot yourself in the foot (oops, some kid deleted half of the files on the SSD by accident). Maybe that is what you meant with "scope", but it's not what I made out of it upon first reading. Besides, the solution for that is simple enough: make a child-safe dialect.
- 9214 8y ago
  My point is that Rebol and Red are extremely good chameleons - they hide all their power behind the approachable facade, and make a false impression of "oh it's just X, nothing serious". I saw a fair share of people who, based on that first impression, dismiss Red as a quirky alternative to Python, or a GUI-building kit, or a pretentious academical toy, you name it. But that doesn't mean that these languages child-safe by default, and indeed, foot-shooting starts as soon as you begin to harness that power - that's where the real fun is, which IMO kids can't appreciate fully. As you said, it's anything but a finger paint. But if it clicks in kid's brain from the get-go and grows over him, then the world is ought to see some great paintings ;)
  - vanderZwan 8y ago
    Ah, so we were more or less on the same page from the beginning. BTW, is there a child-safe dialect for Red? How easy or hard would it be to create an environment like Processing or p5.js, without the foot-shooting risks? https://processing.org/ https://processing.org/ http://p5js.org/ http://p5js.org/
    - 9214 8y ago
      That kinda a broad question. Easy - you can create a live-coding IDE in 20 lines or so, Draw and View a pretty capable for interactive Processing-like demos, bottlenecks can be rewritten in R/S. Hard - hit the academical papers and define what can be considered a "child-safe programming environment". Then implement a separate toolchain for that.
      - vanderZwan 8y ago
        I was thinking more along the lines of [Somewhere between Easy and Hard?] - make the dialect operate in a safe sandbox that can't destroy your computer ... plus optionally convenience functions fitting for the creative problem domain like how Processing removes a lot of Java boilerplate, and p5 does similar things for using the various JS APIs. One can just look at the APIs of Processing, p5 and OpenFrameworks to get an idea of what works there, though.
        9214 8y ago
        Safe sandbox: Rebol had Protect and Secure dialects [1, 2], which are planned to be implemented in Red. Language is very dynamic though, so there's a certain limit on what kind of safety can be enforced at runtime. Creative problem domain: that's what Red is all about in my point of view - slapping domain-specific languages one on top of another to pin down the exact problem space. Draw for 2d vector drawing, View for GUIs, Parse for, well, parsing and metaprogramming, et cetera. The crux is usage of same data format and common notation at every abstraction layer, be it low-level programming or high-level scripting. I don't think that Red can handle large-scale projects the way language workbenches do (yet), but it can be used for moderately small embedded DSLs. Does that answer your question? [1]: http://www.rebol.com/docs/words/wsecure.html http://www.rebol.com/docs/words/wsecure.html [2]: http://www.rebol.com/docs/words/wprotect-system.html http://www.rebol.com/docs/words/wprotect-system.html

decomposed 8y ago

It is "amazingly simple to get started" but also amazingly difficult to go much deeper. Some of this, imo, is because the preferred introduction to Red/Rebol is commonly the view (GUI) subsystem. Gradual documentation or other structured paths to the deeper end of Red/Rebol appears to be non-existent. I've seen Red compared to Lisp, Smalltalk, and Forth and other concise languages. But Smalltalk syntax can famously be fully represented on a postcard. (https://pharoweekly.wordpress.com/2018/06/02/all-pharo-syntax-on-a-postcard/ https://pharoweekly.wordpress.com/2018/06/02/all-pharo-synta...) Lisp syntax is even more simple and orthogonal. (Lisp BNF http://cuiwww.unige.ch/isi/bnf/LISP/BNFlisp.html http://cuiwww.unige.ch/isi/bnf/LISP/BNFlisp.html) I didn't find a good, common BNF for Forth in a quick web search but the stack is exposed and complete, standardized implementations are historically common; I did one myself once upon a time. What about Red/Rebol? Where is the BNF? Anyway, the road to Red/Rebol deep mastery is heavily shrouded at present. All that said, the Red project is amazing and pretty much unique in ambition and I, for one, am certainly hoping it makes it through to a solid 1.0. At that point, I hope, strong effort will allow the language to be fully grokked by, at least, the folks who are comfortable with the likes of Lisp and Haskell. Let's keep our fingers crossed and support the 2019 roadmap.

9214 8y ago
> Where is the BNF? Here [1]. Red and Smalltalk syntax look similar, but semantics are very different. They only relation to object-oriented languages Red / Rebol have is through prototype-based OOP, e.g. Self [2]. Forth doesn't have any grammar specification AFAIK - any space-separated string of ASCII tokens is a valid Forth program, but it may vary from dialect to dialect. It's more of an idea than programming language. [1]: https://github.com/meijeru/red.specs-public/blob/master/specs.adoc https://github.com/meijeru/red.specs-public/blob/master/spec... [2]: http://www.selflanguage.org/ http://www.selflanguage.org/
- decomposed 8y ago
  It is good to see there IS a specification; I - and I think some others (see the Temple OS comments) - had concern Red/Rebol might actually be too ad hoc (throw things against the wall and see if they stick). Is there means to access the lexer directly as a means to explicate how, exactly, Red is interpreting? The use of blocks in Red, and the layout in general, did remind me of Smalltalk but in Smalltalk I could at least rely on really simple syntax rules including some really useful grouping tools to break things up into more human friendly chunks (parens; semicolon; and period). The spec says "* As a first operation of the toolchain, the text file will be subjected to lexical analysis which will break the text up in a series of lexemes, i.e. textual representations of Red single values, interspersed with grouping tokens. The grouping tokens should occur in properly nested pairs, and are the following: ( ), [ ], #( ), #[ ]. A sequence of lexemes enclosed in matching grouping tokens represents a Red grouped value of a certain type, and this construct may again be enclosed in grouping tokens etc. Note that the token pairs " ", #" ", { }, #{ } and < > each delimit a single value, they are not grouping tokens...As a rule, lexemes must be separated from each other and from grouping tokens by one or more whitespace characters.*" Anyway, I think trivial access to the lexer output, so one might SEE exactly how the Red interpreter is viewing things, would go a long way toward dispelling the "Temple OS" concern and providing that on-ramp that IMO is otherwise missing. Any help on this front?