Yatima: A programming language for the decentralized web

I didn't claim that we have solved or will solve the diversity problem, but I did articulate in the README a few ways that I thought Yatima might contribute.

I also don't agree with your characterization of Haskell, Rust and OCaml as being "high-barrier-to-entry" compared to Python. Personally, I find languages like Python much harder to work with given how arbitrary and detail oriented they are. I think for a lot of people that kind of language is fine. Those people are already well served by existing resources.

The people I want to reach are people who have not yet been exposed to a presentation of mathematics or computer science as an elegant unified field, where proofs are programs and theorems are types. This is what I would have responded well to as a kid who detested Math and CS well into my late teens. Much of what is marketed as "accessible" or "educational" in programming languages comes across as patronizing, a lot of visual programming languages are guilty of this. That approach would also not have worked for me.

So what I'm doing instead is building a language that I would thought was awesome when I was 12. Will that work for everyone, who knows? Probably not. But it would have worked for me, and if there are other people out there in the same situation, then that's good enough motivation for me to keep building.

One aspect of bad math education is that most folks competent in math can choose a different field than teaching and earn far more, without also figuring out how to motivate children while constrained by bureaucratized pedagogic dogma of the moment. Management is only sometimes a mob-of-children equivalent :-).

"vaporware" is a pretty harsh accusation for a project that has:

- A performant lazy functional runtime with sharing implemented from scratch in Rust

- A dependent type system with substructural types

- Parsing, tooling, a standard library, ability to run on the web via wasm

- Content-addressing and serialization to IPLD so that packages can be shared over IPFS

That's what we claim to do in our README, and that's what we do.

It's true that Yatima doesn't have an effect system yet, nor is it production-ready, but it's a pre-alpha programming language project, what's the standard being applied here?

I find it hard to reconcile these goals with the language you created: Monads, applicatives etc:

That is a steep hill to climb for beginners. Any ideas how to guide them along?

And it is also not clear how programming languages or computing are tied to corporations and not to individuals. There's no contradiction here.

And you need corporations to build the device you are currently using to reply. We do our jobs on the shoulder of giants. Thousands of corporations in a world-wide link that provide the necessary resources and know-how to build computers. Not sure how that rhymes with "computing should belong to individual users".

> I find it hard to reconcile these goals with the language you created: Monads, applicatives etc

You know, I've never understood the the "Monad is hard" meme. Monad isn't hard. Functor is hard. Like, really hard, especially when you consider contravariance and covariance. Monad is like a tiny little teaspoon of hard on top of the swimming pool of Functor hard.

But does any of that complexity prevent you from calling `Option::map` in Rust or `Array.prototype.map` in JS? Or from seeing the pattern between them?

"I have an A and a function A -> B, so I can make a B."

"I have a List A and a function A -> B, so I can make an List B."

"I have an Option A and a function A -> B, so I can make an Option B."

"I have an F A and a function A -> B, so I can make an F B."

Is that too steep of a hill for people? I don't think so. It may not be intuitive, but neither is learning to read and write, and it turns out that virtually everyone can do that with enough practice.

Yatima is not an intuitive language, but it is very simple, whereas a language like Python is much more intuitive, but vastly more complicated. My take is that the former set of properties makes for a more learnable system than the latter. Maybe I'm wrong on that, who knows, but to me it seems like a thesis worth exploring.

> And you need corporations to build the device you are currently using to reply. We do our jobs on the shoulder of giants. Thousands of corporations in a world-wide link that provide the necessary resources and know-how to build computers. Not sure how that rhymes with "computing should belong to individual users".

I appreciate the intricate dance of capital behind making the devices we're communicating on. That is not what I'm talking about when I say "computing should belong to individuals rather than corporations." I simply mean that users should have control and agency of what they do on the computing instruments they buy, in the same way they have control and agency of what they do with the writing instruments, or musical instruments they buy.

Or in concrete terms, I have nothing against Apple selling me an iPhone, great piece of hardware. But I do think that once I buy the phone, it's mine and I should be able to run what I want on it, without the phone telling Apple what I'm doing. It's a question of mental autonomy and integrity; I'm extending my mind through the device, so if Apple controls the phone it's like they control a piece of my mind.

For a programming language this philosophy informs a lot of decisions, particularly regarding build system servers. Consider for example that in JS npm is owned by Microsoft, whereas in Rust crates.io is owned by the Rust Foundation. I think the latter is better than the former. But I think the way Yatima's package management works over the decentralized IPFS network is better than either.