Some questions on Slate syntax
david.nospam.hopwood at blueyonder.co.uk
Sun Mar 27 07:08:21 PST 2005
> Lee Salzman wrote:
>> The whole "0-based" vs. "1-based" thing is misleading. When you are
>> talking about "at:", you are locating some item in space by a
>> coordinate - addressing. Memory is a spatial thing. Counting is just a
>> different idiom entirely - searching. The thinking is, "I want that
>> thing, there!", as opposed to, "Hmm, that's not what I want. Not that
>> either. Oh, this one!"
> Discrete, /ordered/ items are countable. Counting starts at 1.
> Fundamentally, this issue is about naming a thing with a number
> representing its /place/ in an ordered sequence.
Yes, I agree that spatial metaphors are most appropriate for arrays
and indexing. Think of the index as corresponding to a distance from
the start of the sequence, and as pointing to the left [*] of the item
0 1 2 3 4
| | |XXX| |
For intervals, use the half-open convention and think of the bounds
as being the left and right sides of the bounded interval, e.g. for
the interval [1,3):
0 1 2 3 4
| |XXX|XXX| |
[*] for people used to left-to-right languages.
> Order and counting both start at 1.
Natural numbers start at 0.
Bill Sun wrote:
> Furthermore, when counting, of course it would start at the first
> natural number.
which is 0. You're probably thinking of "ordinal numbers".
> With arrays, we often find ourselves iterating over them. So it
> seems natural to refer to the n-th element in the array as...well,
> the n-th element.
There's nothing "natural" about either way (the technical meaning
of "natural number" notwithstanding); they're just conventions.
If you're used to the 0-based convention, then you think of the element
at 0-based index n as being element n, and don't think about the
"n-th element" at all.
> I guess this is why Smalltalk took the 1-based array approach. As
> it is designed to be a high-level language that is more natural for
> humans to interact with. I believe when C adopted 0-based arrays,
> it was because it was faster, as memory locations starts from 0.
C just followed the convention that had been established by Algol,
Pascal, and assembly languages. (0-based indexing is also simpler in
languages that support pointer arithmetic.)
I don't think this has much to do with performance: Fortran, which has
a stronger performance emphasis than C, uses 1-based indexing. Also
it's possible to eliminate almost all of the performance difference in
the language implementation by subtracting one element from the base
pointer for each array.
David Hopwood <david.nospam.hopwood at blueyonder.co.uk>
More information about the Slate