cubicaltt VS Formality

- cubicialtt a programming language based on cubical type theory in which univalence from homotopy type theory isn't an axiom but a theorem

If you’re interested in programming languages specifically, the current state of the art is called Cubical Type Theory. CuTT has lots of flavours and the community hasn’t coalesced around a single design. The paper I personally found easiest to digest was the “ABCFHL” paper, but I’d recommend reading it alongside the original CCHM paper. None of the publications made an ounce of sense to me until after I’d digested Favonia’s YouTube channel, Mortberg’s lecture notes and this other series of lectures from Harper (particularly the final one).

I updated the blog post to include some people in academia who contributed. I've been interacting with Kent Palmer and Sylvester James Gates, Jr. The latter held lectures about the philosophy of mathematics. I've been using work inspired by Vladimir Voevodsky, e.g. cubicaltt (https://github.com/mortberg/cubicaltt), which is also performed by academics.

Also, my current work is using Kind as a foundation, the purpose of this language is exactly what you have asked for, give a check on https://github.com/uwu-tech/Kind.

Kind has a "how I learned to stop worrying and love the `Type:Type`" vibe. That doesn't make it invalid as a proof language. It just inverts the priority: instead of consistency being the default and expressivity being opt-in (as in Agda, with the `type-in-type` pragma), it is expressive by default, and consistency is an opt-in. I strongly believe that is the right way. We plan to add opt-in termination (thus consistency) checkers, it is just not an immediate priority, but the language is completely ready for that. About `Type in Type` specifically, keep in mind that there are consistent, interesting type theories that feature `Type in Type`. So it isn't problematic in itself, and removing it seems wrong.

About erasure, you can flag an argument as computationally irrelevant by writing `` instead of `(x: A)`. So, for example, in the [Vector/concat.kind](https://github.com/uwu-tech/Kind/blob/master/base/Vector/con...) file, `A`, `n` and `m` are erased. As such, the length of the vector doesn't affect the runtime. As a good practice, you may also write `f` instead of `f(x)` syntax for erased arguments, but that is optional.

> TL;DR -- I think the language looks nice, and the compile to JS (from what I read of the Formcore source) looks to be well done. Also, the docs that are present are well presented in a non-academic way that I find pretty readable.

Thanks for the kind words. We put a lot of effort on the compilers and, while there is still a lot to improve, I'm confident they're ahead of all the other languages, by far.

Kind is a functional, general-purpose programming language featuring theorems and proofs. It has the smallest core, a pretty solid JavaScript and Scheme compiler (seriously, check how clean is the generated kind.js), and a syntax that is a middle ground between Haskell and TypeScript, in an attempt to make it more accessible.

I'm writing CONTRIBUTE.md right now.