This has got to be one of my least favourite trends in programming aesthetics these days. For a font claiming to "follow function" to devote so much effort to sacrificing function for the _vogue du jour_ is especially rich.
If you don't like them, don't use them. It's that simple.
Other people do like them, and will continue to use and enjoy them.
My understanding is that if the font has ligatures then the way to not use them is to use a different font (which is fine - there's a lot of fonts out there :) ).
Is that the only way, or is there a way to disable ligatures but keep the rest of the font? Can you disable only some of the ligatures?
TIA!
but you absolutely don't have to use them.
regular fonts are basically "use this image for 'a', this image for 'e'" etc. ligatures are extra data that says "if you find an 'a' next to an 'e', use this other image in place of the 'a' and 'e' images". but the non-ligature versions of characters are still in the font for use when there is no ligature sequence (just put a space in the middle of any ligature in your editor and you'll still see the independent characters rendered in the font).
So you can turn them off even in fonts that have them, but most fonts have separate versions with and without anyway.
For Atom see (3).
There does not appear to be a way to disable them in Visual Studio.
(1) https://stacksjar.com/post/use-of-font-ligatures-in-vs-code
(2) https://marketplace.visualstudio.com/items?itemName=Coenraad...
I sometimes—rarely happens thought—dislike how the cursor renders on top of ligatures in vscode. Always wished it would allow me to "inject" the cursor into the ligature, but since it didn't happen often or bother me as much, I never tried looking for a solution. This will be a small, but much appreciated quality of life improvement! Thanks again!
It's actually not that easy to use them with for example Emacs where you have to list every combination that you want to 'translate' to a ligature:
Personally -- after originally thinking like you -- I really enjoy ligatures in my code. I disable them for my terminal though.
The same font can work both with and without ligatures, so it's not a negative if a font supports them. You can choose whether to enable them.
That is, I won't claim they help readability. But they do make me smile, and don't seem to hurt. (I'm assuming they disappear on copy operations. Mac OS' habit of replacing -- with a longer dash is painful when sending cli arguments.)
When I'm reading fiction, I generally don't mind ligatures. I find them oppressively obscurantist in any situation where I want to know clearly and distinctly what each character is -- i.e. code and science/math/engineering.
About the only time they are easily visible is in large type, when they really shouldn't be used.
It's kind of like right justified text. Done well, it shouldn't be noticed how it was done.
So, YMMV.
Presence of ligatures in a "font designed for developers" is neither a plus nor a selling point. It is a pointless embellishment that shows that fonts' authors don't grok the character-oriented nature of computer languages. So them parading ligatures as something desirable only serves to detract from the rest of the font design and to nick their credibility as coding font designers.
In particular when doing presentations having fonts that are capable of producing ligatures in monospace contexts is quite useful.
That's like your opinion man.
> So them parading ligatures as something desirable
Others desire them, so they include them. I thank that.
> shows that fonts' authors don't grok the character-oriented nature of computer languages
Nonsense, just an empty insult. I don't think you grok ligatures.
> only serves to detract from the rest of the font design
Your opinion, I believe it enhances the font design.
> to nick their credibility as coding font designers
Another empty insult. Including a feature that people like doesn't hurt their credibility.
See also:
https://www.dictionary.com/browse/subjective
Hogwash. They provided all the characters (which ligatures are also, but you seem bizarrely "against" but "for" the ASCII ones), and ligature-less versions as well. So they grok it at least that far.
You don't need to take their word or rely on their credibility for anything. There's a demo right there of the font for you to decide if it's for you or not.
- there are more fonts without ligatures than there are fonts with ligatures. - every single OS I can think of include by default a monospace font that do not support ligatures. - there are still a huge amount of terminals which do not support them. - for almost any font that has ligature there is a variant without ligature - there is virtually no way to end up with ligatures without actively looking to get ligatures. - any terminal/editor that supports ligature has a setting for that. - most people do actually like ligatures which is the reason they use those editors/terminal/fonts and want those activated by default.
I want to learn Julia in part because it makes use of “fancy” chatacters (so your math looks like math). I like the more functional JS style, and I’m interested in haskell. And I love ligatures. Anedata of one.
Are you more a C-family person, or an ML-family person?
I love them ligatures. I'm looking at this code for lots of hours every day. Let me enjoy it via a nice font — with ligatures — if I deem so.
You seem to have done it well enough with at least 64 of them; maybe closer to 70 since you use _, ., , and ".
Don't let a few more ruin your day. A few more, I might add, that you don't even have to use.
Semantically, the language would like to use a ⇒, because it's representing the idea of an arrow. It's only due to keyboard constraints that it has use use =>. Parsers (and our brain is also a parser) would be much easier to implement if meaning didn't have to derive from symbol combinations like =>, !==, <!--. The input interface is limited to ascii to represent meaning, but our eyes don't need to be.
Sounds like we agree that a font that does this should never be a default. I don't think customized environments to the extent that one developer sees a different view of the code from another are a good idea (partly because I think reviewing and pair-programming are very valuable), but I guess if you want to set up something like that it's fine as long as you're not pushing it on anyone else.
> And any developer should already be well aware that no common language uses symbols beyond ASCII, so seeing ⇒ should be clear enough already that it's a ligature.
I've been using ⇒ in Scala for over a decade, shrug.
Ruby and scala allow using such characters, and there are libraries that use it. Julia actually has special characters in the standard library, although afaik they all have ascii aliases. The repl and many editor plugins support expanding tex style escapes to those special characters.
I wouldn’t know where to get the “⇒” codepoint, and getting is probably more effort than just writing “==>” with the added benefit of my teammates not having to use the ligature (or figure out the symbol) if they don’t want to either.
Brain is really good in parallel processing of letters/symbols as units. I very much doubt that it's "objectively better". See https://docs.microsoft.com/en-us/typography/develop/word-rec... for overview of the research in this area.
For me the problem with ligatures is not so much of recognizing them but reproducing. I know that for arrow ligature I have to have = and >, but there may be ligatures that I might not be sure of how they're formed. Also, when reading the same code in different environment where the same font is not available I get different visual output where not only is the base shape of the letters different but code units as well. For example three lined equals ligature that some fonts produce. I really hate it.