7 Jun
2017
7 Jun
'17
2:56 p.m.
I learned the other day that array indexes in some languages start at 1
instead of 0. This seems to be an old trend that changed around the 70s?
Who started this? Why was the change made?
It seems to have come about around the same time as C, but interestingly
enough Lua is kinda in between (you can start an array at 0 or 1).
Smalltalk can probably have a 0 base index just by it's nature, but I
wonder whether that would work in a 40 year old interpreter.
7 Jun
7 Jun
3:16 p.m.
The original FORTRAN and BASIC arrays started indexing at one because everybody other than
computer scientists start counting at 1.
These languages were for scientists and the beginner, so you wanted to make things
compatible with their normal concepts.
PASCAL on the other hand required you to give the minimum and maximum index for the
array.
It was an interesting concept when I got into computers in the early seventies that things
would be numbered from zero. Tape drive 0, TTY0, etc…
Of course, C’s half-assaed implementation of arrays kind of depends on zero-indexing to
work.
From: TUHS [mailto:tuhs-bounces@minnie.tuhs.org] On Behalf Of shawn wilson
Sent: Wednesday, June 7, 2017 8:57 AM
To: The Eunuchs Hysterical Society
Subject: [TUHS] Array index history
I learned the other day that array indexes in some languages start at 1 instead of 0. This
seems to be an old trend that changed around the 70s? Who started this? Why was the change
made?
It seems to have come about around the same time as C, but interestingly enough Lua is
kinda in between (you can start an array at 0 or 1). Smalltalk can probably have a 0 base
index just by it's nature, but I wonder whether that would work in a 40 year old
interpreter.
3:20 p.m.
shawn wilson <ag4ve.us(a)gmail.com> wrote:
I learned the other day that array indexes in some
languages start at 1
instead of 0. This seems to be an old trend that changed around the 70s?
Who started this? Why was the change made?
It seems to have come about around the same time as C, but interestingly
enough Lua is kinda in between (you can start an array at 0 or 1).
Smalltalk can probably have a 0 base index just by it's nature, but I
wonder whether that would work in a 40 year old interpreter.
Basically, until C came along, the standard practice was for indices
to start at 1. Certainly Fortran and Pascal did it that way. I suspect
that all the Algol family languages did too, but I only did a little
Algol W programming in colledge and that was long ago. I think Cobol also.
Pascal (IIRC) allowed you to specify upper and lower bounds, something
like
foo : array[5..10] of integer;
with runtime bounds checking on array accesses. (I could be wrong ---
it's been a LLLLOOONNNGGG time.)
HTH,
Arnold
3:50 p.m.
On 7 Jun 2017 07:20 -0600, from arnold(a)skeeve.com:
Basically, until C came along, the standard practice
was for indices
to start at 1. Certainly Fortran and Pascal did it that way. I suspect
that all the Algol family languages did too, but I only did a little
Algol W programming in colledge and that was long ago. I think Cobol also.
On the other hand, before C, both B and BCPL used zero-based indexing.
So if we trace C's family tree, there is certainly precedence for
zero-based indexing into arrays.
https://www.bell-labs.com/usr/dmr/www/kbman.pdf page 8 (PDF page 10)
says:
7. A vector is a primary expression followed by any
expression in []
brackets. The two expressions are evaluated to rvalues, added and
the result is used as an lvalue. The primary expression can be
thought of as a pointer to the base of a vector, while the bracketed
expression can be thought of as the offset in the vector. Since
E1[E2] is identical to *(E1+E2), and addition is commutative, the
base of the vector and teh offset in the vector can swap positions.
And https://www.bell-labs.com/usr/dmr/www/bcpl.pdf page 11 (PDF page
14) says:
4.7 Vector Applications
/.../
Semantics: A vector is represented by a pointer to a consecutive
group of words which are the elements of the vector. The pointer
points to the zeroth element.
--
Michael Kjörling • https://michael.kjorling.se • michael(a)kjorling.se
“People who think they know everything really annoy
those of us who know we don’t.” (Bjarne Stroustrup)
4:02 p.m.
Michael Kjörling <michael(a)kjorling.se> wrote:
On the other hand, before C, both B and BCPL used
zero-based indexing.
So if we trace C's family tree, there is certainly precedence for
zero-based indexing into arrays.
Ah. OK. I never used either language. I get the impression that BCPL
wasn't used / known much in the US, but I could be wrong. I was exposed
to BASIC and FORTRAN (and computer programming) circa 1976 and to C
in 1980. Anything before then is before my time ... :-)
Thanks,
Arnold
8 Jun
8 Jun
1:28 p.m.
arnold(a)skeeve.com writes:
Michael Kjörling <michael(a)kjorling.se> wrote:
It may be obvious, but awk(1) uses 1-indexing for arrays and string
offsets, and shell arguments are indexed from 1 too (which may be
reasonable given the special behavior of argv[0], but I think this
resulted in rc(1) being 1-indexed for lists). pic(1) sensibly uses
1-indexing in the "Nth" notation.
--
Christian Neukirchen <chneukirchen(a)gmail.com> http://chneukirchen.org
On the other hand, before C, both B and BCPL used
zero-based indexing.
So if we trace C's family tree, there is certainly precedence for
zero-based indexing into arrays.
Ah. OK. I never used either language. I get the impression that BCPL
wasn't used / known much in the US, but I could be wrong. I was exposed
to BASIC and FORTRAN (and computer programming) circa 1976 and to C
in 1980. Anything before then is before my time ... :-)
4:56 p.m.
On Jun 8, 2017 7:29 AM, "Christian Neukirchen" <chneukirchen(a)gmail.com>
wrote:
arnold(a)skeeve.com writes:
Michael Kjörling <michael(a)kjorling.se> wrote:
It may be obvious, but awk(1) uses 1-indexing for arrays and string
offsets, and shell arguments are indexed from 1 too (which may be
reasonable given the special behavior of argv[0], but I think this
resulted in rc(1) being 1-indexed for lists). pic(1) sensibly uses
1-indexing in the "Nth" notation.
I never thought of it like that wrt awk. However, I always thought of $0 as
"self" in higher level OO languages.
On the other hand, before C, both B and BCPL used
zero-based indexing.
So if we trace C's family tree, there is certainly precedence for
zero-based indexing into arrays.
Ah. OK. I never used either language. I get the impression that BCPL
wasn't used / known much in the US, but I could be wrong. I was exposed
to BASIC and FORTRAN (and computer programming) circa 1976 and to C
in 1980. Anything before then is before my time ... :-) 
7 Jun
7 Jun
4:58 p.m.
Michael Kjörling <michael(a)kjorling.se> wrote:
And https://www.bell-labs.com/usr/dmr/www/bcpl.pdf page 11 (PDF page
14) says:
> 4.7 Vector Applications
> /.../
> Semantics: A vector is represented by a pointer to a consecutive
> group of words which are the elements of the vector. The pointer
> points to the zeroth element.
That syntax is quite different from the later BCPL that I'm familiar with.
http://www.cl.cam.ac.uk/~mr10/bcplman.pdf
It has a ! indirection operator which can be both unary and binary, as in
old BCPL new BCPL C
lv x @x &x
rv ptr !ptr *ptr
ptr*[i] ptr!i ptr[i]
Richards' 1969 paper uses a down-arrow for binary !
You can use "manifest" constants for laying out a structure, e.g.
MANIFEST { car; cdr; }
declares car and cdr to have values 0 and 1. This lets you do struct-style
indirection using the same operator as for array indexing, like in this
function definition:
LET cadr(p) = p!cdr!car;
When I saw how ->integ is used in the 6th Edition kernel it felt very BCPL
to me.
Tony.
--
f.anthony.n.finch <dot(a)dotat.at> http://dotat.at/ - I xn--zr8h punycode
Shannon: Cyclonic becoming southwest, 5 or 6. Moderate or rough. Rain.
Moderate or poor.
8 Jun
8 Jun
1:57 a.m.
On Wed, 7 Jun 2017, Tony Finch wrote:
You can use "manifest" constants for laying
out a structure, e.g.
MANIFEST { car; cdr; }
declares car and cdr to have values 0 and 1. [...]
Which of course led to C's "enum" facility.
`
--
Dave Horsfall DTM (VK2KFU) "Those who don't understand security will
suffer."
7 Jun
7 Jun
6:31 p.m.
Basically, until C came along, the standard practice
was for indices
to start at 1. Certainly Fortran and Pascal did it that way. I suspect
that all the Algol family languages did too, but I only did a little
Algol W programming in colledge and that was long ago. I think Cobol also.
APL (excepting some early implementations) lets you set the "index origin"
to either 0 or 1, either by assigning a value to the quad-IO system
variable, or through the ')ORIGIN' command (varies with the
implementation).
Changing quad-IO inside a function at runtime was a trick used to inflict
endless terror on many a first-year undergrad ;-)
--lyndon
8 Jun
8 Jun
2:47 a.m.
On Wed, 07 Jun 2017 07:20:43 MDT arnold(a)skeeve.com wrote:
Basically, until C came along, the standard practice was for indices
to start at 1. Certainly Fortran and Pascal did it that way.
Pascal's array type syntax is
array-type: "array" "[" index-type "]" "of"
type
Index type could be an integer sub-range or scalar type or
scalar sub-range. Pascal doesn't allow specifying array size
with a simple integer so the question of default index for
first element doesn't arise.
In spite of having learned and used Pascal, PL/I, Fortran and
APL before C, a lower bound of 0 seemed most sensible to me.
Not because of any efficiency reasons but because of modular
arithmetic which I learned before C!
7 Jun
7 Jun
7:59 p.m.
On 7 Jun 2017, at 13:56, shawn wilson <ag4ve.us(a)gmail.com> wrote:
I learned the other day that array indexes in some languages start at 1 instead of 0.
This seems to be an old trend that changed around the 70s? Who started this? Why was the
change made?
I was going to make the obvious glib comment about languages which care more about some
transient notion of efficiency than usability leading to 0-based indexing.
But I think in fact it must be cultural: FORTRAN was historically 1-based, of course, and
although it looks like LISP 1 (1960) didn't have arrays, LISP 1.5 (1962) *did*, and
they were 0-based. It looks to me like ALGOL 58 allowed you to define lower & upper
bounds, based on
http://www.softwarepreservation.org/projects/ALGOL/report/Algol58_prelimina…
So I suspect that languages designed by and for people who actually did a lot of numerical
matrix manipulation (ie applied mathematicians, physicists &c) used the conventions of
those fields, which were and are 1-based indexing; languages designed by & for formal
CS people tended to use zero-based, and languages designed by people who were feeling
their oats as regards flexibility allowed user-defined bounds.
--tim
8:29 p.m.
On Wed, Jun 7, 2017 at 8:56 AM, shawn wilson <ag4ve.us(a)gmail.com> wrote:
I learned the other day that array indexes in some
languages start at 1
instead of 0. This seems to be an old trend that changed around the 70s?
Who started this? Why was the change made?
Tastes Change -- but I really think its more "things happen" is the short
answer.
The longer answer really comes from what you were comfortable. As has
been pointed at the 'engineers' and US types that grew up in the world of
Fortran and Basic in the 50s, and 60s had used 1. Which made perfect
sense for them. Certainly has my father was taught and how he taught me
in the sixties. However, the 'formal' mathematician and Europeans types
from the Algol world tended to think 'normal' in terms of counting from 0
like the HW did during the same time period.
By the late 60s, early 70th, as has been pointed out, some languages
started to offer some choice. I remember different professors at CMU
having different views what was better - and clearly it was a matter of
taste. But most took a view of what was most important was to keep *to
local custom and convention *as the SW engineering rule* of 'least
amazement' *needed to be high bit.
I think the more interesting note is that Ken has gone on record to state
he set out to create a Fortran compiler when he created B. So it is an
interesting question of why B (and C) ended up with the BCPL (Algol)
convention of 0 based addresses not the Fortran 1 based? But I actually
think the 'zero-ness' of today, we have is less to do with
'Algol-like'
(Pascal et al) winning and being 'better' than it was that C ended up as
the dominant language and for whatever reason Ken picked zero based
addressing - probably >>I'll guess<< because he was staying close to the
HW.
Clem
8:46 p.m.
If you think of an array as a memory area of bytes, words, whatever, the
simple way to deal with it is the index being 0 is the first in the array.
Why go to the trouble of decrementing the index to retreive the first
entry?
ALGOL did indeed have arrays with bounds:
INTEGER ARRAY K,L[0:10,0:10];
Two arrays, K and L with 0 first, 10 last. Total of 11 elements.
Of course, it's a "higher level" language than C. My thinking on the
subject is that C is very close to assembler, so if you're using for
example Intel X86 instructions:
MOV SI,1
MOV AL,[SI + ARRAY1] ; retrieve the SECOND
element (byte)
Likewise, for words, just left-shift SI one bit.
For me having started out in assembler (actually, MACRO-10 on a PDP-10),
it's intuitive as to why/how C does arrays.
ak
9:15 p.m.
On 6/7/2017 3:03 PM, Ron Natalie wrote:
In the days when memory and clock cycles were costly, an extra decrement
or subtract was not something to be taken lightly :)
On the other hand, I can see that you could solve this in the
preprocessor. In my example, just make it:
MOV AL, [SI + (ARRAY1 - FIRSTELEMENT)]
And let the assembler deal with it.
Still, there's something oddly "artificial" about that, again from the
machine language point of view. There's nothing "idiotic" about it IMHO.
It's just the way processors actually work.
Of course, if you're really into abstraction, well, to each his own :)
ak
Why go to the
trouble of decrementing the index to retreive the first entry?
What makes you think
that you have to decrement the index. Don't get sucked up in the idiotic C
implementation of an array. Arrays can be efficiently implemented no matter where the
index starts.
9:49 p.m.
The memory storage location and the first element offset are effectively constants, you
can remove them from the equation.
8 Jun
8 Jun
3:58 a.m.
Le jeudi 8 juin 2017, Arthur Krewat <krewat(a)kilonet.net> a écrit :
On 6/7/2017 3:03 PM, Ron Natalie wrote:
I doubt that avoiding a decrement was really the reason. I mean, it's an
array: if you're 0-basing it you're still paying a decrement but for bounds
checking this time. Keeping as close as possible to how the target machine
worked or following a convention in another hand, that I can see.
Loïc
--
ARJANEN Loïc Jean David
http://blog.luigiscorner.com
---
“Computer science is no more about computers than astronomy is about
telescopes, biology is about microscopes, or chemistry is about beakers and
test tubes. Science is not about tools. It is about how we use them, and
what we find out when we do.”
Michael R. Fellows and Ian Parberry
Why go to the trouble of decrementing the index
to retreive the first
or
subtract was not something to be taken lightly :)
entry?
What makes you think that you have to decrement the index. Don't get
sucked up in the idiotic C implementation of an array. Arrays can be
efficiently implemented no matter where the index starts.
In the days when memory and clock cycles were costly, an extra decrement 
3:49 p.m.
On Wed, Jun 7, 2017, at 15:15, Arthur Krewat wrote:
On 6/7/2017 3:03 PM, Ron Natalie wrote:
In the days when memory and clock cycles were costly, an extra decrement
or subtract was not something to be taken lightly :)
You wouldn't need a decrement per access, because the base itself could
still be stored as the address of the "0th" element (i.e. what would be
the "-1th" in a 0-based system). It might add some extra complexity to
the relocator, if it's not currently possible to have a reference
outside the bounds of an object and/or with a negative offset, but
statically linked programs (the only kind on V7 and earlier) did not do
any runtime relocation.
Why go to
the trouble of decrementing the index to retreive the first entry?
What makes you
think that you have to decrement the index. Don't get sucked up in the idiotic C
implementation of an array. Arrays can be efficiently implemented no matter where the
index starts.
3:55 p.m.
On 6/8/2017 9:49 AM, Random832 wrote:
On Wed, Jun 7, 2017, at 15:15, Arthur Krewat wrote:
Shortly after making that statement, it occurred to me that the
preprocessor or assembler could take care of that easily.
Even better than worrying about whether arrays started at 0 or 1 in C
would be to institute bounds checking in the first place :) But again
would add lots of extra code that in the days of the origins of C was
not something you wanted to add to the memory footprint.
In the days when memory and clock cycles were
costly, an extra decrement
or subtract was not something to be taken lightly :)
You wouldn't need a
decrement per access, because the base itself could
still be stored as the address of the "0th" element (i.e. what would be
the "-1th" in a 0-based system). It might add some extra complexity to
the relocator, if it's not currently possible to have a reference
outside the bounds of an object and/or with a negative offset, but
statically linked programs (the only kind on V7 and earlier) did not do
any runtime relocation.
8:41 p.m.
On 7 Jun 2017, at 20:15, Arthur Krewat
<krewat(a)kilonet.net> wrote:
In the days when memory and clock cycles were costly, an extra decrement or subtract was
not something to be taken lightly :)
Indeed they weren't, and that's how we know that 1-based indexing doesn't
require any overhead given a reasonably good compiler. If you'd gone to people
writing big CFD simulations in 1975 and told them that by using a version of FORTRAN which
had 0-based arrays they could save any significant runtime at all then they would have
changed to it without a thought. But they didn't.
4:45 a.m.
Arrays can be efficiently implemented no matter where the index starts.
Keep in mind that C was/is primarily a language to write OS's and
other system level software. Hardware such as memory addresses, page
tables, disk sectors, etc. are all indexed from zero for very good
reasons. I would shudder to contemplate an implementation of the Unix
V6 kernel in a hypothetical C-with-one-based-arrays language.
6:05 a.m.
On Wed, 7 Jun 2017, Robert Swierczek wrote:
Keep in mind that C was/is primarily a language to
write OS's and other
system level software. Hardware such as memory addresses, page tables,
disk sectors, etc. are all indexed from zero for very good reasons. I
would shudder to contemplate an implementation of the Unix V6 kernel in
a hypothetical C-with-one-based-arrays language.
Weren't the Burroughs mainframes implemented in Algol, likely with a
1-origin? Of course, I could be wrong (it was quite a few years ago since
I touched a B-1700)...
--
Dave Horsfall DTM (VK2KFU) "Those who don't understand security will
suffer."
8:19 a.m.
On 2017-Jun-07 22:45:08 -0400, Robert Swierczek <rmswierczek(a)gmail.com> wrote:
Keep in mind that C was/is primarily a language to
write OS's and
other system level software. Hardware such as memory addresses, page
tables, disk sectors, etc. are all indexed from zero for very good
reasons. I would shudder to contemplate an implementation of the Unix
V6 kernel in a hypothetical C-with-one-based-arrays language.
Two counter-examples
1) CHS numbers sectors starting from 1, not 0.
2) Pr1meOS was written in Fortran.
--
Peter Jeremy
9:02 a.m.
On Thu, 8 Jun 2017, Peter Jeremy wrote:
Two counter-examples
1) CHS numbers sectors starting from 1, not 0.
Ah, those were the days, writing drivers for RK-11s etc...
2) Pr1meOS was written in Fortran.
Ironic, really, considering that "1" is not prime :-)
--
Dave Horsfall DTM (VK2KFU) "Those who don't understand security will
suffer."
3:53 p.m.
Original PR1MEOS was a weird beast. Not just Fortran, but FortranIV which
is beyond the array index issues is far from a language I'd want to have to
build a lot of low level contructs in. No structured aspects of it at all
(indeed, this was the impetus for RATFOR, though I don't think Prime ever
saw it). They didn't stay with Fortran long. They wrote their own PL/1
variant called PL/P a scheme also implemented at UNIVAC (PLUS) and IBM
(PL/S). I would venture that C was the only systems implementation
language that made the leap into a general purpose language.
2719
days inactive
2720
days old
25 comments
16 participants
participants (16)
-
ARJANEN Loïc Jean David -
arnold＠skeeve.com -
Arthur Krewat -
Bakul Shah -
Christian Neukirchen -
Clem Cole -
Dave Horsfall -
Lyndon Nerenberg -
Michael Kjörling -
Peter Jeremy -
Random832 -
Robert Swierczek -
Ron Natalie -
shawn wilson -
Tim Bradshaw -
Tony Finch