Kaj Gets on the Meta Train

So Kaj is still out there somewhere, working on a spiritual competitor to Red he is calling "Meta". :roll_eyes:

https://language.metaproject.frl/

His first target is the Atari 2600 :joystick::space_invader: so he's certainly starting from... the basics.

(For whatever it's worth, I actually am interested in things like Atari 2600 programming and seeing what you can do with modern tools. e.g. there's a neat reboot of PAC-MAN and I think a lot of people would like to know what could have been done, theoretically.)

There's no source code by which to measure the amount of investment the project represents so far. He's only giving out binaries, and says:

"There will always be a free version of Meta. We will build a business on top of it, by offering paid premium versions and other products built with Meta."

What's The Mission Difference From Red?

Seemingly not much. But inevitably, one angle is going to be "faster":

"Red/System is the wrong abstraction level and the wrong format for an intermediate language, certainly for a REBOL language. The abstraction level is that of C, which is too low for the intermediate layer. The format is that of REBOL, which is free form for human use. Red is parsed from free form to something more suitable for machine processing, then a lot of Red/System is generated, then all of that needs to be reparsed. The compiler is painfully slow."

But he's willing to build on LLVM to start with. I'd said that Red should aim for a LLVM-subset IR, that could then be built with either a simple/small custom emitter or the full "bloated" toolchain if one really wanted to. That would have provided a fallback; but Nenad wasn't a fan of the LLVM instruction set for some reason, and had ideas about exposing lower-level CPU features (maybe that was why).

So at least in this sense Kaj's approach seems more pragmatic to me.

Also inevitably: having people to work with was slowing him down. He'll make much more progress on his own, as we find from his Atari Forum post:

Red was launched on a REBOL conference of mine in the Netherlands. I helped launch the language and contributed to it for half a decade. After that I left the project, because I am disappointed that it hasn't fulfilled its promises.

Before all that, I contributed to the latest version of REBOL and lobbied its creator Carl Sassenrath to open-source it. It eventually was, and REBOL could have done most of what Red promised, but Carl abandoned it when his funding ran out. After the leader left, the project was torn apart by competing interests.

My language is meant to succeed both REBOL and Red.

There's only ONE Download for Windows, Linux, Mac...?

On the surface this seems interesting: he's using something called the "APE: Actually Portable Executable" format. You can use a single download for all platforms--the same single file. It puts x86 code into a container that can run as either a Windows .COM file or a unix shell script.

It's a stunt which isn't really all that profound--though I'll admit I'd wondered if there was some polyglot trick that could do exactly this. Turns out the answer is yes...so that's cool. I'm glad someone did it.

But it has more relevance to writing viruses than it does to practical cross-platform development. Launching the code is a drop in the bucket compared to all the other things you need to worry about in a useful platform abstraction layer. Not to mention that obviously Macs are now on ARM, so the binaries would have to be emulated or include both instruction sets.

At this juncture, running WebAssembly in a browser is far more compelling a story...because you have the whole web runtime available.

Anyway I doubt he's married to the APE format and is just trying it out because it seems cool. It's not something I want to worry over. And for what it's worth, it doesn't work for me on Windows 11. YMMV.

Source Comparison?

Not much is available to compare. His examples don't have headers, which is one of the more defining historical properties of Rebol programs. The word "header" is not mentioned in his manifesto, so it's not clear if that's temporary or permanent.

Here's a Fibonacci example:

; Maximum 24 for natural16! result
; Max 47 for natural32! result
parameter= 24
 
print "Fibonacci "  print parameter  print ": "
 
natural! [Fibonacci previous]
; natural32! [Fibonacci previous]
 
either parameter <= 1 [
    Fibonacci: parameter  ; Fibonacci 0 ... 1
][
    Fibonacci: previous: 1  ; Fibonacci 2

    loop parameter - 2 [
        previous: also
            Fibonacci
            Fibonacci: Fibonacci + previous
     ]
]
 
print/line Fibonacci 

So...

  • It seems he wants PRINT to not include a newline, so you have to say PRINT/LINE to get it.

    • I prefer the solution of asking those who really want partial line output (e.g. console prompts) to WRITE STDOUT directly...and that PRINT COLLECT be used as a pattern when your code is piecing together a full line from parts generated by distinct bits of code, KEEP-ing each part.
  • Working on Atari means he's getting involved in things like INTEGER16!, and you optimize based on annotating datatypes like that. I'm more of the "bignum by default" philosophy, so different indeed.

    • Putting natural! [Fibonacci previous] in the middle of the code to constrain the type--not in a function spec--suggests this is really rather far afield from the evaluator-driven Rebol.
  • He's trotting out historical ALSO in a first example. No one in the Atari forum clapped with amazement at the genius several Rebolers seem to think it represents. (So I feel pretty comfortable with Ren-C's ALSO and ELIDE.)

Without more to look at I can't have more to say.

2 Likes

Well, I guess I can reiterate that I do find the Atari angle interesting in the sense that Kaj is acknowledging the recreational aspect of such pursuits. e.g. it's more a kind of thought/teaching/art experiment... than it is some obvious revolution in software which you'd want to be running your surgery robots or self-driving cars.

The conversations on the Atari Age forums thus lend themselves to reasonable questions from other old people about supporting features such as inline assembly from other Atari tools. (Whereas Red's marketing hype leads to young programmers asking about running Red-powered AI connected from the cloud on their toaster.)

But when he says "Meta is close to REBOL, but solves its weaknesses."...that really shows that what we consider the weaknesses of Rebol couldn't be more different.

When I looked at Rebol I never fretted about "whoa, it's too slow". I thought "whoa, it doesn't work".

Tricks that seemed great--like being able to make your own loop constructs--broke instantly when RETURN from inside your custom loop's body just stopped the loop and kept running. It seems many people who agreed this stuff was a problem...like Andreas, BrianH, and Ladislav...all vanished and went on to other things...leaving present company to worry about it. (Note: Only Gabriele remains remarking on the RETURN concept to the Red people)

I think people who were tied up on "Rebol is great because it's one file with no install process cross platform" are the ones who miss the point of Rebol. You could rig up Python or any other language to be a single EXE cross platform, and pre-package it with a GUI. These days you can pack anything up in Docker so it's a "single file". That isn't the special part.

The special part is giving people something they can bend into new dialects--without waiting for the language designers to do it for them. UPARSE goes there, in spades. I don't see this coming from other endeavors which seem to claim I take Rebol outside its original plan. :man_shrugging:

1 Like