@kspalaiologos

> Why does Japanese use weird glyphs to encode their language? Why can't they use the Latin alphabet and settle on writing everything with Romaji all the time to convenience me, a stranger?

I think it would convenience their own population as well in the long term. Children would become literate quicker, and have an easier time learning English. For such a developed country, their English seems really bad on a population level.

The Turks did it about 100 years ago. Ditched the Arabic script, and adopted a custom Latin alphabet suitable for Turkish, similar to romaji. The Philippines did it way earlier due to Spanish colonization, ditching Baybayin in favor of the Latin script, which works fine for Tagalog, Cebuano, and presumably most if not all their other languages. Baybayin is being revived by some historians etc. but in general people don't care because the Latin script works just fine.

> Asian languages have some benefits: e.g. thanks to the fact that Cantonese (a language also encoded with an inscrutable unreadable alphabet) has single-syllable digits, native Cantonese speakers on average remember phone numbers better and have an expanded working memory.

Seems like speculation, so I would question whether it's worth the immense complexity of Hanzi, but I know very little about Chinese so ok.

> I will give this question benefit of doubt and assume that it's genuine: the reason is mnemotechniques (APL glyphs make sense for what they do and have clear patterns) and context confusion. E.g. to me, & is exclusively address-of or bit-and. If a language used it in some other context, I would be confused and I would never recover. Which is why if you settle on terse syntax custom operators are our only option.

Well, using words would solve that. Address-of, bit-and, etc.

> Why not words? Out of convenience: scanning and parsing the word requires more intellectual effort to parse and register than pattern-matching a glyph and when used often enough, verbose names become a nuance. You can ask this question to e.g. Haskell designers, who thought that `foldl1` is a good function name - why not use the `fold_left` convention like OCaml does? Without closer inspection, it appears more readable.

I'm very skpetical of this. Words being made up of indvidiual lettres is mailny a leraning aide. Once you've masterd a word, your brain prety much scans it as one token, which is why tpyos often beocme insivible.

(I might have overdone it with the intentional typos in the previous paragraph, but you get the point lol.)

> And finally: APL was developed as a mathematical notation. Mathematics do not use words, but they could. Instead of F = ma, we could say that force is equal to the mass multiplied by acceleration - imagine how difficult would it be to derive Telegrapher's equations with such an inefficient thought model.

I think the mental model is the same whether you write F = ma or "force = mass × accel."

I think the tradition of single-letter variables probably just stems from 1. maths having evolved from people writing manually on paper and blackboards, and 2. formulae most often being very short, without all that many different variables, compared to lengthy algorithms spanning many function definitions.

It's similar for operators, though it's useful to visually distinguish them from variables I suppose. (Writing "force = mass × accel" makes it much easier to parse than "force equals mass times accel.") You can do that while still using words though, like foo(bar) making it clear that foo is the operator thanks to the ().

In my experience, verbose variable and operator names are no hindrance to writing complex and readable code. I love Scheme (a very maths-adjacent language as well) and it has a tradition of verbosity, with operator names such as:

- call-with-current-continuation
- with-exception-handler
- define-syntax
- fold-left / fold-right
- vector-ref
- let-values

And so on.

(Call-with-current-continuation is a bit of a pathological case though, and is usually shortened to call/cc after all.)

Fun fact: I couldn't grasp how delimited continuations work in Scheme until I've read the relevant section of the GNU Guile user manual, which explains it in terms of the more verbose primitives call-with-prompt and abort-to-prompt.