9214

My 2 cents: please add an example or two for dialecting and homoiconicity, because that's IMO not apparent from what I've seen so far (granted, I could have missed some bits), and the terms "dialecting" and esp. "homoiconicity" are so ill-defined that everyone uses them to describe different things.

My understanding so far is that Arturo has VM-based interpreter (perhaps stack-based or even indirect-threaded, hence the mention of Forth as an inspiration) which operates on a syntax tree (either concrete or abstract, although Rebol uses the former) produced from textual source during lexing. Is that correct?

Alright, but personally I fail to see how is that qualitatively different from all the other mainstream languages that use strings as a compensatory kitchen sink to encode literals not present by default.

I see, so strings act as implicit "constructors" for datatypes (which are not even datatypes per se, just encoded information within a given string datatype), depending on their usage? This is indeed an interesting design choice. Rebol in such cases requires explicit conversion from string to a target type.

Red got sidetracked by an attempt to build local economy based on an ERC-20 token, to be precise: for tipping contributors, funding FOSS projects and helping maintainers, curating high-quality learning materials within community, etc. That didn't pan out in the near term since no-one shared the enthusiasm.

Besides, there are only a few active contributors helping the project, others, unfortunately, prefer to watch from afar and wait, or to pick Red apart feature-by-feature for other languages — and TBH I don't know if this is a historical problem with Rebol family or lack of goal-oriented communication from Red's side which would encourage people to participate (e.g. write a Postgres driver).

Could you please elaborate in what aspects Arthuro is ideologically inspired by Rebol, aside from minor syntax resemblance?

Which is in fact Logo's syntax. I don't see any literal forms for IP addresses, URLs, e-mails, dates, @references and hashtags in Arturo, which are historically present in Rebol and which make it unique.

Compatibility with either Rebol 2 or 3 is not the goal, since Red takes the best parts from both.

Previous discussion: https://news.ycombinator.com/item?id=24686186

Could you please elaborate on what you find confusing about Red? Am genuinely interested as an active member of that project.

No, it's actually the other way around: Red and Rebol are interpreted by default, and Red has a bootstrapping AOT compiler capable of bridging it with Red/System (a C-like sub-language), which it turn targets machine code. However, since Red is highly dynamic, compiler cannot preserve semantics across the whole language, so it keeps some parts for the interpreter to process at run-time. And sometimes that's the only option, since code can be generated on-the-fly or pulled over the network: Red is homoiconic and has quite powerful meta-programming facilities on top of that.

Nim and Red are quite different languages, both in terms of semantics and in terms of project's goals and scope. Perhaps you should elaborate on an intersection that you see between the two.

I can speak only for Red: it takes its heritage in Lisp, Forth and Logo, has an embeded cross-platform GUI engine with a dedicated DSL for UI building, C-like sub-language for system level programming, OMeta-like PEG parser, and unique type system with literal forms for things like currencies, URLs, e-mail and dates with hashtags; all of that fitting in one-megabyte binary and valuing human-centered design above all.

There's Red with its Parse meta-DSL.

https://www.red-lang.org/2013/11/041-introducing-parse.html

Blocks in Rebol are not a mere "stuff" delineated by square brackets. Rather, it's a heterogeneous container that can hold first-class values and represent both code and data (homoiconic property), thus serving as a base for the syntactically-rich data format.

It also has a well-defined model [1] within the language, and, as such, can be freely operated upon at the run-time.

On a grand scale of language design, blocks form a concrete-syntax tree that can be derived from (or converted to) both textual [2] and serialized binary [3] forms.

Moreso, Rebol's syntax was in fact inspired by Logo. So, the relation between Arturo and Rebol seems to be very superficial; reminds me of Spry [4] that claims to be Rebol-like but is in fact an opinionated Smalltalk.

[1]: http://www.rebol.com/docs/core23/rebolcore-6.html

[2]: https://pointillistic.com/ren/

[3]: https://github.com/red/docs/blob/master/en/redbin.adoc

[4]: http://sprylang.se/

The basic premise (The friendly data format for human & machine) instantly reminded me of Red language [1], which, by the virtue of homoiconicity, is also its own data format (both textual and binary [2]) with 50 datatypes, many with several unique literal forms:

  date:      4-Oct-2020 4/11/20
  time:      13:04:07
  url:       https://concise-encoding.org
  email:     kstenerud@gmail.com
  ref:       @kstenerud
  tag:       <div color="red">
  integer:   123 
  float:     123.45 1.#NaN -1.#INF
  pair:      67x89
  percent:   9000%
  money:     USD$0.50
  binary:    #{deadbeef} 2#{00101101}
  container: [#hashtag "string" %file.ext #(key value)]
  ...

[1]: https://www.red-lang.org/p/about.html

[2]: https://github.com/red/docs/blob/master/en/redbin.adoc

For moderately small apps, Red language offers a cross-platform (Win32, Cocoa and GTK) graphical engine with an embedded DSL for declarative GUI specification. As a baseline comparison, 7GUIs task implemented with it clock under 300 LOC.

https://www.red-lang.org/2016/03/060-red-gui-system.html

https://eugenkiss.github.io/7guis/

https://github.com/9214/7guis-red

My comment about relevancy was more in line with @jdoliner's in the neighboring thread. I totally agree that tools and practices weren't quite there at the time and that things are different now.

The takeaway from Salmon experiment IMO is not specific to fMRI: you cannot trust a single technique or field "golden" standard (whether flawed or not), and should rather pursue accuracy across different pre- post-processing methods.

That's not realistically doable single-handily (at least in my experience), but in the current age it should become the norm to rely on publically available pipelines, probably with some sort of configuration files or even GUIs. I personally worked with fMRI only sparingly, so cannot comment on that in the context of the posted article.

Salmon story is more than a decade old at this point, and still as relevant as before; became an instant classic in my neuroscience-related MS programme. This Wired article elaborates on the motivation behind the study:

https://www.wired.com/2009/09/fmrisalmon/

What I described is more of an internal monologue thing, not even at linguistic level but as an attitude and stance towards stress with anxiety. Should have phrased it better.

Anxiety-management tricks that I personally employ is to either refer to a group/class I find myself in as "we" or to use passive rather than active voice.

The former I borrowed as a kid watching Spider Man 1994, where Brock/Venom symbiont calls themselves "we"; the latter is an inspiration from David Bohm's rheomode.

Both shift the perspective from your ego to the environment that it is embedded into and is a part of: e.g. a company, a crowd, a body ("we" as a human microbiome), humanity, or nature itself; not as an object, but as an ongoing process, from being to becoming. A giving up of ontological primacy.

https://en.wikipedia.org/wiki/E-Prime

https://en.wikipedia.org/wiki/Body_without_organs

Red language; foundation is based in Paris, France.

The title instantly reminded me of "Capitalism and Schizophrenia" authored by Deleuze & Guattari. A very interesting text on micropolitics of desire.

There's also a relatively old Common Lisp solution.

https://vitovan.com/dino.html

Kudos for mentioning the relation between FF:SW and Scheme, I didn't know that! This is one of my favorite movies since I was a kid. Pity the documentary [1] doesn't mention any of that.

The ideas from Gaia theory and neovitalism in it are what eventually got me into my MS program (neurorehabilitation & bio-signal processing), and venerable SICP was the first programming book that really clicked with me. Heck, I even bought a phantom figurine for my working desk.

Speaking of actors, "Robot Ghosts and Wired Dreams" [2] has a whole chapter discussing Aki Ross (the main protagonist) as the first virtual actress, with a very interesting rhetoric (an excerpt follows):

Final Fantasy is made disturbing by the fact that not only the Phantoms but the human characters as well appear undead. The ontological uncertainty of these digital humans has several sources. While the Phantoms derive part of their proliferating, malignant vitality from the human spirits they prey on, the filmʼs CGI humans literally "vampirize" the motion-capture actors who modeled them. The elastic, dot-constellation figures produced by the computer from motion-capture data provided by real human actors absorbed, as it were, the latterʼs "lifeblood", which then became the "living material" of the digital actorʼs "lifelike" behavior.

[1]: https://www.imdb.com/title/tt1634340/

[2]: https://www.upress.umn.edu/book-division/books/robot-ghosts-...

"We, as innovators, must learn to keep a 50-year-old programmer as useful as a new recruit." speaks about the ageism in software industry before it was even conceived as a term!

"Aesthetics and logic are both concerned with the enjoyment of a composition, as derived from the interconnections of its factors." -- Alfred North Whitehead, "Modes of Thought".

I wonder how this ties up with Naur's classical "Programming as Theory Building"? Also worth mentioning Gang of Four software patterns and their relation to the work and aesthetical thinking of Christopher Alexander (cf. "The Nature of Order").

TBH, the whole datatypes section needs a revamp. Will put Steve's blog on my weekend reading list. Cheers!

Thank you for taking your time to do a review! The prescriptive tone ("you should") on datatypes page doesn't really match the intent of the reference documentation (i.e. to inform), I agree.

Even if 50 vs 6-8 contrast sounds off-putting and overly sensationalist, it doesn't mean that language is more complex than its mainstream cousins. For example:

  ping @techdragon from http://www.rebol.com/docs/shell.html thread via hacker-news@techdragon.io
  today at 20:23:17 UTC
  say: your HN account was created on 11-February-2013 and has 1455 karma points 

Is a Red code (or rather data) containing 8 examples of unique datatypes (@reference, URL, e-mail, date and time, integer and flavors of symbols). One can even write a DSL that would understand it and send you a mail over SMTP or something.

I'd rather say "datatypes belong to 3-4 separate classes, each with a distinct yet simple semantics", and that "the set of their literal forms is diverse enough to count half a hundred exemplars; that makes the language simple, and the code written in it expressive". And then maybe build-up a motivation to study these classes ("to use Red effectively"), outline the studying path to take ("become familiar").

I don't follow Rust closely, is there any summary/takeaway of its history with documentation and community's lessons that I can read?

Interesting point, thanks. We do have community maintained learning materials [1] (+ wiki itself), official docs [2] and formal specification [3]; granted, even if put together they don't match the quality of a cohesive user guide.

[1]: https://github.com/red/red/wiki/%5BLINKS%5D-Learning-resourc...

[2]: https://doc.red-lang.org/

[3]: https://github.com/meijeru/red.specs-public

A rather strange thing to say, given that (a) Github arbitrary limits number of displayed repositories (try to refresh the page a few times) (b) there is Gitlab and other Git-repository managers with VCSs (c) there's a Gitter chat with daily activity [1].

It's true that community is small (yet tightly knit), but I wouldn't go as far as to call it absent.

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

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.