[type_enthusiast]

I think the answer is pretty clearly "no, but" (or "yes, if"). Of course it depends on what you're doing – if you're writing shell scripts, it might make sense to keep them at 80 characters in case you have to go down to the data center and edit them from a terminal because your network card failed. But for most code, there's no particular limit that makes sense (in my opinion).

I'm somewhat against code formatting "rules" in general. If it's about readability (/aesthetics), different code will have different properties that make it readable or unreadable. Sometimes, forcing a line break makes code less readable. In other situations, it can have the opposite effect. IMHO, it's a local decision – and the human that's working on that code is better at deciding what's readable than a linter is.

[necovek]

I agree with you that writing readable and aesthetically pleasing code is more art than science (that can be expressed with deterministic rules), I still find some of the rules and rule-checkers beneficial (though I dislike strict formatters).

As such, 80 is as good a limit as any, and makes you think carefully about avoiding deep nesting of blocks, which is usually a good idea anyway. It also allows putting many windows side-by-side on a modern big 4k screen.

[type_enthusiast]

I have to push back here a little bit. It really depends.

I mainly use Scala, and I think the majority of Scala code would be far less readable if forced to 80 columns, than if it were a larger number (or simply unconstrained).

My WFH monitor is an Apple Thunderbolt Display, which is woefully out-of-date now. Even on this display, and even though I use a much larger font than most people (16pt Hasklig), and even with a generous project/navigation/etc sidebar, I still get 180 characters. The display I have in the office is even wider, but I can't measure it right now because I'm not there.

My point is, displays are now wide enough where arbitrary line limits don't make sense. Nobody is going to cram stuff into one line unnecessarily, so just leave it up to the local decision about what makes the code most readable. If for some reason a 240-character line is more readable in some situation, then we should talk about that situation rather than why they didn't break the lines.

[fragmede]

Unfortunately, while the monitor on my desk has gotten bigger, I've got this screen that I hold in my hand that's smaller than any desk monitor, and it's in portrait, not landscape mode, so while I don't write code on it, I do read code on it, so now, ideally, we'd accommodate that use case as well.

[necovek]

With 180 characters on your display and lines of more than 90 characters, you can't put two code windows side-by-side.

But it sure depends on the language too, though I wonder what's so peculiar about Scala to really benefit from long lines?

[llm_trw]

Method chaining, and a lot of it too. I honestly think it's a code smell, but some people love to do a dozen transformations in one line. You then need to make the line twice as long with .taps to debug it.