Math notation sucks because none of it maps to things non-mathematicians know.

I'm struggling to see how someone could conclude the latter statement from the former. Why is it reasonable for Vietnamese to be unintelligible to non-Vietnamese speakers, yet unreasonable for mathematics to be unintelligible to non-mathematicians?

This doesn't mean maths notation sucks any more than vim's user interface sucks because it doesn't make sense to non-vim-users.

Mathematical notation presumably mostly makes perfect sense to the kind of people who deal with mathematical notation all day long.

Vim, like math notation, is optimized for efficiency. That's great for power users, but it's not what you would use if you wanted to teach someone how to word process.

(BTW, try imaging Vim where each file mandates its own special keybindings. That's math notation for ya.)

Vim is a text editor, not a word processor. Additionally, Vim is a tool designed for power users. Mathematical notation is also meant for power users. When we teach mathematics, we introduce the notation gradually, so students have time to pick it up. This is a process which takes decades from Kindergarten through PhD. Just as a Vim user would scoff at being forced to write in Notepad, a mathematics PhD would scoff at being forced to express their ideas in Kindergarten-level mathematical notation.

try imaging Vim where each file mandates its own special keybindings. That's math notation for ya.

That's how Emacs works, and how Vim works when you install filetype-specific plugins.

I have too many things to remember, and there are plenty of options that give me equal power but don't demand that investment from me.

Math isn't like that - I do more math than the average person and I hate having to decipher the annotation. The number of times I've tried to work out if this sigma is the same as the sigma in this other paper frustrates me enormously.

Or the paper that used a accuracy^bar metric as their primary reporting metric, and we couldn't get near it until we found an obscure footnote in an appendix that explained the ^bar metrics were temporally averaged at test time around a known labelled standard (ie, test data was used to optimise the performance).

It seems like your complaints are with academic papers, not with mathematical notation specifically. This is a problem that is universal to academic papers. Try reading a critical theory paper, for example, and you'll find it's extremely dense with critical theory jargon the authors don't bother explaining at all.

The problem with academic papers is that they aren't intended for a general audience. The authors of papers are often operating in subfields that are so small that they've actually met most of the other people who will be reading their papers. In that situation, conventions and jargon arise naturally among colleagues. Variable names form a part of these conventions such that, in a more common example, sigma will mean standard deviation among statisticians but mean singular value among linear algebraists.

The other problem with academic papers is that the authors generally don't care about reproducibility, consistency, clarity, pedagogy, or even intelligibility. They're optimizing for quantity of papers published, not quality. As long as their expert peer reviewers understand and give the green light for publication, that's good enough.

It's really about the lazy habits of many who work at the intersection of math and computer science, and use maths to express themselves without defining things.

> The other problem with academic papers is that the authors generally don't care about reproducibility, consistency, clarity, pedagogy, or even intelligibility. They're optimizing for quantity of papers published, not quality. As long as their expert peer reviewers understand and give the green light for publication, that's good enough.

Having worked around this field, I think this (common) perception of publishing doesn't quite capture what is happening. Peer review isn't anything like code review, and software engineers (separate from computer scientists and mathematicians) think that it is.

A lot of mathematics is optimised for pencil efficiency for a reason, and it's not at odds with learning mathematics.

That is like trying to learn an instrument by looking at it but never touching it. Notation like other tools is made to useful. Also if you never played an instrument you would think they are each their own little completely different world. That's totally wrong for ya.

I think this nails it perfectly. There are plenty of good programmers who refuse to use vim. In math those people can't operate.

Maybe the overuse of opaque names leads to self-selection of who becomes a mathematician?

Single-letter non-descriptive variable and functions names would “make sense” to programmers who use it all day long too — but that alone doesn’t make it a good idea.

We're trying to derive that a^x = b^(x * log_b(a)).

Or in verbose descriptive terms, oldBase `exponentiate` oldExponent = newBase `exponentiate` ( oldExponent `multiply` inverseExponentiationInNewBase (oldBase) ).

We could maybe argue about the verbosity and clarity of each statement, but I think math's notation shines when you compare derivations instead of statements:

      a^x
    = b^( log_b(a^x)       )
    = b^(    ln(a^x)/ln(b) )
    = b^(  x * ln(a)/ln(b) )
    = b^(  x * log_b(a)    )

      oldBase `exponentiate` oldExponent
    = newBase `exponentiate` ( inverseExponentiationInNewBase(oldBase `exponentiate` oldExponent)                                                )
    = newBase `exponentiate` (   inverseNaturalExponentiation(oldBase `exponentiate` oldExponent) `divide` inverseNaturalExponentiation(newBase) )
    = newBase `exponentiate` ( oldExponent  `multiply`  inverseNaturalExponentiation   (oldBase)  `divide` inverseNaturalExponentiation(newBase) )
    = newBase `exponentiate` ( oldExponent  `multiply`  inverseExponentiationInNewBase (oldBase)                                                 )

This is a ridiculous over the top example, since I'm avoiding using everyday symbols like * and / and ^ and log, but for working mathematicians and applied mathematicians, their notation is just as familiar to them and I'm sure it'd be equally annoying to write out descriptively as it is for us to write out basic math symbols descriptively.

Programming notations are to be written and read. Math notation is to be manipulated.

But there are alternative ways of describing that derivation that are not as symbol-manipulation heavy; you would certainly not communicate this proof in words to another mathematician — or to a non-mathematician — by simply reading your derivation (or your alternate, verbose derivation) symbol by symbol. Instead you would more likely rely on the meanings of the symbols.

Even in your verbose derivation, however, it’s worth noting that your new names capture the fact that b^x and log_b(x) are inverses, a key piece that someone unfamiliar with logarithms and their relationship to exponentiation now has a hope to understand.

Because it is better communicated in notation than in words.

Also, no better notation could help you understand most modern mathematics. There's no better choice of symbols or names that will help you understand Galois theory. You simply need to understand high-school algebra, then group theory, then Galois theory.

This probably isn't completely true—as will be clear to anyone, even a subject expert, who tries to go back and read the original papers. At least part of this is due to fads in notation—in my field, I can easily read the papers of people who do similar work to mine, and struggle with the papers of those who don't, even when they're talking about exactly the same thing—but some of it must be due to genuine improvement.

Being able to recognize things like "oh, that's a polynomial!" is extremely useful, especially in the context of learning new math rather than a more applied context. And I think it would be extremely hard to spot an opportunity to do integration by parts when working with Java-style verbose variable names.

Imagine you would write the code on paper by hand and have to repeat some long var or function name all the time . Even with IDEs I see programming languages using shorter keywords like "var","const","int" then the full word.

Because you are agains single letter symbols let me know what are your suggestions for PI, or X(in polynomials or equations) and show me a screenshot on how some real world physics equation solving would look like with camel case named symbols.

Sure, you could write

-CoefficientInFrontOfXToTheOne/2

But then each row of your calculation will need line breaks and will be hard to understand. It will take forever to write and it will take forever to read. No thank you.

Now, formalising that above sentence even with symbols is quite difficult.

Programming language syntax sucks because none of it maps to things that non-programmers know. Every time a new token is introduced, whether it be an ascii symbol or a word it's one more mapping your brain has to create to remember it. And on top of this you have to remember how these actually execute too. Yes I said execute - most programming concepts have so many implementations it's crazy. Even basic conditionals can't escape this. There are several tokens for if-statements (if, guard, case, (^:), etc.) and countless common implentations (gcc, ghc, guile, J, and whatever actual processors end up doing).

Deep, complex things are hard, my friend. The pain is real; the payoff is totally worth it though.

I think a good example is: https://xkcd.com/936/

"Correct Horse Battery Staple" is easier to remember than "Tl)7x" because the latter maps into plumbing we already have. Likewise, print "Hello world" is easier to remember than printf("Hello World"), which is easier to remember than std::cout << "Hello world"; This is why we recommend beginners start with a language like Python or BASIC and not C++.

Also, my point wasn't about ideas, but rather the notation used to represent these ideas. For example, you might not be able to read "Ăn quả nhớ kẻ trồng cây", but if I tell you it means "When eating a fruit, think of the person who planted the tree" you understand the idea. Notation is just a means of transferring ideas. Having deep complex ideas is not an excuse for poor notation.

I dropped out again and haven't looked back. That system wasn't for me and didn't care about my success or its ability to transfer knowledge.

Mathematics is a deep subject. It requires many hours of study over decades to develop. Students who are struggling deserve to have a patient teacher explain things to them in terms they already understand. Not every student has this experience, however. I have tutored a number of my peers in undergrad and they have complained of similar treatment from professors or TAs. I do my best to help them and make sure they really understand the topics they're studying.

Funny enough, that grad student was almost certainly making less than that. Universities are screwed up.

As a novice programmer, it took years to get out of the habit of using non-descriptive single-letter variable and function names. It’s a terrible habit, and makes code incomprehensible — and programmers know it.

Math, as taught to kids, is full of single-letter variable names (or worse, as you point out, using non-Roman letters and other symbols) that are devoid of any hints to the uninitiated of what their meaning might be.

I wonder what it would be like if math were taught with descriptive names — starting with the basics, for functions and variables, and used those names consistently.

Would it be more verbose? Absolutely — but I’m pretty sure it would also be a huge kindness to learners.

Note that if you programmed in FP languages, you'd have to unlearn the "descriptive variable names" thing you were taught. Once you deal with abstractions, names cease to be meaningful. If the most you can say about a parameter to a higher order function is that it is "a function", then "f" is the best name for it. Some very good programmers argue that long/descriptive names often obscure the shape of an abstraction.

Of course. But even in FP languages you don’t name all your functions “f”! At some level of abstraction, sure, you use “i” for index variables, etc., but once you back out of that low level, you are going to be naming things that are less abstract.

If they did, it would be a lot easier to talk about trains speeding through the night!

A person can wonder if it would be better to start with understanding. (Personally, I only briefly taught that age but my oracle for how to teach it, Mr Barton, does say that experience shows you have to have down the class's ability to mechanically solve before you introduce the trains. The other order, apparently, doesn't work when you try it with actual students in practice.)

Any time a new symbol is used in a text, it will typically be introduced. The phrase "Let A be the subgraph composed of G" for example defines A in relation to G. Typically, the author will also define their notation at the start of a paper with: "A graph G is defined as the set of edges E and vertices V such that...". To be frank, I always see math papers and communications written in this style.

More often than not, I think folks just say "SINGLE VARIABLE NAMES BAD. MATH HAVE SINGLE VARIABLE NAMES". It's really dense. In any given math paper, the author typically defines any such variables. And if those definitions don't make sense, it's because the underlying mathematical objects are beyond you, and you need further background.

Yes, that’s my point.

Imagine learning a foreign language by being given a dictionary and a set of grammar rules. Is that enough to learn the language? Not really. You’d be missing idioms, patterns of speech, common phrases & compositions - the same is true in math.

If you already halfway understand the language, then yes, you can do with a reference / definitions and rules for application — but even then, understanding how to use them is not trivial.

Also, you are talking about “texts”, but there are plenty of domains in which conference and journal papers assume a certain set of notation, and that notation is not defined, nor even consistent; you need to be well-read in the field to even have a hope of understanding what’s going on. AI/robotics comes to mind, but ML in general is sometimes guilty of this.