Ruby also provides arr[-1], arr[-2], etc. But there's a subtle difference when I read arr.last vs. arr[-1].
Makes sense to me.
Me too.
But: when I see code that refers to first and last, I expect that the first and last elements are special.
When I see integers, it leads me to think that all of the elements are about equally important.
I also find it easier to read the text form rather than the integers; I don't have to look carefully to see if it's 1, 11, 7; code reading goes more smoothly.
Having both forms allows me to express, and parse, intention better.
Yet another programmer/techy and ordinary person divide.
0-based indexing is noob friendly because most cs algorithms use it so you can do a straightforward translation. Would it be better to go with 1-based and make this harder for novice programmers? I don't think so.
I don't think anyone finds Lisp's car and cdr (much less cadr and friends) particularly intuitive when they are first introduced to whichever dialect it happens to be.
You get used to it, and when needed, write specific-case functions for readability that are simple wrappers to those combo functions. Which I think is probably best no matter whether you have last or [-1], this argument is kind of pointless. Step back and think about why you need that item, write a small wrapper function to grab that it and name the wrapper well so it provides a little semantic context to whoever ends up reading the code later.
Don't take this as hostile. Rather as an observation of the shifted expectations of programmer subculture.
So a cryptic negative index counts as "elegant?" Wouldn't it be more straightforward just to ask a list for "last?"
Here's the equivalent Smalltalk:
In Ruby: Laypeople would have an immediate inkling of either. The negative array index stuff would cause at least some python prompt exploration or the shift to some sort of reference.