I have much more experience programming than I do with advanced mathematics, so perhaps this is just a comfort thing with me, but I often get frustrated when I try to follow mathematical notation. Specifically, I get frustrated trying to keep track of what each variable signifies.

As a programmer, this would be completely unacceptable no matter how many comments you added explaining it:

```
float A(float P, float r, float n, float t) {
return P * pow(1 + r / n, n * t);
}
```

Yet a mathematician would have no problem with this:

A=P (1+rn)ntA=P (1+rn)nt

where

AA = final amount

PP = principal amount (initial investment)

rr = annual nominal interest rate (as a decimal)

nn = number of times the interest is compounded per year

tt = number of years

So why don’t I ever see the following?

final_amount=principal(1+interest_rateperiods_per_yr)periods_per_yr⋅years

Its quite self explanatory if you read of how Cardan wrote polynomials:

Instead of

x4+6x2+36=60xx4+6×2+36=60x

He’d write

1q¯¯dq¯¯d.p:6q¯¯d.p:36 aequalia. 60pos.1q¯dq¯d.p:6q¯d.p:36 aequalia. 60pos.

or to write

x4+(2y+12)x2+y2+12y+36=(2y+6)x3+60x+y2+12yx4+(2y+12)x2+y2+12y+36=(2y+6)x3+60x+y2+12y

He’d put

1q¯¯dq¯¯d.p:2pos.p:12q¯¯d R p:1q¯¯d.p:1pos. additi numeri p:36 aequalia. 1q¯dq¯d.p:2pos.p:12q¯d R p:1q¯d.p:1pos. additi numeri p:36 aequalia.

2pos.6q¯¯dratoru¯¯¯,p:60pos.p:1q¯¯d.p:12pos. numeri additi

Actually, I think the reason why single letter identifiers are popular in math, and not so popular in programming is Intelisense. Today, every profesional developer would flinch if shown something like

`return P * pow(1 + r / n, n * t)`

, but we have been spoiled by the ease of use of automatic filling of long names.As I remember, 10-15 years ago it was more common to use single or double letter names for any local variable, because the developer would have to write each character himself, by hand. Right now, I just press a few keys, and the IDE does the rest.

BTW, the name of the function used in the example (

powfor Power) fits nicely with the explanation.Because the intellisense & autocompletion on my piece of paper is turned off. 🙂

(So is the context sensitive color highlighting.)

Holy cow, imagine a sheaf cohomology commutative diagram chase with camel casing and vaguely Java like method syntax for all operations. Or even just the chain rule:

derivative(firstSmoothFunction.composedWith(secondSmoothFunction)) = derivative(firstSmoothFunction).composedWith(secondSmoothFunction) * derivative(secondSmoothFunction)

In many cases the more concise notation may make it harder to remember what stands for what, but well chosen notation makes the relations between things much more apparent.

It’s a convention like any other; never underestimate the power of historical inertia! Different disciplines have different conventions.

I would also guess (and I have no evidence to support this) that a big reason it is currently still around is that typesetting equations was expensive and time-consuming before the rise of modern typesetting (e.g. TeX) and writers of textbooks were probably encouraged to keep their notation as concise as possible. This would explain the disparity between mathematicians and programmers since the latter, after all, have the benefit of a history of using computers.

When doing algebra by hand with pencil and paper, it’s a lot easier – and a lot faster – to work with something like

PV=nRT

instead of

(pressure)(volume) = (number of moles of gas) (gas constant) (temperature).

And this matters a

lotwhen you’re doing a timed exam.