Jai Language Primer (2017) (github.com)

Which moment have you been waiting for? I have also spent a lot of time watching his streams, but I don't believe Jai is a thing anybody can use yet, is it?

It’s not public yet, still in close beta

I'm into PL(T) stuff and I've gotten tired about hearing about Jai. One thing I like is Jai adopting the SPAD X-form (Chi-form); he (mis)attributes it to Sean Barret:

    The syntax name: type = value; specifies that a variable named name is of the type type and is to receive the value value

Where the inferred/imperative-assignment form is a visual reduction:

    name : type = expr
    name := expr

It has the lovely property that if you elide the type expression the variable gets an inferred type. If you keep the type expression, then the language has both a type-expression for type-checking and type of the value-expression for type-inference; then, the PL can be designed in one of a few ways:

1. If the type expression mismatches the type of the value-expression, fail;

2. If the type expression can be unified with the type of value-expression, keep the unified; or,

3. If the value expression can be coerced to the type expression, keep the type expression.

SPAD used the second behavior and it was the bees-knees. This was especially true since SPAD supported refinement (quotient) types, so you could do things like this:

    name : int(-2 < n and n <= 10) = ... complex expression that we can't prove is in the range (-2, 10] ...;

... and this would fail to compile.

    var damage: float = 10.5
    var damage := 10.5
    var dynamic_typed_damage = 10.5

Year added above. Thanks!

Year added above. Thanks!

I'm not super eager at having to watch a few 1-2 hours videos to even understand why I should use Jai.

jblow seems like a really talented developer. I loved Braid and there's clearly some great work being put into Jai. But if (and this is a big if) he wants to make Jai into a language people use, he should seriously consider putting more effort into the documentation and distribution side.

The page says "Jai could be described as a modern replacement for C"

Rust and Zig are other languages that more or less try to be replacements for C. Without having looked too deeply, it feels like Jai could more or less be described as similar to D (with the -betterC flag, perhaps). Does that seem like a reasonable characterization? Is there something specific that Jai brings to the table that those other languages don't?

You might very well be fighting against a force of nature, i.e. shouting at the wind.

Well, if you split "language" into 1) syntax, 2) semantics, 3) standard library, then why would you think that #1 (syntax) is the only part that can't be improved upon?

Most of it doesn't seem terribly new. It's like a hybrid of some classic-Algol-style, C-style, and Haskell-style (particularly at the function/struct declarations), but mostly C-style.

That he seems to have thought deliberately about stepwise refactoring is actually pretty nice. This is hard to do in many languages (where refactoring-to-function/method is often a wholesale endeavor). Doing it stepwise means you can iterate and test more deliberately throughout the process, and is nicer if you're not using a refactoring tool beyond your text editor.

In the end, reading the example code caused me no headaches, it was as clear as any other C/Algol-derived language.

It is no longer in the language. Much of this document is extremely out of date.

Ahh, I wish they could do concise text updates like this article, videos are so time consuming.