Launching Version 13.0 of Wolfram Language and Mathematica

Why don't you answer the question?

Each run of some specific code is “ouch, we must try and see when we have the time to understand how it works and how each error is handled.” Just because it is soooo difficult to properly write a module.

This isn't the language though. A runtime in Mathematica is called a kernel. By default, Mathematica uses one. I think base licenses allow you to run two simultaneous runtimes and you can buy more. When you start a new window you have to pick the kernel, it doesn't launch its own like Jupyter would do.

This is an annoyance with Mathematica: it's proprietary software so it's in a world of license servers, license keys, artificial limits and paid upgrades.

I've dreamed about creating a language like this, but had to give up because it makes diagnostics impossible in case o typos and things like that..

My best bet now is to have some quote syntax to make a symbol stand for an abstract symbol, like

1 + x -- this sums 1 with x, and errors if x is unbound

1 + 'x -- this is an abstract expression, doesn't care if x is bound or not

Like lisp, except with some first class support to things like derive(1 + 'x, 'x), and, well, every operator needs to respect quoted symbols.. even if + were a user-defined operator or function, 1 + 'x needs to return (the AST) 1 + 'x. I suppose this is the same as Mathematica, except that Mathematica doesn't need quoting

I claim any semantics which resulted in `11` would be extremely confusing, because it would imply the following also resulting in `11`, which is obvious nonsense:

    y = 10;
    Module[{y}, 1+y]

y = 1;

expression = Block[{y},1+y];

Print[expression]

2

There are also the 'formal' symbols, e.g. https://reference.wolfram.com/language/ref/character/FormalY... if you want a symbol that will never be assigned a value but can still be substituted using ReplaceAll etc.

Anyway, to solve your first problem, add the definition f[_]:= Throw["Your error message here"}

To solve your second problem, use Block instead of Module (though in your simple example given here the solution is to just use neither).

Datasets have grown in size exponentially. You deal with images which are no longer few kilobytes. Window managers in the GUI have to paint over a much larger display area even if you consider whitespace. To do a hobby project like for e.g build a toy spam-filter or a toy classifier, the prompt to execution takes over 6 minutes on a really tiny model. I don't see why this hobby project angle seems viable either. Hence, why I said its unusable practically.

But what he's missing in his points is that Mathematica is led by a company! They get to design it, they get to organize it, so they have full control of it still. Look at Terraform: it's horrible usability-wise and has tons of limitations. If it was open source, it would have had auto-import from day one, adding a version or depends_on to modules would've happened from day one, and something like CDK probably would have already been built in, so Pulumi probably wouldn't exist either. But since Hashicorp controls it, it only works the way they want, in spite of open source.

As long as Stephen's company is developing Mathematica, they can maintain full control (of their distribution of it), and it's extremely unlikely for any fork to be successful.