Some questions on Slate syntax

[David Hopwood]

Shaping wrote:
> 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
being indexed:

   0   1   2   3   4
   +---+---+---+---+
   |   |   |XXX|   |
   +---+---+---+---+

   <---2--->


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|   |
   +---+---+---+---+

   <-1->
   <-----3----->


[*] 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>