So here we are, 1/3 of the way through 2021 already. How can things seem so long and yet time pass quickly at the same time?
One element of good news is that today marks my 2-weeks-since-second-coronvirus vaccination shot. I'm pretty sure this means I'm immortal now.
Having been cooped up too long, I'm going to get back to my traveling lifestyle--once I take care of some necessary business, like seeing the dentist and stuff.
So it seems a good moment to quickly take stock of what's happened since January.
Despite Downtime And Distractions, Lots Of Good News
I've been involved in some other things (I've mentioned Rust programming, for instance). And given the monotony of staying in all the time, there have been stretches of time where I didn't feel like looking at code and just watching animal videos on YouTube all day.
Especially harrowing is trying to make progress on fundamental issues of binding and modules. There's not some map to follow, and there may be no answer. It can turn into a death spiral pretty easily.
So I wasn't necessarily all that optimistic I'd have a good roster of things to report before I pack up and leave my island prison. But as luck would have it...a lot of things started working out and clicking into place!
Most Obvious Major Success Story: UPARSE
Rebol PARSE boasts a nice gimmick of the mixture of BLOCK!s for rules and GROUP!s for imperative code. The groups have sequencing of rules implicit just by having one follow another...no special operator or function calls required.
But I'd been lamenting for a while that it really wasn't packing the punch it should, especially when compared to things like Haskell parser combinators. You couldn't make new PARSE keywords, and it was too locked down in terms of extracting little bits of series without being able to leverage abstraction to build bigger things.
When I started writing a combinator-based UPARSE--the way someone who didn't know C might try writing it within the language--I didn't know how successful it would be. The only thing I knew was that it would be very slow (so long as none of the combinators were written as natives). But what emerged is very, very good!
The backbone of difference in UPARSE surrounds rules not only knowing how much input they consume, but also having a "synthesized product". Especially satisfying is how this uses multiple-return values, which had some progress on improving their performance and hardening their feature set.
There are still many open questions. But what is clear is that leveraging the evaluator and frame mechanics is a HUGE win...as opposed to trying to write some limited and super-optimized state machine. This is truly code that vindicates my attention to the design how action invocations can be reified, reflected, and manipulated as FRAME! objects.
(I'm sure that some of the hesitance people have had to try writing their own PARSE in Rebol is related to speed when it runs. But it's also the case that historical Rebol2/Red/R3-Alpha just don't have good bones for doing a generic combinator parse dialect. The code would be a nightmare.
But Ren-C is far more powerful, so it is actually looking quite legible and good!)
As I tried to build in abilities like dealing with invisible combinators inside of the UPARSE engine, this drew out the fact that we didn't have good mechanics for that. The ideas that had been simmering and percolating around things like modal parameters finally clicked... into a comprehensive plan for how @ forms could let code deal with invisibility and null isotopes.
Less Obvious Major Success Story: "Sea Of Words"
The observation I made in Don't Fear the WORD! really seems like it is poignant to realizing what the difference of this medium is. Ren-C has been putting together the mechanics to make this feasible...being able to GC word spellings just as strings are GC'd. We just need to make the binding model account for it.
Top priority for this year was: "Kick the tires of virtual binding, optimize and clean it up as necessary". That kind of got subsumed into the module work and sea of words, which will continue to be the major issue.
I talked stacklessness getting integrated. Given that stackless is written, the major point of it has been made...I know how to design for it, and bits of it have been grafted in. Our real question remains about locking, and the language's general lack of destructors and lifetime management. What I've seen in Rust makes me think we might want to use something similar...to distinguish reference-counted objects to ones that are managed by an implicit borrowing protocol. I don't think there's really any other solution if we want any kind of destructors for things like iterators.
Debugging...well...the best I can say on that front is that the shape of UPARSE is very friendly to debugging. And the protocol surrounding @ is adding new smart ideas on how return results can go "meta" when doing something like a usermode TRACE.
As I said above, I'll have to see how much other stuff I get involved in before I can get a sense of how much to realistically expect to get done this year. But there is a lot going on, and a lot to get excited about--if one is the sort of person who is excited by this sort of thing.