Notas sobre apuntadores, memoria y referencias.

En el principio era la nada.

Luego, en algún punto de la década de los cincuentas del siglo XX, una matemática soviética establece los fundamentos teóricos de la programación de sistemas informáticos en base a referencias de memoria. Aproximadamente una década después otro investigador sugiere una metodología similar en los Estados Unidos; entre ambos establecen el origen de uno de los elementos de programación que ha aterrado más a los programadores de finales del siglo XX, y sigue subyaciendo en las pesadillas del siglo XXI: los apuntadores, o punteros, o pointers en inglés.

Quizás la más famosa de las implementaciones de la aritmética de apuntadores se establece en el lenguaje de programación C. En ese lenguaje el manejo de los apuntadores es explícito en la sintaxis del mismo, es decir, que existen elementos lexicográficos claros para su manipulación, C++ mantiene ese manejo explícito, sin embargo, pocos lenguajes mantienen un manejo tan claro de los mismos, y eso ha sido terreno fértil para la confusión.

Bases teóricas.

Antes de ir más allá, vamos a establecer algunos términos indispensables para poder seguir adelante:

• bit o "dígito binario", que es 0 o 1, verdadero o falso, el todo o la nada, o sea, la unidad mínima de información que se puede almacenar dentro de una computadora digital.
• byte o "palabra lógica", que es un grupo de 8 bits, que no siempre ha sido así a lo largo de la historia, y que puede representar un número decimal entre 0 y 255 (o sea, 256 valores posibles). Tradicionalmente, un byte podía almacenar una letra legible al humano, como una "A", "b", "1", o "ñ". En nuestro contexto esta información es irrelevante.
• Memoria, que es el lugar donde las computadoras almacenan información. La memoria está compuesta por (actualmente) miles de millones de casillas individuales, cada una de las cuales puede almacenar solamente un byte.
  
•  Apuntador, puntero o pointer, que es un número entero que indica la posición en la memoria (la cinta enorme donde las computadoras digitales escriben toda su información) de una casilla en específico en la memoria. En el argot, se le suele representar como un valor hexadecimal: 0x00F8B310, que representaría a la 16'298,768-va casilla de memoria (algún punto después de los 16 megabytes). Un dato importante es que el puntero hace referencia al inicio de donde se guarda el valor.
  

Una vez definido lo anterior, vamos a retomar el concepto de la memoria de la computadora, que al final es el espacio de trabajo de donde el procesador va a leer el trabajo a realizar (programa), la información con la cual realizarlo (datos) y en donde va a almacenar el resultado obtenido. Cabe señalarse aquí que en términos teóricos es indistinto que la memoria se almacene de manera volátil, o permanente: en ambos casos la memoria sigue siendo una cinta enorme, dividida en casillas del mismo tamaño, que pueden ser referenciadas a través de un número entero.

Cuando almacenamos información en la memoria, por ejemplo, al asignarle el valor a una variable, la computadora intentará hacer lo siguiente:

1. Evaluar el número de casillas necesarias para guardar la información, según el tipo de dato especificado
   
2. Buscar una posición disponible en la cinta con las casillas contiguas necesarias para guardar la información.
3. Escribir, uno por uno, los bytes de información en cada una de las casillas, leídos desde un espacio temporal de trabajo.
   
4. Guardar la posición de la primera casilla en la cual guardó la información.

Si lo anterior tuvo éxito, podremos usar esa variable para hacer referencia al valor guardado, ahora bien, para leer el valor de una variable, los pasos serían los siguientes:

1. Ubicar el punto de lectura en la posición de memoria a la que hace referencia esa variable.
2. Evaluar el número de casillas según el tipo de dato.
3. Abrir un espacio en el área de trabajo para poner el valor.
4. Copiar los bytes contenidos en las casillas al área de trabajo.

Y por último, cuando modificamos los valores, simplemente vuelve a escribir en las casillas a las que hace referencia esa variable. Bueno, pues esa referencia es como tal un apuntador o puntero.

¿Qué pasa si no hay casillas suficientes en la memoria? pues vamos a tener un error de Out of memory o memoria insuficiente; ¿qué pasa, en cambio, si queremos escribir más bytes que casillas disponibles en la variable? lo más posible es que perdamos información, o que tengamos una señal de aborto de ejecución (SIGABRT en el estándar POSIX). Así mismo, si la variable hace referencia a una posición de memoria fuera  del ámbito de nuestro programa, vamos a tener una señal de segmentación (SIGSEGV en el estándar POSIX).

La pregunta clave entonces ¿Qué guardaste (el valor) y en dónde lo guardaste (el apuntador)?

Más allá de los básicos

Antes de seguir adelante, es necesario diferenciar la "naturaleza" de los tipos de datos que los lenguajes de programación nos dejan manipular. Cabe aquí una importante aclaración: internamente TODOS los tipos de datos son en realidad bytes (números entre 0 y 255 en decimal, 0x00 al 0xFF) organizados en casillas de memoria; sin embargo, los lenguajes de programación hacen una abstracción de ésto generando "tipos" de datos, como enteros, letras, cadenas de texto, o incluso estructuras, instancias de objetos y una larga lista de etcéteras.

Sin embargo, en este texto nos vamos a enfocar en dos naturalezas básicas: tipos primitivos y tipos complejos.

• Tipos primitivos son los que típicamente se relacionan con datos que son representables directamente en bytes, como enteros, o letras: ambos se pueden guardar en la memoria en sus representaciones binarias.
• Tipos complejos son, en cambio, aquellos tipos que requieren una interpretación posterior para volverse valores útiles, como por ejemplo, una cadena de caracteres (string), una estructura de datos (struct), o referencias a objetos.

A ambos tipos se pueden hacer apuntadores, sin embargo, los tipos primitivos pueden ser valores manipulados directamente, mientras que los tipos complejos van a ser manipulados preferentemente a través de un apuntador, y esto es especialmente relevante cuando hablamos de mandar valores a funciones.

Cuando invocamos una función con parámetros, y esos parámetros son variables de tipos primitivos, lo más probable es que la computadora haga una copia del valor a manejar, y esa copia sea con la que trabaje la función. Sin embargo, cuando son tipos complejos, puede ser que intente enviar una referencia de dónde está almacenada la información necesaria.

Lenguajes donde el manejo de apuntadores es explícito nos permiten decidir qué hacer al momento de invocar las funciones, pudiendo elegir entre si enviar copias de los valores, o referencias a los mismos, pero lenguajes modernos como Javascript lo van a decidir automáticamente. PHP, en cambio, está un poco en medio de ambos.

Por último, es  importante recordar que para una computadora, no solamente lo que nosotros entendemos por "valores" son valores, sino que también los programas están expresados en una serie de números que representan instrucciones al procesador. O sea, al final TODO son números, entre 0 y 255...

¿Javascript y apuntadores?

Debido a que es un lenguaje muy usado actualmente, y que además tiene una sintaxis muy dependiente de apuntadores, a la par que oscura al respecto, vamos a hablar a detalle aquí de cómo se implementan.

Lo primero a considerar es que Javascript es un lenguaje de tipo flexible o dinámico, es decir, que no es necesario decir qué tipo de valor vamos a almacenar en una variable o parámetro al momento de declararlo, haciendo que sea especialmente oscura su manipulación.

Lo siguiente es mencionar que, dada su orientación a objetos, es también fuertemente codependiente del uso de apuntadores, pero no tiene ningún tipo de manejo explícito al respecto, lo cual, una vez más, lo vuelve especialmente oscuro.

En términos generales, sin embargo, podemos pensar que todo aquello que es reducible a un tipo primitivo (básicamente los enteros y los flotantes, y forzadamente las cadenas de caracteres) se manejan como copias de valores, mientras que todo aquello que resulta ser una instancia de algo (arreglos y objetos) son manejados como referencias.

Eso nos importa por que quiere decir que podemos tener una variable conteniendo un entero, enviarla a una función, cambiar el valor dentro de esa función, y al retornar al contexto original su valor no debería de haber cambiado. Sin embargo, si tenemos un objeto que es enviado a una función, cambiamos alguna de las propiedades de ese objeto en la función, al regresar al contexto original, ese valor cambió. Saber ésto es fundamental.

Otra nota relevante es que podemos declarar un arreglo como constante, y modificar los valores del arreglo sin problemas, ya que lo que se vuelve constante es la ubicación en memoria a donde está almacenado el inicio del arreglo, pero no los valores contenidos. Lo mismo sucede con las instancias de los objetos: una variable que haga referencia a una instancia de objeto, puede ser considerada como constante, pues mientras no se cambie la referencia en memoria de la instancia, no va a ocasionar ningún problema, sin embargo, si sobre esa constante intentamos crear una nueva instancia (usando "new") entonces dará problemas.

Usar constantes es importante en lenguajes interpretados por que permiten que se haga una optimización del uso de la memoria, haciendo nuestros programas más ligeros y eficientes.

Conclusiones.

Para más referencias, recomiendo la lectura de "El lenguaje de programación C" de Kernigan y Ritchie, y para adentrarse un poco de manera amigable al funcionamiento de las computadoras de cálculo general "La nueva mente del emperador" de Roger Penrose

Por mucho que nos digan que los lenguajes de programación avanzan, en el fondo todos mantienen principios teóricos similares y es importante poder relacionarlos con nuestro trabajo del día a día. La correcta comprensión de la memoria es vital a la hora de planificar la ejecución de una tarea y el cómo vamos a manejar la información durante ese desarrollo.

Si bien es cierto, la tendencia se inclina por oscurecer y alejar a los programadores nóveles de estos conceptos, por considerarlos "demasiado complejos" para ellos, no quiere decir que sea positivo para el desarrollo de sus carreras que se mantengan ignorantes al respecto, sino que más bien los tornan idiots savants de un oficio altamente complejo.