Line limit to 120

[mattBrzezinski]

I'm finding the 92 line limit very restrictive and forcing breaks more often than not. Between giving a function a meaningful parameter name and typing it you're more often than not breaking this line with a couple parameters.

I'd propose increasing this line length to 120, it allows you to reasonably read two files side-by-side in an editor. I think this is goes a bit hand in hand with #76 and I think makes things easier to read.

Some Linus thoughts from a fixed 80 character limit.

[iamed2]

I can only hit 112, not 120.

I think 100 would be best.

[mattBrzezinski]

I'll take anything, do others have thoughts?

[fchorney]

I think 120 is a little bit much. So I'd compromise to 100

[nickrobinson251]

i'd be a little bit interested in knowing what effect this has in terms of reducing line breaks.
JuliaFormatter has a BlueStyle and let's you configure line length (via the margin keyword e.g. format("path/to/src/", BlueStyle(); margin=N), so we could see across a bunch of different packages how changing N changes the total number of line breaks?

[zsz00]

I'd propose increasing this line length to 120 !!

[omus]

If I recall correctly the original reason 92 was chosen was because it is the line length limit specified by the Julia contribution guide.

[mattBrzezinski]

If I recall correctly the original reason 92 was chosen was because it is the line length limit specified by the Julia contribution guide.

The commit for this was made 7 years ago, maybe it's time to revisit? 😄

[mattBrzezinski]

i'd be a little bit interested in knowing what effect this has in terms of reducing line breaks. JuliaFormatter has a BlueStyle and let's you configure line length (via the margin keyword e.g. format("path/to/src/", BlueStyle(); margin=N), so we could see across a bunch of different packages how changing N changes the total number of line breaks?

Just got brought up in the office again. I went through all the packages below and ran format(".", BlueStyle()) did a git add ., then re-ran format(".", BlueStyle(); margin=100) (only 100 since it seemed more agreed upon from previous discussions). These are the results of the following git diff --shortstat:

• BlockDiagonals.jl: 4 files changed, 9 insertions(+), 22 deletions(-)
• ChainRules.jl: 4 insertions(+), 10 deletions(-)
• CompatHelper.jl: 13 files changed, 39 insertions(+), 117 deletions(-)
• Intervals.jl: 11 files changed, 58 insertions(+), 155 deletions(-)
• OrderedCollections.jl: 6 files changed, 23 insertions(+), 63 deletions(-)

[Wynand]

I'm not a linguist or typographer, but 92 characters seems fine with a few assumptions by taking
(things on the line) * (max length of each thing) + (connectors between things) as an equation for line length

If you assume most people can keep 5-9 things in mind at a time, that indentation is some of those things, and if you really stretch it an assume that the length limit for remembering a word is between 5 and 9, then the upper limit on that is actually (9*9 + 8) = 89

I think 89 is short, especially considering that the 7 +- 2 rule is outdated (though 4 +- 1 is apparently more accurate) (https://en.wikipedia.org/wiki/Short-term_memory#Capacity), but it suggests that 92 characters is long enough

[iamed2]

@Wynand one of the most common things, AbstractArray, is of length 13. As you have more functions in your codebase, the length of the things are probably going to increase. If you look at the top-level symbols in Base, the average size is greater than 11:

julia> mean(length∘String, names(Base; all=true, imported=true))
11.476996687523004

(a better measurement could be done with a parser rather than just looking at the top level)

@mattBrzezinski can you show those diffs? it might be interesting as a sample of lines that are impacted by the current line length limit.