Hacker News Reader

Comment by vslira | Hacker News Reader

I just wish the Julia community wasn't so invested in using UTF8 symbols in the code. I understand that for Physicists, Engineers, Mathematicians, etc it look cleaner and more familiar, but when writing code that is meant to be maintained and read over and over agains it makes a difference if that µ looks too much like a u sometimes. What's so bad about just writing mu?

Anyway, this is not a complaint about the language (which I like very much), just a dislike of the popular usage

View on HN

The right name for a variable is related to what you think the way people will check it will be. In most code the attestation to the correctness of the code is the programmer's understanding of the code. Clearly then names should be descriptive. In contrast, when the attestation to the correctness of a formula is that it is the same as a formula printed in a published paper, then it should look as much like the formula in the paper as possible. A programmer who does not know that rho means density will not be able to catch scientific misconceptions by virtue of the fact that they see the word "density." On the other hand, the will be able to catch differences between the symbols in the source material and the source code.

In any code you write, you should be asking, "how will people check this?" If the answer is "by comparing it to something else," then it should resemble the original as much as possible. If the answer is "by thinking about it," then it should be formatted for self-contained comprehensibility. The distinct use cases lead to different best practices.

I wish non-Julia community would adopt this practice, because unicode symbols exist for a reason, and using proper symbols instead of making look every language like Perl with unix-style abbreviations that look bogus to pretty much everyone but the most seasoned C-programmers. And complaining u and μ are too similar is like complaining 1 and l or 0 and O are similar. I mean, yes, they are, unfortunately, but if you are noticing it's a real problem for you when writing code, you should probably check out better fonts for your text editor.

For the record, I'm not a blackboard addict, I never had a career in academia and I'm not even really a member of Julia community any more than any other person who wrote maybe a couple thousands of LoC in Julia. But I wish people would realize it's not 1970's anymore, and ASCII is culturally outdated. For that matter, I would love if I could write formulas in my code the same way I do on paper, like in that MathJax sample from the article. That's why math notation exists at all, imperfect as it may be (and I hate many things about established math notation, but it's the best we have). I just don't see how it's possible without abandoning plain-text, which I surely wouldn't like because we (currently) don't have tools that would make handling it as effortless, as editing text in Vim.

For that to happens common keyboards need to include these esoteric symbols. Yes, esoteric. Who's in the market for a keyboard with Greek alts? Or do you prefer a space cadet keyboard? What if you already have a US-Arabic keyboard which is fairly common?

The fact is it's easier to type "mu" instead of "u" (like right now, I can't be bothered to look up "mu unicode", or open the special characters picker, or exhaustively brute force alt-gr key combos to find the mu).

Take it a step further, I wish physicists and mathematicians would stop naming their variables so poorly so that only the most seasoned of their field can follow along.

Sometimes, like v (velocity) it's quite obvious, at other times I find myself staring at scripts with insane variables like a,o,t_o, etc. And this is a habbit that seems to carry over to non-academic code as well. It's trivial to spot code written by a mathematician because it tends to be incredibly obfuscated.

Do you really need to name your constants K_(single letter)? Or can you just write "AIRDENSITY" once and let your editor autocomplete it in the future?

The reason I complain about these symbols is because they don't have clearly defined meaning. Maths/Physics had to pull out the Greek alphabet after it exhausted the Latin alphabet (and overloaded most letters with 2 or more meanings) and then promptly molested the Greek one in the same way. Just look at Omega. It's useless. It has been overloaded with so many possible meanings that it has none. Stop naming your variables "omega". Unlike Maths, programming languages support variable names of more than 1 character long.

Long variable names make mathematically oriented code unreadable. A short half-liner becomes a multi-line monstrosity. What you need to understand is that in mathematical code, the variables themselves are of secondary importance, while the structure of the expression is primary. With long names, you cannot see what's going on.

Julia allows you to input Unicode characters via latex names though. I think that's a sweet spot of ease of typing and expressivity of characters.

Honestly I really hate seeing mu_a, delta_k and company all over the place. If we are gonna name our variables like this might as well give us the actual characters

> making look every language like Perl with unix-style abbreviations

your criticism of Perl is unfair. Base perl has supported unicode variable names since more than 20 years ago, way before all the other languages that you speak about.

Physicists, mathematicians, and engineers have been writing µ and u on chalkboards for years with no issues. Why should it be harder on a screen?

It's not the screen so much as the keyboard that is the problem

They’re very easy to type in Julia’s repl, or any text editor with Julia support.

You just type \mu and then hit the tab button and you get μ. I actually switch over to my Julia REPL all the time when I’m emailing someone and want to type a greek character.

> with Julia support.

So you can see how this becomes a bit of a barrier to entry.

I'm not sure I'd want to do any serious coding in an editor that doesn't have the most basic support for the language I'm using, but to each their own I guess.

For new users, if they're not used to writing unicode characters and don't have an editor with nice support, then they don't have to write them.

The julia community has a pretty strong convention of giving both unicode and ascii versions of almost all functions. Some packages don't have this convention, but I'm not aware of any big important ones that don't follow it.

Anyone that doesn't use a language aware editor is making themselves a disservice.

that's not really acceptable. I'm a big julia fanboy, have been since 0.4 (proof in bio) but dismissing real pain felt by newcomers is kind of bad for the ecosystem.

What editor do you use, if I may ask, and have you asked them to add unicode support? Part of the goal in permitting unicode variable names is that more and more niche editors might be forced to become fluent in languages other than english, benefits everyone (and might be a bit overdue at this point).

I use vim, and have a completions plugin (part of julia-vim mode), so that I can write \mu<tab> for any unicode name, which makes it as easy to type as "mu", but easier for me to read (as it matches my textbook expectation of the formula).

It's not a display issue. Do I want to type ctrl-u <whatever hex> or copy-paste if I want to write some code that calls a function when I'm playing around with a new library? Well those are the two strategies I've used with experience... But some person coming new to Julia will grab some package, and then see some function call and get deer in the headlights "how the hell do i do this".

And LaTeX codes are not always obvious. For example it's \triangleleft but \leftarrow

that's two extra strokes than just "mu"

Code is read more often than it's written, even scientific computing code.

agree, that doesn't make it not a problem.

It is a non-issue when you can use just use autocompletion for mathematical symbols on almost all Julia-supported editors

If Emacs doesn't have enough input methods, you can add one reasonably easily... A good deal of early-ish work on multilingual support in Emacs was done out of interest in editing technical text, which is basically the same problem as more-or-less complex natural language scripts (which deserve support anyway, of course).

How exactly do you type mu? On a chalkboard writing the mu sign is trivial, on a computer... well I don't have a mu button.

Edit:

There are like 5 replies to this mentioning different ways of doing it (including memorizing 3 digit unicode values) none of which seem more intuitive than writing "mu".

For me: alt+enter (switches to Greek keyboard layout), m, alt+enter (back to usual layout). I use Greek symbols in Python and in Javascript. I do it almost without thinking now, as lots of my coding is tightly linked to maths.

you can map a useless key like capslock to do that in a single step. Thus to type μ, for example, you simply press CAPS+m, and similarly for all greek letters

What is a capslock key, I only have ctrl and hyper ;)

man, it's the only key that has an assigned light in my keyboard! Funnily, the capslock light in my laptop seems to be detached to the configuration of that key, so that the light shows the parity of the total number of greek characters that I have typed.

You probably have what is called a GUI key, hyper died out with the space cadet keyboard. Caps lock is above the left shift.

I type <Greek>-m. One extra keypress, just like when I type é, ü, č, ç, π, etc. If you type in more than one language, or math, your keyboard is already set up to handle this.

in Julia:

\mu<tab>

Vim/Neovim makes it very easy to input all kinds of interesting Unicode, using the "digraph" system. A lot of other code editors have similar functionality, either through keystrokes or some kind of "palette" interface. And Julia REPL itself has Tex-like escape sequences.

I agree that we need better system-wide tools for arbitrary Unicode input. Font support and confusable glyphs are also issues. But I think these are solvable problems, and they will be good problems to have solved.

On Windows you can use Autohotkey and map it to "Right Windows Key" + u. Or use "Right Alt Key"+ "Numpad 230" ALT Code, https://usefulshortcuts.com/alt-codes/greek-alt-codes.php)

I use on Linux the XCompose key (which is assigned the menu key right from the space bar, or the "Print Screen" key), and then "\mu" like in LaTeX. I don't need to think about it because I have used LaTeX for years. I also use the XCompose to generate € and ß which are special symbols in my native language. This has the advantage that I can use the UK International layout for everything, which makes specifically writing code much more comfortable. Also, the xcompose keymap is just a text file in my home directory, I can extend it at any time and take it with me. The method is also independent from any application.

Also, Emacs has an input method which supports "\mu", and this convention is also used in Racket for things like λ.

> none of which seem more intuitive than writing "mu"

Write for the convenience of the reader, not of the writer!

I just do \mu (or ;mu) in Emacs.

We're in the 21st century, all the tools we use should have reasonable Unicode support. The fact that we collectively keep on talking about typing non-ASCII characters as a real problem is a pretty depressing reflection of our shared computer infrastructure :(.

In the Julia REPL and most Julia editor extensions you can just use \mu <tab> and call it a day. This is a non-issue for Julia users.

Because of keyboards?

The difference is that form is important in mathematics and not very important in programming. Therefore symbols are used because it makes it easier for the eye to recognize patterns.

For example these equations look similar,

x^2+4x+5=0

y"+4y'+5=0

Even though one is a polynomial equation and the other is a differential equation, the common visual pattern suggests that the techniques needed to solve them may be similar.

On the other hand in programming there's no need to do this, all the math has already been worked out on paper, so it's better to use clear, distinct, easy to type variable names.

> form is important in mathematics and not very important in programming

How important is form when I'm programming mathematics?

> How important is form when I'm programming mathematics?

Not important.

As a physicist who does a lot of mathematical programming for my every day job, I'm going to disagree pretty hard.

With how I've defined form, I'm not sure how you could.

Who in their right mind does math on a computer, math is implemented on a computer, but it's done by hand.

> Who in their right mind does math on a computer, math is implemented on a computer, but it's done by hand.

Maybe you think this becuase your used to writing math on computers that make writing that math ugly and obtuse?

Besides, having the math you've written by hand closely match the syntax you use on the computer can greatly reduce the cognitive burden of switching between code and paper.

I'll just make one brief comment in regard to wanting the math you've written by hand to closely match the syntax on the computer, and say that this is rarely the correct thing to do when writing high quality numerical software.

Making your code performant, and doing a thorough numerical analysis, usually requires a significant rearrangement of your formulae.

I'm sure there is so much room for improvement here. The closest thing for me is using TeXmacs: https://m.youtube.com/watch?v=H46ON2FB30U

Usually, the formulas I derive on paper end up quite complicated and can not be simplified away. When I am numerically implementing the formula, I want that it matches closely what I wrote in the paper, and long variable names would make my code less clear mathematically.

Why would I use the variable name "probability_distribution_on_m" instead of "rho_m", when I know all along what rho_m means in the contexte of my code (the symbol use throughout the paper). Usually, I comment at the beginning and specify what the variables mean and to what they correspond in the paper. And if somebody needs to read my code, that person will need to understand the paper first. More descriptive variable names won't make the person understand the paper better.

Of course, when I am writing some non-scientific software, I will use descriptive variable names, because there is no complicated formula, no paper that sets the context of the code, and it makes sense in general to have descriptive variables for logic elements for a clear code.

I didn't say to make your variable names verbose. rho_m is fine in my opinion, although I find it strange that you would name a probability distribution rho unless it's a density matrix. I would probably name it prob_dist_m, or even pdist_m if you want to be more terse.

What I do think is bad form would be naming it ρ_m.

Besides the good points about the difficulty typing characters, not all fonts have good glyphs for non-alphanumeric (by that I mean low ASCII) characters. Sometimes they don't have those glyphs at all and the system has to go to a fallback font. Terminals can also shit the bed with Unicode characters.

The solutions to those problems is to use better fonts, terminals, and editors. Using Unicode characters is fine but some people do have legitimate problems with them.

> Besides the good points about the difficulty typing characters, not all fonts have good glyphs for non-alphanumeric (by that I mean low ASCII) characters

Not all fonts are good fonts for an evey use use; heck, not all fonts make 0 and O or 1 and l and I clearly distinguishable.

> The solutions to those problems is to use better fonts, terminals, and editors

Exactly.

On that topic, I'll throw in a shoutout to Cormullion's excellent JuliaMono font [1,2]!

Typing certainly does add more friction between u and µ than a chalkboard would, though it is perhaps also notable that mathematicians seem to have felt that it's worth the effort, and have come up with a quite nice system for it in LaTeX -- and I would certainly not mind seeing more languages and editors add support for LaTeX completions the way the Julia ecosystem has.

[1] https://juliamono.netlify.app/

[2] https://github.com/cormullion/juliamono

Because they dont do it at all on a screen. All papers written in Latex use \mu .

The thing is, symbols like µ and λ often have well-understood meanings in context, especially when using a particular package. It would be like a programmer complaining about using `i` to iterate through an array or `row` and `col` to iterate through a 2D array.

I'm personally very empathetic to this. Fortunately, I think most "real" developers are pretty restraint regarding this in popular packages' code.

Some proper use casees IMHO are: 1. in "terminal" code: scripts, notebooks. 2. function internal variables 3. for making the code look like their counterpart of a paper.

idk what to think of 3. if you look at any paper, non of them only uses ASCII, which raises the question, if we're happy with reading papers (even CS ones) with symbols, why not in our code?

I definitely agree with this. It's just a pain to type out.

Maybe I'm behind on this, but needing to use the mouse to find symbols in a huge menu is very painful.

You can copy and paste too but again, huge break of flow.

Do some editors support discord-style emoji syntax, where typing :fo would bring up a menu of emojis that might match foo. Then hitting enter inserts the emoji over the :foo: representation. You can also not use the auto complete menu.

Ex. :pow2: might turn into ²

Julia has the best REPL for this. You can \<type><tab> to type unicode symbol and emoji.

Better yet, you can reverse look up how to type a thing:

  help?> χ²ᵢ
  "χ²ᵢ" can be typed by \chi<tab>\^2<tab>\_i<tab>

Yeah. Now go edit your code.

I can edit it in Vim with no problem.

Sure, because you have a julia plugin. Not every casual user trying out the language will bother, or want to bother installing someone else's plugin. They'll just hit a function call they need to make with a Unicode character, go WTF man, and give up.

I don’t have a Julia plugin. I don’t even understand what you think the problem is.

> They'll just hit a function call they need to make with a Unicode character

This is optional, the language adapts to the capability of the user. He can write ∑ or sum for a function, µ or mu for an identifier.

https://docs.julialang.org/en/v1/manual/functions/

You get people riled up in this thread with your false assumption, next time simply ask questions.

that's for stuff in the stdlib. You can't control library writers, and julia does not force a function identifier that is mapped to unicode to have a "non-unicode equivalent", though, that might be interesting.

If libraries use unicode in their internals, it doesn't affect you or me. And I have yet to see in the wild any examples of unicode identifiers that are required for use. The closest thing i can think of is the composition operator in Base, though it has a somewhat awkward ascii equivalent.

Do you have any example? As far as I know this is strongly discouraged in the community.

You can easily search for omega and lambda via vim slash(/) search command?

Yes, just like searching for any other character.

How do you type it?

On my keyboard, if I’m in Vim and want to search for λ, I type /λ. I type the λ with <right-CTRL>l.

Any special setup for that? I'd be hard pressed to touch type capital/lowercase sigma, ro, pi and quite a few others, I think.

I fully think this is a problem with archaic input - but that doesn't mean it would not be inconvenient when navigating through a code base :/

I just use what X-Windows supplies for customizing the keyboard. The way to tell the machine what modifier keys to use for what is with xmodmap. My .Xmodmap file contains:

    clear control
    clear mod2
    clear mod4
    keycode 134 = dead_greek dead_greek dead_greek dead_greek
    keycode 108 = Multi_key
    remove Lock = Caps_Lock
    keycode 66 = Control_L
    add control = Control_L

But you have to figure out the keycodes that your keyboard is sending to make it work for your particular machine. The program xev is good for this.

This mapping also makes the capslock key into another control key, which is good if you use Vim.

The Greek letters will be on keys that make sense, and the other Unicode characters are pretty rational too: to make é, type <mod>'e. You can make any key combination produce anything, even long strings, by putting the mappings in the Compose file. My Compose file is in /usr/share/X11/locale/en_US.UTF-8. I have snippets in there, such as my email address. This way the mappings work anywhere, not just in a particular editor.

Thank you. Looks like custom input is still a little up in the air on Wayland. I guess one benefit is that some solutions will also work for the console (though not for the bootloader, so no "pi" boot options... but i can live with that...).

https://unix.stackexchange.com/questions/292868/how-to-custo...

In particular: https://gitlab.com/interception/linux/tools

https://gitlab.com/interception/linux/plugins/caps2esc

(for remapping caps lock to escape - in the terminal and under Wayland).

Oh, sorry, I don’t know anything about Wayland. It took me long enough to learn how to get X11 to do what I want, so I’m not about to learn a new system unless there is a big benefit. I don’t use multiple monitors or do anything that X11 can’t handle, so I'll stay here in 1987.

I actually agree with this sentiment, using non-keyboard utf8 characters in code is just asking for massive problems down the line. A fun party trick perhaps, but such a bad idea for anything that isn't a hobby Project.

I disagree, in that it's the opposite. You might want to put some internal calls in Unicode as a way to gatekeep contributors and users to people who are serious about using Julia. But if you think your project could be used by casual explorers, your public API better not have Unicode calls, or, at least provide sensible non-unicode aliases for unicode calls.

Oh dang I didn't know this. Thanks, TIL!

Yeah. Many editors (VS-code, julia repl, atom), support something very similar where I can type in `\ome` tab complete to `\omega` tab complete to ω. (similar completions exist for many other common unicode symbols).

In the Julia REPL you can type LaTeX commands for Greek letters and math symbols, and a <TAB> converts them to the actual character; so \mu<TAB> gets you a μ. Or you can just input the Unicode directly. I’m constantly doing such things everywhere, so the extra few keystrokes seem worth it to get code where the math looks a more like math. Using the mouse and a menu or character palette is the worst possible solution.

EDIT: In general it makes sense to set up your keyboard with a compose key and a “dead Greek” key, and set up your Compose table so the shortcuts make sense to you. Then you can use an expanded set of symbols everywhere, including comment boxes like this one. You can even put things like your email address in your Compose table.

If your editor doesn’t help, on macOS ^⌘Space brings up the character picker with the search bar focused for the keyboard, so you can just search the name of the symbol and enter.

That might be a problem with your tooling, but most likely not. I know how to do that in Linux (XCompose) and I've heard there are similar tools in both Windows and MacOS as well. So more likely just a problem of not being aware/proficient with using these tools properly. Typing λ² is 6 keystrokes for me, no touching mouse required. And while maybe not very illustrative in this post, I'd argue it's way more readable than lambda_squared when being a part of long and complex formula.

Absolutely it's my lack of experience in tooling. Never had to type unicode symbols consistently.

I think restraint and common sense are key here (once you're comfortable typing the non-ASCII characters). In parts of my code it's much more intuitive to use \Omega or \Sigma and \mu than giving them ASCII names, and others looking at my code will immediately understand what the matrices and vectors do.

On the other hand, if you're going to use \mathfrak{i} to index a simple loop you're doing it wrong.

In certain domains, people will immediately recognize the symbols for delta, lambda, mu...etc. That's how they're written in the textbooks and academic white papers and so on. Seeing the English word is actually more confusing.

> but when writing code that is meant to be maintained and read over and over agains it makes a difference if that µ looks too much like a u sometimes.

So, if you are maintaining code where that is the idiom, use a font where that isn’t an issue.

Mathematica has many non-latin symbols as well, and it works great. The symbols in my paper are the same symbols in my code. No confusion at all.

Have you had to use Symbolize to make compound symbols?

I have not had the need to do it. I have written two large programs, with variables as a[i,j] or as a_{ij} and in both cases Mathematica treats the whole thing as a single symbol.

You can also put Greek symbols in superscripts or subscripts and that works just fine.

Do you think the Symbolize (or the Notation package) are useful? I don't see any examples in the docs, so hard to tell.

I'm a mechanical engineer by training, and a software and control systems engineer by trade. IMO, neither alternative is a good one. I prefer to write out the un-abbreviated form wherever practicable. ex: "microradians", "microseconds", "permeability", etc.

Reply on news.ycombinator.com