De Pascal, C y C++ a entender cómo piensa una máquina

Después de BASIC llegó otra etapa: la de empezar a programar con más estructura.

BASIC me había enseñado a perder el miedo. A escribir, probar, equivocarme y volver a intentarlo. Pero con el tiempo aparecieron otros lenguajes que me obligaron a pensar de otra manera.

Pascal, C y C++ no eran solo “más lenguajes”. Para mí fueron una forma distinta de acercarme a la máquina.

Con ellos empecé a entender mejor conceptos que hoy parecen básicos, pero que entonces te cambiaban la cabeza: tipos de datos, memoria, compilación, estructuras, funciones, librerías, punteros, módulos, errores de compilador y una sensación muy clara de que el ordenador hacía exactamente lo que le pedías, no lo que tú creías que le estabas pidiendo.

Pascal: aprender a ordenar la cabeza

Pascal me enseñó estructura.

Después de los primeros pasos con BASIC, donde muchas veces aprendías a base de saltos, pruebas y apaños, Pascal obligaba a escribir de una forma más ordenada.

Había que declarar variables, pensar tipos, separar bloques, crear procedimientos y funciones, organizar el programa y evitar que todo se convirtiera en una madeja difícil de seguir.

Eso tenía mucho valor.

Porque programar no es solo conseguir que algo funcione una vez. También es conseguir que puedas volver a leerlo, entenderlo y modificarlo sin miedo.

Pascal me ayudó a ver que la claridad también era parte de la técnica.

C: más cerca del sistema

Con C la sensación era distinta.

Era un lenguaje más seco, más directo y más cercano al sistema. Te daba mucho control, pero también te dejaba equivocarte con mucha facilidad.

Ahí empezabas a entender de verdad que la memoria no era una idea abstracta.

Un puntero mal usado, una cadena mal terminada, un buffer mal calculado o una variable sin inicializar podían convertir un programa sencillo en un problema difícil de encontrar.

Eso podía desesperar, pero también enseñaba muchísimo.

C me hizo más consciente de que debajo de cualquier aplicación hay memoria, direcciones, estructuras, llamadas, librerías y una relación bastante directa con el sistema operativo.

También me ayudó a entender mejor por qué ciertas cosas fallan de formas aparentemente raras.

C++: potencia y complejidad

C++ añadía otra capa.

Objetos, clases, métodos, constructores, destructores, herencia, encapsulación y una forma más rica —y también más compleja— de organizar programas.

La promesa era atractiva: escribir software más estructurado, reutilizable y mantenible.

Pero también aprendías que más potencia no siempre significa más sencillez.

C++ podía ayudarte mucho si entendías lo que hacías. Pero también podía complicarlo todo si lo usabas sin criterio.

Eso me dejó una lección que sigo aplicando hoy: una herramienta potente no sustituye al entendimiento.

Arquitectura, chips y lo que hay debajo

Durante esa época también me interesó mucho la arquitectura de computadores.

No solo el lenguaje, sino la máquina que había debajo: CPU, registros, buses, memoria, instrucciones, interrupciones, puertos, placas, controladoras y cómo todas esas piezas acababan ejecutando un programa.

Entender algo de arquitectura te cambia la forma de mirar el software.

Dejas de pensar que un programa flota en el aire. Empiezas a verlo como algo que vive sobre hardware real, con límites reales.

Memoria, disco, procesador, entrada/salida, comunicaciones, rendimiento y errores físicos.

Todo cuenta.

Compilar también enseñaba

Hoy muchas herramientas esconden casi todo.

Pero en aquella época compilar era parte del aprendizaje.

El compilador te enseñaba a golpes: errores de sintaxis, tipos incompatibles, librerías que faltaban, símbolos no encontrados, dependencias, rutas, opciones, warnings que al principio ignorabas y luego aprendías a respetar.

Ese proceso también formaba criterio.

Te hacía entender que entre escribir código y tener un ejecutable hay un camino. Y que ese camino puede fallar.

Con el tiempo, esa idea aparece en muchas otras cosas: despliegues, contenedores, pipelines, dependencias, versiones, compilaciones, builds y entornos.

Cambian los nombres, pero la lógica se parece.

Lo que me dejó esa etapa

Pascal me dio orden.

C me acercó al sistema.

C++ me enseñó potencia, abstracción y complejidad.

Y la arquitectura de computadores me recordó que la tecnología no empieza en la interfaz. Empieza mucho más abajo.

Todo eso sigue presente en mi forma de trabajar.

Cuando hoy miro un contenedor, una aplicación, una integración, un problema de rendimiento o una incidencia rara, sigo pensando en capas: qué se ejecuta, dónde, con qué permisos, sobre qué sistema, con qué dependencias y qué puede fallar.

Porque aprender lenguajes no va solo de acumular sintaxis.

Va de aprender a pensar.

Fuentes y contexto histórico

• Pascal programming language — contexto histórico
• C programming language — contexto histórico
• C++ — contexto histórico