Q:

¿Por qué en ciertos lenguajes de programación el primer índice de las colecciones de datos es el 1?

En general estamos acostumbrados a ver que los objetos de tipo colección, hablo de listas, arreglos, matrices, recordsets, o como se denominen en cualquier lenguaje, se "indizan" a partir de la posición 0. Sin embargo, en R, por alguna decisión de diseño, cualquier objeto (de hecho en R no hay objetos escalares) se "indizan" a partir del 1.
> vector <- c(1,2,3)
> vector[1]
[1] 1
> vector[0]
numeric(0)

Históricamente hablando ¿Qué motivó esta decisión? ¿Tiene alguna ventaja en particular sobre la "indización" a partir del 0?

A:

En este tema en particular es donde es bien clara la diferencia entre el concepto de "lenguajes orientados a la maquina" y los "lenguajes orientados a los humanos". claro que es algo arbitrario, por que todos los lenguajes están orientados a satisfacer la necesidad de los humanos para comunicarnos con las maquinas, sin embargo, la decisión de comenzar los índices en 0 o en 1, claramente tiene que ver con esto. Vayamos por partes:
¿Porqué comenzar desde 0?
Sin duda esto tiene una relación directa en como se accede a áreas contiguas de la memoria física de un maquina, suponiendo un objeto de n elementos, cada uno del mismo tamaño, el acceso a cada porción de memoria que le toca a cada elemento se hace teniendo en cuenta la dirección de memoria inicial más un desplazamiento de un puntero en el área y la longitud de cada elemento en memoria, pero para acceder al primero, no queda otra que el desplazamiento sea 0. Suponiendo tener un array de elementos de un tamaño fijo de 8 bytes, que sabemos que comienzan en una posición absoluta 689000, el acceso a cada elemento utilizando un índice de base 0 es sumamente transparente:
+----------+----------+----------------+----------------------+
| Longitud | Elemento | Desplazamiento | Posición absoluta    |
+----------+----------+----------------+----------------------+
| 8        | 1        | 0              | 689000 + (8 * 0)     |
+----------+----------+----------------+----------------------+
| 8        | 2        | 1              | 689000 + (8 * 1)     |
+----------+----------+----------------+----------------------+
| 8        | n        | n - 1          | 689000 + (8 * n - 1) |
+----------+----------+----------------+----------------------+

Esta es la mecánica de la mayoría de los lenguajes actuales, sin duda el que popularizó esto fue C, pero ciertamente hubo  lenguajes anteriores que usaban esta metodología (Caso BCPL) y los que vinieron después de él, la reusaron, podemos apreciar una lista más completa aquí.

Es claro que esta forma es cómoda, simple y rápida. Pero a no
confundirse, la rapidez no radica en la velocidad de ejecución, el
código de maquina final siempre accede a la memoria con el
desplazamiento basado en 0, la razón de esto es más bien producto de
una coyuntura histórica (ver Blarg?), en las primeras épocas,
dónde no existía la multitarea, dónde los compiladores no tenían que reservar memoria con malloc() (C era solo una letra del abecedario), ni siquiera existía el concepto de puntero y las velocidades de cómputo no eran
las de hoy, se tenía ventanas de tiempo para cargar/compilar/ejecutar
muy limitadas, en este contexto, evitar que el compilador haga indice - 1 por
cada instrucción de acceso a un array, fue una decisión práctica y
razonable. Resumiendo: Tiempo de compilación No de ejecución

¿Y entonces ...? ¿Porqué comenzar desde 1?
Ciertamente en muchas disciplinas de la Matemática, hablar del primer elemento de una matriz o vector es hablar de elemento 1, de hecho en nuestra vida real cualquier primer elemento de algo es el 1. De ahí que esta abstracción, si bien agrega una complejidad computacional al tener que hacer  indice - 1, resulta mucho más natural, en particular para humanos no necesariamente programadores.
Retomando el caso de R, este lenguaje nace de otro más antiguo llamado S el cual a su vez, estuvo fuertemente influenciado por el "papá" de todos los lenguajes: FORTAN. Y este particularmente, un lenguaje orientado a la matemática, igual que  R (estadística en particular) usa por defecto  1 como base de toda colección de datos (en realidad se pueden usar índices arbitrarios también). La ventaja que tiene esto es que resulta mucho más transparente de entender y de manejar arreglos, vectores, matrices, etc, para cualquier humano en general, y particularmente a los que vienen de disciplinas matemáticas, no les exige, ninguna traducción al respecto, a la hora de trasladar formulas al lenguaje en sí.
Curiosidades de R
Sorprendentemente, es posible modificar la forma de acceder a los elementos de una modalidad basada en 1 a una basada en 0, de manera global, podemos sobreescribir la función de selección por índice:
index1 <- .Primitive('[')
`[` <- function(v, i) index1(v, i+1)

vector <- c(1,2,3)
vector[0]
[1] 1
vector[2]
[1] 3

Referencias

Zero based arrays/vectors in R
Why do R (programming language) vectors and MATLAB/Octave arrays start in 1 instead of 0 like many other programming languages?

