[kroltan]

For me it's not a matter of speed, but distinctness and fitness to the meaning.

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.

[kroltan]

Which leads me to another tangent, which is that there is a very clear split between programmers that "manipulate text" and programmers that "manipulate structure".

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.

[firecall]

I’ve never really thought about, but I’m in the first group for sure.

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.

[Shawnj2]

As someone in the second group the IDE is basically just doing the first thing efficiently for you when you do the second thing. Not a good or bad thing but I do think that that’s interesting to note

[kroltan]

Yep, it's just the mental framing, which is why it doesn't really have noticeable effects elsewhere in code.

[flir]

I'm in the first group (these are text files first and foremost) and I think that's a really interesting observation. Do you have any thoughts on what the consequences might be?

[kroltan]

Can only speak of experience writing code for both groups and seeing them work, don't take any of the info below as statistical truth.

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.

[ghqst]

As someone who manipulates structure, the refactoring tools and the like, as well as the formatting IntelliJ does for you, make my programming less portable between editors. Text-driven development is very portable, but I actively dislike using VSCode in comparison to IntelliJ because it refactors and formats code in different ways.

[function_seven]

I have nothing to add, just wanted to say I think this is the best-written explanation I’ve come across for why I like both ligatures and good syntax highlighting.