Programación · Conceptos · Compilador

¿Qué es un compilador?

Escribes un programa en un lenguaje que sabes leer: palabras, sangría, nombres con sentido. El procesador de tu máquina no entiende nada de eso — ejecuta instrucciones binarias en crudo. La herramienta que tiende el puente es el compilador. Esta guía explica qué es un compilador, las etapas por las que pasa, en qué se diferencia de un intérprete, y dónde encaja un compilador como GHC cuando escribes Haskell.

La definición corta

Un compilador es un programa que traduce código fuente escrito en un lenguaje a otra forma — normalmente el código máquina que un ordenador puede ejecutar directamente. Le entregas los archivos de texto que escribiste y produce un ejecutable (o un formato intermedio) que la máquina, o un runtime, puede ejecutar. La traducción ocurre una vez, por adelantado, y el resultado se ejecuta solo, sin que el compilador esté presente.

Cómo funciona un compilador, paso a paso

Un compilador no traduce de un solo salto. Recorre una cadena de etapas, cada una pasando su resultado a la siguiente:

• Análisis léxico (tokenización): el texto fuente se divide en pequeñas unidades — palabras clave, nombres, números, símbolos — llamadas tokens.
• Análisis sintáctico: los tokens se organizan en un árbol que refleja la estructura del programa, según la gramática del lenguaje.
• Análisis semántico: el compilador comprueba que el programa tenga sentido — nombres definidos, tipos coherentes, reglas del lenguaje respetadas. Aquí se detectan muchos de tus errores.
• Optimización: el compilador reescribe el programa en un equivalente más rápido o más pequeño sin cambiar lo que hace.
• Generación de código: finalmente emite la salida objetivo — código máquina, o una representación intermedia que otra herramienta terminará.

Si alguna etapa encuentra un problema, obtienes un error de compilación y no se produce ningún programa. Ese es el trato del compilador: se niega a construir código roto, así que toda una clase de errores se atrapa antes de que el programa siquiera se ejecute.

Compilador vs intérprete

El otro enfoque común es el intérprete, que lee tu código fuente y lo ejecuta directamente, línea por línea, cada vez que el programa corre — no se construye ningún ejecutable por adelantado. Un compilador traduce todo el programa una vez, al inicio, a una forma que la máquina ejecuta sola.

La diferencia práctica: los programas compilados suelen arrancar y correr más rápido, porque la traducción y la optimización ya ocurrieron, y los errores aparecen en tiempo de compilación. Los programas interpretados son más rápidos de probar y más flexibles, pero rehacen el trabajo de traducción en cada ejecución. Muchas cadenas de herramientas reales mezclan ambos — compilan a una forma intermedia y luego la ejecutan en una máquina virtual.

Dónde encajan GHC y Haskell

Cuando escribes Haskell, el compilador que usas es GHC (el Glasgow Haskell Compiler). Lee tus archivos fuente .hs, los comprueba de tipos a fondo, optimiza el resultado y produce un ejecutable nativo que puedes correr solo. El sistema de tipos fuerte de Haskell hace que la etapa de análisis semántico de GHC trabaje mucho por ti: muchos bugs se reportan como errores de compilación en lugar de fallar en tiempo de ejecución. Para el recorrido completo de su uso, mira nuestra guía del compilador GHC y cómo instalar Haskell con GHCup.

Los comandos que realmente te encuentras

• Compilar un solo archivo: una herramienta como ghc Main.hs lee tu fuente y produce un ejecutable.
• Construir un proyecto: herramientas de build como Cabal o Stack dirigen el compilador a través de muchos archivos y dependencias por ti.
• Comprobar tipos sin build completo: muchos compiladores ofrecen un modo más rápido que busca errores sin emitir un binario.

La mayoría de las veces no llamas al compilador a mano — tu herramienta de build o tu editor lo hace y te muestra los errores. Pero saber qué hace por debajo hace esos errores mucho más fáciles de leer.

Las concesiones honestas

Los compiladores añaden un paso: cambias código, esperas el build, y luego ejecutas. En un proyecto grande esa espera se nota, por eso importan los compiladores rápidos y los builds incrementales. La recompensa es real: errores atrapados pronto, salida optimizada y un único ejecutable que puedes distribuir sin distribuir tu cadena de herramientas. Para un lenguaje fuertemente tipado como Haskell, esa comprobación por adelantado es gran parte del atractivo — el compilador es una red de seguridad, no solo un traductor.

Preguntas frecuentes

Explora más explicaciones claras en nuestro índice de guías.