This is very arrogant and wrong. The exact opposite is true. Mathematicians have worked hundreds of years and streamlined notations that can express complect things well.
Mathematical and sheet music are both organically grown. They're like C++ for math and music, but with about fifty times more cruft. Our forebears just kept adding on to and expanding purely crap syntax because getting people to change the existing way they do things is nigh impossible. Going on to hail this as "refined" is beyond me.
EDIT: Sometimes, in maths, different disciplines have conflicting syntax. Rather than fixing this, we just resorted to overloading (see i vs. i in maths and physics). If any programmer encountered that kind of thing in a computer language they would describe it as clearly evil.
EDIT: For a funny take on musical notes, see: https://youtu.be/-3WuQxnA7Hg
Mathematicians aren't dumb. There's some element of tradition (that's a small part of the reason why many mathematicians prefer chalkboards to whiteboards) but most of the reason we use the notation we use is because it's the best way anyone has ever found to express rigorous, technical, creative, abstract thought cleanly and efficiently. Mathematicians routinely do completely /new/ work which requires us to invent entirely new notation out of wholecloth on the spot. The techniques we use are suited to this need. When we find something that's better, we use it. There isn't anything better yet.
It's easy to design a better toy system. It's very, very hard to design a non-toy system that encapsulates all of the information in a full orchestral score and makes it readable for players of all instruments.
Just as finding a complete and consistent set of axioms for all mathematics is impossible, a universal syntax without namespaces sounds inefficient.
Math is even worse. It's syntax piled on top of syntax. It's actually evil.
Surely you're not talking about modern tuning standards.
Given the expression:
{f ∈ [1..N ⟶ 1..N] : ∀ y ∈ 1..N : ∃ x ∈ 1..N : f[x]=y}
I can instantly read it in my head as:
The set of all f where f is a function mapping 1..N to 1..N such that for all Y in 1..N there exists an X in 1..N such that f[x] = y.
One might argue that the ability to express such a long definition in such a compact form is a benefit, but I don't think so. In this particular case the definition is so trivial that it's easy to understand what is being talked about. Anything more complicated than this quickly becomes tedious and boring. I would prefer that mathematicians simply used longer, more verbose, but more clear and explanatory names for quantities and concepts. Just my opinion, though.
My math profs emphasized juggling multiple layers of logical abstraction and omitting all unneeded explanations, while the CS guys wanted everything in excruciating detail and extremely formal language.
My current course is Programming Language Semantics. It's all relations, functions, states, predicates, induction, etc. Greek letters are used all over the place. The topic is interesting and I love implementing semantics in Prolog, but the mathematical notation is painful.
Totally! That's why Perl has taken over the field of software engineering, vanquishing all who came before it.
And for the handful of people who find Perl hard to read and understand: choose another career because brevity and standard notation are critical for understanding, and Perl has that in more abundance than any other language. The problem, as it were, is you.
As a perl cum python developer, no. It's that I had to spend time reverse engineering the code I wrote last week, because of the hundreds of obscure symbols I cleverly used to reduce thirty lines of clear code to five lines of compact code.
Python and Ruby both have to deal with references (though much more indirectly via the concept of mutable objects), as well as arguments coming in as parameter lists (and dicts).
And by references I meant exactly that perl is not pass by reference, unlike just about any other scripting language. R is the only other popular one I can think of that's not. There's shell too but it doesn't count.
"Because I could"
More specifically, in very short programs, the shortcut values were actually valuable, and the mental overhead for interpreting them in short subroutines or programs was minimal. The problem is that programs don't stay static, and that single time-saving shortcut becomes two, then four, then eight, then...
Soon, it's an absolute mess.
Even once I realized the cost, I had to follow the coding conventions of those who had come before, at the cost of increasing the cognitive overhead even further. A self-reinforcing loop.
> not pass by reference, unlike just about any other scripting language
As Smaug says, Python is pass by value. The trick is that the value is always a reference to an object, or more specifically “pass-by-object-reference” (“Object references are passed by value.").
This causes a few subtle behavioral inconsistencies, such as the dreaded `def a(b=[]):` bug.
One of the uses of the notation is to serve as a map for a more long-winded description, as you can lose your place in verbose explanations when they begin to get complicated.
More importantly, perhaps, is their use when you are applying formal manipulations to them. I think author's point is that many computer scientists apparently lack the background to follow or evaluate some of the important current developments in their field.
You can look at each permutation as a (unique, one-to-one and onto) function from the set [1,2,3,...N] to positions labeled also [1,2,3,...N]. For it to be a permutation, each position needs to contain a single value, and each value needs to be at one single location. Since the domain and range of the function have the same (finite) number of elements, either of these properties implies the other.
Given that each f is a function, mapping each member of its domain to one member of its range, and that for each member of the range, there is a member of the domain that the given function maps to it, and that the domain and range are the same size, then there can be no member of the domain not mapped to some member of the range, and each member of the domain must be mapped to a distinct member of the range (or else there would not be enough members of the domain to cover all the members of the range), so, with the domain and range being the same set, each of the given functions is a permutation of the domain, and collectively they must be all of them.
This is a verbose version of the argument for this being the set the author says it is. Arguably, it would be easier to read if I had used x for 'member of the domain', y for 'member of the range' and f for 'the given function'.
There are so many ways to write the same idea in less symbols.
It can be written with fewer symbols: `f: [N]->[N] s.t. x != y => f(x) != f(y)` is an equivalent formulation, for instance (since f from a finite set to itself is surjective iff it is bijective iff it is injective). The quantification is now implicit in the "implies" symbol. Not sure how standard `[n]` is to refer to {1,2,…,n}; it was used commonly in my undergrad courses.
Programmers have moved away from single letter variable names to make things understandable, but mathematics, even in CS has not.
I think many CS students have problem with mathematical notation because it can be both accurate and syntactically very sloppy and informal at the same time. It's human language and notation, it's not for computers.
Your comment is needlessly rude and you don't give any evidence to support your contention.
If his argument is offended, I apologize. I don't think it's possible.