I like to think of it like this:

For 0 based indexing the punctuation is the indexes/offsets:

  [    a    ,    b     ,    c    ]
  0         1          2         3

for 1 based indexing consider the actual elements are the indexes/positions:

  [    a    ,    b     ,    c    ]
       1         2          3

In the first case it is non inclusive, ie.

  elements[0:3] - all items between offset 0 and 3

The second case is inclusive, ie.

  elements[1:3] - all items including 1 and 3

Personally I don't have an issue with either, they both 'make sense'

Where they stop making sense is when you'd mix up the inclusivity ie (for the second case).

  elements[1:4] - including item 1 not including 4

In C it also helps to think of it in the equivalent pointer form:

   p == &(p[0])
   p[0] == *(p+0)
   p[1] == *(p+1)

where p is a pointer to some arbitrary data type. Then it becomes an offset in memory.

Thanks for saying this :) It's things like these that I'd wish people would tell sooner rather than later.

Why didn't you born sooner? :D

I think this would help a lot for people learning computer systems as well. Matches the underlying pointer arithmetic logic. Let's all agree to switch to using offset instead of index?

Wow. Everything just changed.

That indeed is a very good way to phrase the core of the problem for non-mathematicians, thanks :-)