Ask HN: Why is math so obsessed with ancient syntax and frameworks?

Math (well, math to undergraduate college level) doesn't. To even have a chance of understanding a concept in math, you are forced to use an Ancient Greek symbol system. Once your done with that, the formulas are written in a very specific forum and very specific pattern that your forced to learn in order to understand it at a higher level.

In a way, it's like learning the concepts of object oriented java by only having access to assembly language syntax. Yes, it's possible to learn it that way but there are better ways to understand it.

Why is math so obsessed with ancient syntax and conceptual frameworks? Why isn't there a Python for math? Why isn't there new conceptual frameworks for math being used out there being created? Why does math feel so obsolete? Is the methods used for math today really the best way to present math to modern day people?

using single letter variables is for convenience and done in another script to avoid confusion with the text and sometimes varies to encode information (real value vs vector vs matrix).

There's plenty of work to be done making math better but I don't think you'll get away from these conventions any time soon.

People who enjoy the current state of mathematics will probably think the OP is trolling, but it's a reasonable question.

Perhaps it could be better put as 'Why doesn't maths concern itself with readability like programming does?'

Greek leters: It's a feature not a bug! The advantage of Greek letters is that they don't collide with normal variables, you can use short (1 letter) names for symbols. That is also the advantage of using special characters for number (and not using something like a->1, b->2, ...).

An additional problem is that some letter has an expected behavior, for example \epsilon usually is small, and M (capital M) usually is a big number, p is a prime number and z is usually a complex number. The problem is not that they are Greek letters, the problem is that you have to learn the expected behavior. (It's like using i for a counter in a for loop. Obviously i is integer.)

The problem with the syntax is that mathematicians (and humans in general) are too good parsing DSL (domain specific languages). So each mathematical branch has its own DSL (we call it "notation"), and the DSL can barely be combined, but usually a calculation doesn't combine many areas of mathematics. (For example there is a special notation for "function integrals" and "modulo congruence" and "fields towers", but I hope I should never combine the three in the same calculation.) (A similar problem is why regular expressions are so popular, they can be implemented with normal constructions, but sometimes it's easier to use regular expressions. Or the special syntax for here strings.)

The problem is that you have to learn all the DSL, but usually the specific details of the DSL have some insight of the main ideas of the area. There is an (perhaps apocryphal) quote from Gauss: "A good notation is half of the solution.".

The problem is not that you must use Assembler to write Java classes. The problem is that you must use 50 almost incompatible Lisp packages, that define its own macros and syntax reader (that hides almost all the parenthesis) and define each one a very useful but limited DSL that compiles to the JVM.

It's very difficult to jump into a new mathematical structure, because very often you have to learn the lexicon from scratch.