xvm VS TablaM

Have a look at the ecstasy library for the language definitions of these types.

2) Funky interfaces: This is an Ecstasy interface that declares abstract static members (e.g. functions), which can then be implemented on any class and overridden on any sub-class, such that they can be invoked by type (instead of this), and virtually resolved (late bound at runtime) based on the type known at compile time. The best known example, of course, is Hashable, because it has to guarantee that a type implements both equals() and hashCode() on the same class, and the implementation is tied to the type, and not to the this. (C# added a similar feature last year in version 11.)

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.

Generally, left to right, one character at a time. If you’re looking for example code, here’s a simple hand-built lexer.

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

Ecstasy

Ecstasy and the xvm were designed assuming an adaptive runtime compiler (similar in concept to the Hotspot compiler for Java), but not necessarily using a JIT.

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:

FoxPro(dBase family) was a much better take on the idea.

I also dream of something modern like this (https://tablam.org) but is certainly a significant undertaking. Accept partners!

I wish I could devote to build my dream programming language (https://tablam.org) that has several hard questions and troubles (mainly I wanna rebuild in full something like FoxPro).

But, there are things I truly have dream but have dedicated almost not effort trying:

* Play (rock) bass

* Draw comic/manga style. I wish to make histories and think I could do it but refuse to write plain words (idiot!).

Basically, art is my unreachable goal

And what it make this even better, is that you can also write `SQL` so you can have the best of both worlds.

BTW, I think this idea can be move even further and my take is at https://tablam.org

I love these ideas! I've been thinking about the "fully relational" language ever since I worked with some product folks and marketers at my start up 15 years ago who "couldn't code" but were wizards at cooking up SQL queries to answer questions about what was going on with our users and product.

There was a language written in rust, Tablam[0] that I followed for a while, which seemed to espouse those ideas, but it seems like it's not being owrked on anymore.

And Jamie from Scattered Thoughts[1] has posted some interesting articles in that direction as well. He used to work on the old YC-company/product LightTable or Eve or something, which was in the same space.

I've also always thought Joe Armstrong's (RIP) thought of "why do we need modules" is really interesting, too. There's a language I've seen posted on HN here a couple times that seems to go in that approach, with functions named by their normalized hash contents, and referred to anywhere by that, but I can't seem to remember what it's called right now. Something like "Universe" I think?

[0] https://github.com/Tablam/TablaM

I have some work on this idea: https://tablam.org

BTW something closer was done with FoxPro and similar languages...

> Very curious if anyone knows how to pull this off.

I work in this space (small/mid-size).

The good news is that there are several "obvious" ways to pull this off because an ERP is the culmination of everything a company needs and does. So almost anything you can imagine on the software is part of it.

The bad news, and the reason everyone wants a solution, is that is truly a big space, and then you need E.V.E.R.Y.T.H.I.N.G.

---

My take is to start from the bottom, and build a much better version of Access/FoxPro (https://tablam.org).

Any medium/big ERP end being a specialized computing platform that needs:

- A programming language

- A database engine

- An orchestration engine

- ELT engine

- Auth

- UI/Report builders

And to be clear: NONE of the "programming language", "database engine", etc are a good fit today.

NONE.

This is the big thing, This is the reason (from a tech POW only) that most attempts fail.

This is the secret of why Cobol rule(d): Is all of this! but is too old! (also, this is why SQL still is best: Is almost this).

---

So, to pull this off, you need a team that knows what is "missing" from our current tools, makes a well-integrated package, and adds a "user-friendly" interface in a way that is palatable for the kind of user that uses excel (powerfully).

Is not that impossible. FoxPro was the best example of this kind of integrated solution.

P.D: This is my life's dream, to make this truth!

SEEKING VOLUNTEERS: TablaM relational language (https://tablam.org)

TablaM is an in-progress programming language to provide a more ergonomic experience for building data-oriented applications.

This means that where most languages are focused on low-level details or engineering at large, TablaM is tailored with some small & big design decisions to make it enjoyable to write applications for e-commerce, finance, ERPs, and similar.

Cool things:

- TablaM marry the array + relational models. It means we should get very little need for manual loops and all the ops are vectorized.

Yeah, I worked on https://tablam.org and https://spacetimedb.com.

It becomes pretty clear that `order` is a significant property to make useful (and performant!) programs. "Duplicates" is also required to make usefull programs.

One nonobvious reason for this: You wanna report that a `customer` has a duplicated key `1`. If you CAN'T model `[(customer.id = 1), (customer.id = 1)]` then you can't report errors! And `erroneous` data is VITAL to make useful programs because then the only possibility is "perfect" data, and that is not possible!

Another reason is that we want to `count` duplicates, to see `duplicates`, and other NON-obvious at first: "What is a duplicate?". Get fun with floats, Unicode, combining case and non-case sensitive input... and is obvious that for useful programs IS REQUIRED to support bags in an extended version of the relational model.

And yet...

IS very important to remember about `set semantics` and try to adhere to it when makes sense. Your query planner will like it. You "valid" constraints like it. And `unique index` like it. And so on...

Finally, for app development, I will "suggest" everyone use my lang https://tablam.org!

This is moe interesting than it looks, probably because the best part (IMHO) is about the type system, that is what enables the other ideas.

> In Julia, types are first-class and every value has a type

This is what I do from the start in https://tablam.org and only later found that is not common! Is so intuitive this way and simpler to check, by a lot. In fact, I waste so much time adapting type inference algorithms that are hard to translate because for some reason graphs are imposed on trees, types are second-class and live at a distance (and erased) and all is a mess this way.

The relational model already makes this so simple: `project / rename / extend` relational operators cover you.

From this other facilities become possible. Note how in `SQL` you don't have functions as first-class per se, but now try to imagine that a function is a table and suddenly, is much better!