xvm VS langs

I'm just going to warn you in advance that invocation is one of the hardest things in the compiler to make easy. In other words, the nicer your language's "developer experience" is around invocation, the more hell you're going to have to go through to get there. The AST nodes for Name( (NameExpression) and Invoke( (InvocationExpression) alone are 7kloc in the Ecstasy implementation, for example -- but the result is well worth it.

Ecstasy uses message passing automatically behind the scenes for asynchronous calls, but the message passing isn't visible at the language level (i.e. there is no "message object" or something like that visible). Basically, all Ecstasy code is executing on a fiber inside a service, and services are all running concurrently, so from any service realm to any service realm, the communication is by message.

Regarding Ecstasy, we did not set out to build a new language; we actually set out to solve a real world problem. Specifically, we wanted to be able to dramatically improve the density of workloads in data centers, by at least two orders of magnitude in the case of lightly used applications. Our initial goal was to create a runtime design that would support 10,000 stateful application instances on a single server. Let's call it the "a10k" problem 🤣 ... a tribute to the c10k problem from 1999. We refer to our goal as "zero carbon compute", i.e. we want to push the power and hardware cost for an application to as close to zero as possible; you can't reach zero, but you can get close. If we succeed, we will help reduce the electricity used in data centers over the next few decades by a significant percentage.

Parts of Ecstasy are now implemented in Ecstasy. Here's the Lexer, for example.

Ecstasy

A Future reference has the various capabilities that you'd imagine, taking lambdas for thenDo(), whenComplete(), etc. The reference, in the above example, is a local variable, so you just obtain it using the C-style & operator:

FWIW - here is the stage manager code that I referred to.

Ecstasy (xtclang.org): Currently working on session management for a cloud-based HTTP back end. Not exactly compiler or language stuff, but it certainly is exercising the compiler and language.

I prefer to make my AST nodes fairly rich, and let them do the brunt of the work themselves. Instead of the 5 lines of code above, the assignment statement node in Ecstasy is over 1000 LOC. But it handles everything from initial validation through the MLIR emission.

No, not that specific project. It's our own Mid Level Intermediate Representation (or Mid Level Intermediate Language), aka MLIR/MLIL. Here's a snapshot of the operators.

Well, I only wrote a few dozen lines in each. (Those benchmarks I wrote are here, all in one file; scroll through to find them. Those two will be at the end.

Next I tried writing a custom C program just for the VM execute function; mostly this was a framework machine-generated from my interpreter, with the handlers necessary filled in manually.

This is my doswitch/u-based test program, a mini-interpreter executing a loop.

Actually the next thing I did after trying svm.c was to port it to my systems language to see how my compiler managed with it. (Source is here.)

I have taken something away from Forth which is the (a--b) notation that describes the stack behaviour. I use it in these early docs of my IL here.

The 1Mlps (just over actually) was specifically on this 740Kloc test input. I've used the equivalents in other languages for compiler testing, but they are now all out of date.

(This is the version in my syntax. It's zipped because it's large at 9MB)