Mining History For Anything Relevant: Carl's Rebol Blog

Domains Redbol
1

Carl maintained two Rebol blogs. One was specifically for Rebol 3.0 development issues. But the other was for more general topics, essays, thoughts.

Here is the first post from February 5, 2008:

https://www.rebol.com/article/0001.html : "Ok, Let's Try It"

That blog apparently made it up to 554 posts, stalling out on February 25, 2018:

https://www.rebol.com/article/0554.html : Website Update, New Projects, Fresh Thoughts"

But it had been stalling out long before that (post #553 was in January of 2016 as part of a little spurt of notes.)

I Decided To Skim Through It For Anything Useful

It's a lot of material, but many of them are short (or obviously not relevant to Ren-C's interests). I'm in a mode of feeling like I'm seeing answers to old questions through the lens of what Ren-C can do today, so I thought I'd flip through them to see if anything caught my attention.

Here are some notes on any thoughts triggered...

  • IO Redirection - Rebol2 and R3-Alpha had many quirks and broken aspects in IO redirection. Ren-C actually does a pretty good job and has tests of it in various shells. At least a bit in part due to my hassling them, PowerShell actually changed the way they did IO to accommodate making binary redirection accommodate us (many other people wanted it too).

  • MakeDoc - I have never touched Rebol's MakeDoc, and pretty much only use MarkDown. Maybe someone who uses MakeDoc needs to write a post about it and if it matters at all in the modern ecology of such standards.

  • HASH! - The predecessor to Rebol's MAP! was a sort of optimization layer on top of blocks, where you still could enumerate them and experience them as blocks. But people insisted that a conventional key/value store which was dissociated from any order or enumeration structure was better. But in light of some recent findings about Python's Dict becoming order-preserving and deterministic, I wonder if MAP! was a wrong turn after all. Hmm.

  • Async Ports - Oh my, the beginnings of the nightmare. Thankfully that's over.

  • NEW-LINE - Naming a function NEW-LINE when NEWLINE is a character constant is pretty confusing. Ren-C has made a lot of progress here (including controlling terminal newlines in blocks) but never really came up with a good answer for how to better define functions to tweak the meta-formatting information. There's also a lot to be said about newline marker significance in dialects.

  • Mixed Dialects and REDUCE/ONLY - The idea of providing constructs that are more careful about executing code is something I've gone after, but more in terms of primitives like GET and SET not running code in GROUP!s in paths or tuples unless you say so. It's good to see Carl was thinking about "security" (or clarity). Ren-C sort of drifted away from thinking there's much hope in guessing what people will care about.

  • No Style Guide and Deep Lake - The idea that you use the style that fits you is very critical I think.

  • Context-Dependent Language - Hadn't seen this particular post before.

  • Was XML Flawed From The Start - Yes. I didn't know it but there is apparently a follow-up post.

  • Building in a DIFF Function - Hmmm. Not necessarily the worst idea to have one... dialected diff sounds interesting. But should probably be a module or extension.

  • Rebol Internationalization - In the past I've said it might be interesting to "skin" Rebol in usermode to be in other languages. Spanish or Chinese PARSE dialect, etc. UPARSE would let you map the combinators to different words. It's still interesting, but I think when it comes to stuff like internationalizing messages and error strings... it's probably time to just assume AI will be good enough for that. I don't think this project is going to do any localization in my lifetime.

  • Modules - "I should mention that modules are the main point of the REBOL 3.0 version." ... so unfortunate they more or less did not work at all. Ren-C has made great progress and things are much more promising, but there sure is a long way to go on the vision of a completely usermode module system that people can customize or override at will.

  • SET and GET on Objects - I dropped this feature, but it does raise another question of determinism in field ordering, as to whether you should even be able to do such a thing. It seems to me someone needs to lay down the fundamental philosophy about basic issues that persist in Redbols today, like:

    red>> obj1: make object! [a: 10 b: 20]
== make object! [
    a: 10
    b: 20
]

red>> obj2: make object! [b: 20 a: 10]
== make object! [
    b: 20
    a: 10
]

red>> obj1 = obj2
== false

  • Consistency in POKE - Aaah, this reminds me of all the "what is picking and poking and setting and getting" semantics issues. The code is going to need to be revisited for the plan of obj.method passing the OBJ to the method as a "coupling". It was a nightmare to work on, but maybe enough time has passed to where going in and cleaning it up will be "fun".

  • PARSE words are "commands"? - Hm. Well, I like "combinators". In any case, I don't know that I've used the word "command" much if ever. Should I?

  • Is Rebol a Pure Functional Language? - No, but it does remind me that I was thinking of making a PURE designator where any function marked pure could only call other pure functions. Could be a fun experiment.

  • Rebcode - I don't think I ever heard of this (or if I did, confused it with the binary storage REBBIN format or something). If I had infinite time I'd tinker with something like putting Red/System in the WebAssembly build and generating Wasm, but I don't. It seems clear in retrospect that this tendency to drift off from language design issues really burned up RebolTech's time.

  • BIND? - While Ren-C's Pure Virtual Binding is humming along running most code, being able to inquire and reflect the compounding environments is going to need a lot of deeper answers than this. And I still don't know exactly what to do about attached words...they're just there to keep the ship afloat for the moment. But worth pointing out that Rebol was pretty far along before it had the ability to query binding (AFAIK Red still doesn't have it, there's no BIND?)

  • Extending Objects - Thought is needed on this. It should definitely be a different operation than APPEND. My feeling is that APPEND on an OBJECT! should be reserved for interacting with that object's concept of what APPEND means (but does that mean it can't have its own idea of what EXTEND means?)

  • Checksum Ports - We have all the encryption code to do this but understanding what PORT!s are supposed to be keeps this on a very far back burner.

  • RebolTech Priorities - Interesting in light of my own writing on the topic. It's a different era, where people have so many free tools to choose from... where the only relevance I see is whether the language design offers something truly unique and notable.

  • Source For Carl's Blog - I didn't know he'd published it. The link is dead, but the Internet Archive has it: blog.r. I never used the CGI facilities but it's interesting to see that it is indeed just one long single file. (I'm idly curious about how this would compare to someone trying to do the same thing in PHP.)

  • Anthropomorphizing Errors - Interesting topic.

  • Two Year Rebol Blog Anniversary - In two years from 2008-2010 the Rebol blog got to 316 out of its 554 total posts.

  • FOLLOW was the original name of ALSO - Who knew. Either way, I don't like it.

  • PICK with LOGIC! - I never really cared for this. It's not obvious to me if true is the first item or the second one. Ren-C has soft-quoted branching, so you can do either (cond) 'this 'that and I find it a lot clearer. Now that logic is an antiform, it means the whole picking system gets messed up by needing to support antiforms. Not sure why I didn't kill this off yet...

  • Reacting to Complaints About Not Communicating - Seems the natives are getting restless around August 2008.

  • Rebol: Not For Everyone - I wrote a bit here about this post in 2018. Should probably see if I have any updated thoughts now that I know more.

  • The GUI: Harder Than It Seems - I've often been puzzled by the obsession the Rebol community has on the cross-platform GUI. Here we see an admission from Carl that it's harder than it seemed and eating up time. A prelude to today, where Red seems to drag along indefinitely with it. I'm pretty well-versed in Rebol design points, yet I find what they're making to largely be gibberish. HTML and CSS are pervasive, have been modernized with time, and I don't really think the GUI work has shown to be markedly ahead for any non-trivial task. :man_shrugging:

  • The suffix of Rebol Files - After having campaigned a bit on the side of saying Rebol should accept it doesn't own the "R" language term and use .reb I changed my mind. I think it should be .r. The reason I haven't gone around renaming things is because the disruption it would create doesn't make much sense to do until there's a good reason to go around and muck with all the file organization.

  • Enfix DEFAULT Before Enfix existed - I didn't know this had been considered, much less that you do it in Rebol2. That's surprising. The idea of making DEFAULT a dialect taking a BLOCK! is actually not something I had considered, and I'm not completely sure I hate. You get advantages in the sense that you could potentially default more than one thing...I'm going to have to think about it.

  • Announcement of PowerMezz - @rgchris had at one time undertaken a porting of this to Rebol3, and don't really remember what was in it. I didn't look too closely. But it could be a very good place to look for challenging problems in binding and parsing to ask "has Ren-C raised the bar so people trying to do these things can do them more clearly".

  • CALL/SHOW - Never saw this. I do think that for a GUI program, /SHOW should be the default. Worth looking at. I notice that call "explorer" returns an exit code of 1, which is now reported by CALL unless you do CALL/RELAX (or intercept it with EXCEPT).

  • LIB and SYS - Since I started using Rebol only after R3-Alpha, I'm often surprised to find things that you can't do in Rebol2... such as get the original version of a function if you overwrite it. I gather that to this day, in Red, if you say append: func [] [print "Hi"] without saving the old-append there's no way to get it back!

  • Fight Software Complexity Pollution - I cite this one a lot, I should cache it here on the forum and add some comments.

  • Common PARSE Patterns - Link is broken, and internet archive is down, look these up when it comes back. (Ok it's back and... well, not much there).

  • Simplicity Defined - While I respect that Carl certainly has thrown some unique vision into the mix of computing, no one knows the R3-Alpha code better than I do, and so sometimes these posts ring a bit hollow. It may have been easier to ramble from on high before the code was open sourced, but really R3-Alpha is every bit the ball of mud he is critiquing! But it is certainly the case that in its ideal form, Rebol is a rich-enough substrate for expressing one's domain knowledge simply... whereas other mediums (like say, bash) just are unsuitable...but people use them out of expedience or pragmatism.

  • Carl Announces Giving Up - August 2012 solicits opinions on the future, stating: "I also need to tell you that I don't have much time to help out with whatever the REBOL future may be."

  • Open-Sourcing Announcement - There was a bunch of debate over licensing, I said use the LGPL, it was made Apache to "appeal to more contributors". Yeah, right. Ren-C has been LGPL since September 2020

  • Rebol C Documentation Style - Comments in R3-Alpha weren't particularly copious. Ren-C has tons of them. I'm pretty pleased with how they're done, and have been adopting a kind of "headnote" style where I don't mix too much commenting directly into the code, but just tack on the end of the line // don't accept groups [3] and then have a section above somewhere that says // 3. The reason that we don't accept groups here is... Of course, Ren-C has much improved embedding of native function specs directly in the comments above natives as well.

  • "We Need a New Rebol Forum" - I have to wonder how things would have gone if we'd used Discourse earlier. This question was asked in November of 2012, and Discourse was released in August 2014.

  • Comparing Rebol and JSON - This is interesting because he is using BLOCK! for both arrays and key/value stores. He glosses over what that winds up meaning for systems interpreting the data. I'm suspicious that it is insignificant, I wrote a bit about this.

  • Calling REBOL, Rebol - Yes.

  • Rebol Conference, Montreal, 2013 - If not for me recording and editing the videos, there wouldn't be much left of it!

  • FUNCTION and CLOSURE - There's no more CLOSURE in Ren-C because all the good parts of it are subsumed into every function (at reasonable cost). Now I worry over LETs. Kind of funny to think how much I take for granted these days...

And That's About It...

So that took me a few hours, and feels worth it to have done so. He started a separate Rebol 3.0 tech blog, and after that it was mostly philosophy and administrivia posts. I'll do a similar survey of the tech blog.

While it seems to me the GUI is the killer of Redbols, it probably is what allowed Rebol2 to get the popularity that it did. Probably they shouldn't have made any changes to VID or the graphics. I think there's this tendency to want to go deep and burn time on grid controls or whatever the "one missing thing" is, when if an application is truly of any sophistication then it's always going to run up against the limit of what Rebol can offer.

I'll do some posts on the follow-up items here at some point.

1 Like