Is it bad to use Unicode characters in variable names? [closed]

Question

I recently tried to implement a ranking algorithm, AllegSkill, to Python 3.

Here's what the maths looks like:

_{No, really.}

This is then what I wrote:

t = (µw-µl)/c  # those are used in
e = ε/c        # multiple places.
σw_new = (σw**2 * (1 - (σw**2)/(c**2)*Wwin(t, e)) + γ**2)**.5

I actually thought it is unfortunate of Python 3 to not accept √ or ² as variable names.

>>> √ = lambda x: x**.5
  File "<stdin>", line 1
    √ = lambda x: x**.5
      ^
SyntaxError: invalid character in identifier

Am I out of my mind? Should I have resorted for a ASCII only version? Why? Wouldn't an ASCII only version of the above be harder to validate for equivalence with the formulas?

_{Mind you, I understand some Unicode glyphs look very much like each other and some like ▄ (or is that ▗▖ ) or ╦ just can't make any sense in written code. However, this is hardly the case for Maths or arrow glyphs.}

---

Per request, the ASCII only version would be something along the lines of:

winner_sigma_new = ( winner_sigma ** 2 *
                    ( 1 -
                     ( winner_sigma ** 2 -
                       general_uncertainty ** 2
                     ) * Wwin(t,e)
                    ) + dynamics ** 2
                   )**.5

...per each step of the algorithm.

Answer 1

I feel that just replacing σ with s or sigma doesn’t make sense and is counter-productive.

What’s the potential gain of such a replacement?

• Does it improve readability? Nope, not in the slightest. If that were so, the original formula would have undoubtedly used Latin letters also.

• Does it improve writability? At first glance, yes. But not really: because this formula is never going to change (well, “never”). There will normally be no need to change the code, nor to extend it using these variables. So writability is really not an issue.

But programming languages have one advantage over conventional mathematical notation: you can use meaningful, expressive identifiers. In mathematics, this isn’t normally the case, so we resort to one-letter variables, occasionally making them Greek.

But Greek isn’t the problem. Non-descriptive, one-letter identifiers are.

So either keep the original notation … after all, if the programming language does support Unicode in identifiers, there’s no technical barrier. Or use meaningful identifiers. Don’t just replace Greek glyphs with Latin glyphs. Or Arabic ones, or Hindi ones.

Answer 2

Personally, I would hate to see code where I have to bring up the character map to type it again. Even though the unicode closely matches what's in the algorithm, it's really hurting readbility and ability to edit. Some editors might not even have a font that supports that character.

What about an alternative and just have up top //µ = u and write everything in ascii?

Answer 3

This argument assumes you have no problem with typing unicodes nor reading greek letters

Here's the argument: would you like pi or circular_ratio?

In this case, I'd prefer pi to circular_ratio because I've learned about pi since I was in grade school and I can expect the definition of pi is well ingrained to every programmers worth his salt. Therefore I wouldn't mind typing π to mean circular_ratio.

However, what about

winner_sigma_new = ( winner_sigma ** 2 *
                    ( 1 -
                     ( winner_sigma ** 2 -
                       general_uncertainty ** 2
                     ) * Wwin(t,e)
                    ) + dynamics ** 2
                   )**.5

or

σw_new = (σw**2 * (1 - (σw**2)/(c**2)*Wwin(t, e)) + γ**2)**.5

To me, both versions are equally opaque, just like pi or π is, except I didn't learn this formula in grade school. winner_sigma and Wwin means nothing to me, or to anyone else reading the code, and using neither σw doesn't make it any better.

So, using descriptive names, e.g. total_score, winning_ratio, etc would increase readability much better than using ascii names that merely pronounce greek letters. The problem isn't that I can't read greek letters, but I can't associate the characters (greek or not) with a "meaning" of the variable.

You certainly understood the problem yourself when you commented: You should have seen the paper. It's just eight pages.... The problem is if you base your variable naming on a paper, which chooses single-letter names for conciseness rather than readability (irrespective whether they're greek), then people would have to read the paper to be able to associate the letters with a "meaning"; this means you're putting an artificial barrier for people to be able to understand your code, and that's always a bad thing.

Even when you live in an ASCII-only world, both a * b / 2 and alpha * beta / 2 are an equally opaque rendering of height * base / 2, the triangle area formula. The unreadability of using single-letter variables grows exponentially as the formula grows in complexity, and the AllegSkill formula is certainly not a trivial formula.

Single letters variable is only acceptable as a simple loop counter, whether they are greek single-letters or ascii single-letter, I don't care; no other variables should consist solely of a single letter. I don't care if you use greek letters for your names, but when you do use them, make sure I can associate those names with a "meaning" without needing to read an arbitrary paper somewhere else.

When in grade school, I definitely wouldn't mind seeing mathematical expressions using symbols such as: +, -, ×, ÷, for basic arithmetics and √() would be a square-root function. After I graduated grade school, I wouldn't mind the addition of a shiny new symbols: ∫ for integration. Note the trend, these are all operators. Operators are much more heavily used than variable names, but they are less often reused for an entirely different meaning (in the case where mathematicians reuse operators, the new meaning often still holds some basic properties of the old meaning; this is not the case for when reusing variable names).

In conclusion, no, it's not bad to use Unicode characters for variable names; however, it's always bad to use single letter names for variable names, and being allowed to use Unicode names is not a license to use single letter variable names.

Answer 4

Do you understand the code? Does everyone else who needs to read it? If so, there's no problem.

Personally I'd be glad to see the back of ASCII-only source code.

Answer 5

Yes, you are out of your mind. I would personally reference the paper and formula number in a comment, and write everything in straight ASCII. Then, anyone interested would be able to correlate the code and the formula.

Answer 6

I would say using Unicode variable names is a bad idea for two reasons:

1. They're a PITA to type.

2. They often look almost the same as English letters. This is the same reason why I hate seeing Greek letters in math notation. Try telling rho apart from p. It's not easy.

Answer 7

In this one case, a complex maths formula, I'd say go for it.

I can say in 20 years I've never had to code something this complex and greek letters keeps it close to the original maths. If you can't understand it, you shouldn't be maintaining it.

Saying that, if I ever have to maintain µ and σ in bog standard code that you bequeathed me, I will find out where you live...

Answer 8

• Pro: it looks nice
• Con: the unicode characters and so the whole meaning might get lost in the tool chain (editor, code formatter, version control, older compiler)

How big is the risk for you? Does the gain outweigh the risk?

Answer 9

I posted the same kind of question on StackOverflow

I definitely think that it worth using unicode in heavy math-related problems, because it makes it possible to read the formula directly, which is impossible with plain ASCII.

Imagine a debugging session: of course you can always hand-write the formula the code is supposed to compute to see if its correct. But ninety percent of the time, you won't bother and the bug can stay hidden for a long, looong time. And no one is ever willing to look at this abstruse 7-line, plain ASCII formula. Of course, using unicode isn't as good as a tex-rendered formula, but it is way better.

The alternative of using long descriptive names is not viable because in math, if the identifier is not short, the formula will look even more complicated (why do you think people, around the XVIII century, began to replace "plus" by "+" and "minus" by "-" ?).

Personnally, I would also use some subscripts and superscripts (I just copy-paste them from this page). For instance: (had python allowed √ as an identifier)

√ = math.sqrt #function alias
c² = c**2
σʷ² = σʷ**2
γ² = γ**2
σ′ʷ = √(σʷ² * (1 - (σʷ²/c²)*Wʷⁱⁿ(t, e)) + γ²)

Where I used superscripts because there is no subscript equivalent in unicode. (Unfortunately, the unicode subscript character set is very limited. I hope that one day, subscripting in unicode will be considered as diacritics, i.e. a combination of one char for subscript, and another char for the subscripted letter)

One last thing, I think this conversation about using non-ASCII character is primarily biased, because many programmers never deal with "formula intensive mathematical notations". So they think that this question is not that important, because they never experienced a significant portion of code that would require the use of non-ASCII identifiers. If you are one of them (and I was until recently), consider this: suppose that the letter "a" is not part of ASCII. Then you will have a pretty good idea of the problem of having none of greek letters, subscripts, superscripts when computing non-trivial math formulas.

Answer 10

Sometime in the not too distant future, we'll all be using text editors / IDEs / web browsers that make it easy to write edit text including Classical Greek characters, etc. (Or maybe we'll all have learned to use this "hidden" functionality in the tools we currently use ...)

But until that happens, non ASCII characters in program source code would be hard for many programmers to handle, and are therefore a bad idea if you are writing applications that might need to be maintained by someone else.

(Incidentally the reason you can have Greek characters but not square root signs in Python identifiers is simple. The Greek characters are classified as Unicode Letters, but the square root sign is a non-letter; see http://www.python.org/dev/peps/pep-3131/ )

Answer 11

You didn't say what language/compiler you are using, but usually the rule for variable names is that they must start with an alphabetic character or underscore, and contain only alphanumerics and underscores. A Unicode √ would not be considered alphanumeric, since it is a mathematical symbol instead of a letter. However σ might be (since it is in the Greek alphabet) and á would probably be considered alphanumeric.

Answer 12

personally I am motivated to consider programming languages as a tool for mathematicians in this context, as I don't actually use math that looks anything like that in my life. :D And sure, why not use ɛ or σ or whatever — in that context, it is actually more legible.

(Although, I have to say, my preference would be to support superscript numbers as direct method calls, not variable names. eg 2² = 2 ** 2 = 4, etc.)

Answer 13

Is this code just for your personal project? If so, go nuts, use whatever you want.

Is this code meant for others to use? i.e., and open source app of some sort? If so, you're likely just asking for trouble because different programmers use different editors, and you cant be certain all editors will support unicode correctly. Plus not all command shells will show it correctly when the source code file is type'd/cat'd, and you may run into issues if you need to display it within html.

Answer 14

What the hell is σ, what is W, what is ε, c and what is γ?
You are to name your variables in a way that explains what their purpose is.
I'd personally beat up anyone who'd leave the Unicode or the ASCII-version for me to maintain, although the ASCII-version is better.

What is evil is calling variables σ or s or sigma or value or var1, because this doesn't convey any information.

Assuming you write your code in English (as I believe you should wherever you are from), ASCII should suffice to give your variables meaningful names, so there is no actual need for Unicode.

Answer 15

For variable names with well-known mathematical origins this is absolutely acceptable - even preferred. But if you ever expect to distribute the code, you should place these values in a module, class, etc. so that IDE auto-complete can handle "typing" the strange characters.

Using √ or ² in an identifier - not so much.