A ligature happening is kind of a "syntax affordance" saying that the code is correct, and it indeed says "!=" and not "! =". It kind of helps my brain elevate the code from "sequences of characters" to "serialised syntax tree".
The fact that the "not equals" operator is the exclamation mark followed by an equals sign is purely an artefact of the practicality of keyboard input. Ligatures are a simple way of stepping away from the raw text and into the meaning of things, just like syntax highlighting helps transform "words" into "tokens" on our brains, or rainbow parens help us visualise the hierarchy of the language in question.
(Though I find rainbow parens a bit too colorful and distracting, so I don't use them in practice, I like the idea behind them)
It is the same idea that proponents of visual coding advocate for, but text as a medium is much better because of how compact we are able to make it without feeling cramped.
It can be seen in the choice of tooling, some people really go ham with multi-cursor editing, find-and-replace patterns, "select next word", editor macros, and other text manipulation based tools. While others (myself included) prefer a more content-aware tool like JetBrains' "rename field", "extract method", "widen selection" (select AST parent's text span), etc.
Which is not to say that either group is more correct or efficient, it's just a pattern I see on people.
I’m also someone that likes getting the most out of a basic set of tools or features. A less is more kinda person.
Although I’m old skool Mac OS so I need some kind of GUI.
As I said before, it certainly affects the choice of tooling, and therefore this property of programmers often places them in either side of the eternal "IDE vs text editor" wars. Which is distinct from the GUI vs TUI wars, but in practice most IDEs are somehow graphical. Structure-ers generally prefer tools to be thorough even if they're slow, while Text-ers prefers tools to be as fast as possible so they can be thorough themselves.
I don't think there is really that much of a difference in code style, the general pains of weirdly styled code are often universal regardless of how you look at it. (Text-ers might dislike identifiers with multiple words because it takes longer to navigate through, while Structure-ers might dislike having complicated expressions for the same reason.)
I guess the main impact I see is from pair programming, it is supremely distracting to watch someone with a different mental model of the code do things in what appears to be this "inefficient" way.
I wouldn't say its harder to go back, but it does make me do a double take. Overall I would say the effect is quite minor and I'm just fine without the ligatures, but given the option I would enable / prefer them.
I guess my brain likes having distinct continuous symbols to represent different operations - it reminds of of math in school & university. And I don't see a problem during editing, knowing they're made of multiple symbols.
And yes - I feel that I do struggle much more without them.
Completely out-of-the-blue, unproven guess - my mind is used to learning new symbols quick, from all the gaming I've done. And it's much easier to learn a new symbol that's cohesive, continuous & unique, rather than having to read disjoint characters and figure out a different meaning for them.
I find ligatures more interesting for the slightly more "exotic" syntaxes like arrows → instead of ->, ⇒ instead of =>, etc. Most of them are incredibly similar to their non-ligature counterparts, and even ones like != don't seem to cause much trouble.
I don't seem to have any trouble switching between ligatures in the IDE and no ligatures on github. I haven't really had to think of them.
Now when they are turned off I feel like something is missing, and scramble to turn then on again. For whatever reason my brain feels more comfortable with them.
if you see the <= "less than or equal to" ligature and hit backspace once it will become <. it's very intuitive. this is how emoji operate to combine a face with a skin tone - it is two characters merged into one.
dunno why so many people see ligatures and clutch their pearls like it is some kind of rock and roll devil symbol.
I often work with files (both documents and code) where Unicode input is permitted, and it can then be important to know what exactly is written in the file. Fancy ligatures make this ambiguous.
I would also advise against ligatures in terminals, as it can mess up some text-based interfaces.
I guess looking at font that doesn't support ligatures does become a little bit harder, but I can't imagine the switch being too time consuming.
I've been using JetBrains Mono for years now. It's great.
However, most programming languages really just have a few symbols: arithmetic operators (+, -, /, *), comparison operators (<, >, <=, >=), and logical operators (&&, ||, !). C also has bitwise operators (~, &, |). It's already easy enough to distinguish these without ligatures, so the benefit is negligible here, IMO. I prefer to go without ligatures, because I have no trouble remembering or distinguishing them, and, like someone else mentioned, I find ligatures in a monospace font kind of weird (how they morph into a two column character when you write them, and turn back to a one column character when you delete half of it).