# Line numbers in text editor

Okay this sounds like a question a six year old would ask, (and I hope there is an empirical answer) so here's my inner child: In programming numbers start from from zero but why do line numbers in text editors (for programming) also start from one?

• Zero index signifies memory address (first place of the memory block) whereas line 1 is plain number 1. Human, including programmers, count thing starting from 1. Non-programmers usually confusing between things and places. – 9dan Jan 16 '13 at 15:27
• Not all programming languages start array indices at 0. I suppose most modern languages do, but I think program line numbers beginning at 1 predate array indices starting at 0. – obelia Jan 19 '13 at 4:51

Line numbers need to be countable. It is more intuitive to start counting at `1` instead of `0`, because `0` (say: zero) means none, not one.

Looking at a coffee mug on your table, you would not answer the question of how many mugs there are by saying: "Zero" - because that would imply no mug at all is on your table. Thus with line numbers, and almost every other countable thing there is, you'd start with `1` for logic reasons.

Your real questions should be: Why on earth do array indices and the like start from `0` in programming! :)

• You might find the following useful: en.wikipedia.org/wiki/Zero-based_numbering – CJF Jan 16 '13 at 13:01
• I think this answer is best summarized as `Because only programmers start counting at 0, and not only programmers use text editors`. – SpellingD Jan 16 '13 at 15:16
• Because only programmers start indexing at 0 :) – kontur Jan 16 '13 at 15:18
• s/indixes/indices/ – steveax Feb 22 '13 at 20:16
• Do you ever count lines like this, though? To me, line numbers are a clear-cut example of indexing, thus zero-basing would have made things easier for users. – James Wood Oct 9 '14 at 8:10

Kontur is correct. But I would also like the add that Arrays in programming start at 0 for a very specific reason. This is not because the number in an array is supposed to 'count' the amount of elements, but instead it is considered an offset value, and thus array merely means that the specific entry is 0 memory positions away from the start of the array in memory and array is 1 position along. They are not used for counting purposes but as an offset meaning it is perfectly logical that programming lists start at 0.

• I would agree that this is the historical reason array indexes started at zero (when array indexes were mapped to memory addresses), but would argue that the reason it is still this way has more to do with the mathematical convenience of dealing with 0-based indexes than anything to do with memory offsets. – devios1 Jan 17 '13 at 19:25
• Counting arrays from 0 is C (where you have pointer arithmetics); Algol68 etc. starts at 1. See here. – Reinstate Monica - M. Schröder Jan 17 '13 at 19:37

Early languages like FORTRAN had the first element of an array starting with 1, and it was weird when C came along to use 0. That's only natural to you youngsters. FORTRAN started with 1 because it was natural to number things in a list starting with 1. C started with 0 because it was a language deliberately written to be close to the hardware, whereas FORTRAN was abstracting the mathematical concepts with no idea as to how the computer would implement it. Of course we had to be able to know in some cases how the code was implemented in machine language, but in general C is much closer to the hardware.

• Good point about abstraction also! There is a good reason why starting at 0 makes sense under the angle of technical logic, but that has little to do with common sense logic. – kontur Jan 31 '13 at 11:30

It is purely historical / traditional / cultural. In many ways one can argue that line numbers should start at zero. But text editors have always labeled the first line as line one, and any editor that labeled it as zero would be outcast.

Generally, the difference between starting at 1 and starting at zero is whether you are "counting" or "measuring". If you measure a highway, it is clear that the point where the highway starts is "zero". But what do you call that first mile? Is it "mile 0" or is it the "first mile"? Both are acceptable depending upon whether you are measuring the distance, or counting the miles. This is very much like centuries: 1950 is the middle of the "20th century". The distinction is the 1950 is a measure of the time since the beginning (except there was no year zero, another historical anomaly) and the other is a counting of the centuries.

In an array, we are "measuring" to the position, and this is preferred not because it is closer to the hardware, but because the math works out easier. The first element in an array is always 0 units from the beginning of the array. This becomes quite apparent when you have an array of arrays. Imagine an array of decades, each element of which is an array of years. You would want the years to run 0 thru 9 to represent a decade like 1950 thru 1959. While it could be implemented either way (the first year of the decade is 1950, which is zero years from the start of the decade). The math is easier if the you can simply subtract to find the offset = (year - decade_start).

All that being said, the logic is that the first line of a text file really should be called "line 0" because you are measuring the position in the text file. But it is not. I don't believe there is a logical reason for that, but simply that it has been traditionally labeled with a "1". Perhaps in the same tradition that the first year in the Gregorian calendar is named "1" as well.

Starting from zero sounds a bit too technical to a six year old inside me :)

It probably gives an impression that

• first line will not be counted,

• or the code lines have not started from here,

• or it is only for the comments.

We (programmers) don't actually count from zero, I think that's a misunderstanding. The first element in an array is at index (or offset) zero (but it's still the first element, i.e. element number one).

So there's no reason to count lines from zero, because no one counts from zero.

In fact if your editor shows relative line numbers, you'll see that the current line is number "0".

You can check by yourself in any recent version of vim (> 7.3) by using the command:

``````:set relativenumber
``````