Tarea 4

Compiladores e Interpretes

Compiladores

Un poco de historia...

  1. El primer compilador fue escrito por Grace Hopper en 1952, para el lenguaje de programación A-0.
  2. El equipo FORTRAN dirigido por John W. Backus de IBM esta generalmente acreditado por haber presentado el primer compilador completo.
  3. El compilador COBOL para el UNIVAC II fue probablemente el primero en ser escrito en un lenguaje de alto nivel, llamado FLOW-MATIC, por un equipo dirigido por Grace Hopper.
  4. Los primeros compiladores se realizaron programándolos directamente en lenguaje máquina o en ensamblador. Una vez que se dispone de un compilador, se pueden escribir nuevas versiones del compilador (u otros compiladores distintos) en el lenguaje que compila ese compilador.

Tipos de compiladores:

  • Compiladores Curzados
    • Generan código para un sistema distinto del que están funcionando.
  • Compiladores optimizadores
    • Realizan cambios en el código para mejorar su eficiencia, pero manteniendo la funcionalidad del programa original.
  • Compiladores de una sola pasada
    • Generan el código máquina a partir de una única lectura del código fuente.
  • Compiladores de varias pasadas
    • Necesitan leer el código fuente varias veces antes de poder producir el código máquina.
  • Compiladores JIT (Just In Time):
    • Forman parte de un intérprete y compilan partes del código según se necesitan.
  • Compiladores incrementales
    • Generan un código objeto, instrucción por instrucción cuando el usuario teclea cada orden individual.
  • Compilador con montador
    • Compila distintos módulos de forma independiente y después es capaz de aplazarlos.
  • Auto compilador
    • Compilador que está escrito en el mismo lenguaje que va a compilar.
  • Meta compilador
    • Es programa que recibe como entrada las especificaciones del lenguaje para el que se desea obtener un compilador y genera como salida el compilador para ese lenguaje.
  • Descompilador
    • Es un programa que acepta como entrada código maquina y la traduce a un lenguaje de alto nivel realizando el proceso inverso a la compilación.

Interpretes

Un poco de historia...

El primer interprete que se creo fue el interprete de LISP en 1558 por el estudiante de John McCarthy Steve Russell solo 6 años despues del primer compilador

El caso de LISP es muy especial, porque era un lenguaje extremadamente simple que lo hacía factible la interpretacion (y la computadora se había vuelto un poco más grande en 58 ya que cuando se creo el primer compilador las computadoras eran simples y no tenian mucha memoria , memoria la cual es mas utilizada por un interprete que por un compilador). Más importante aún, el intérprete de LISP fue una prueba de concepto con respecto a la autodefinición de LISP ( meta-circularidad ), independientemente de Cualquier problema de usabilidad.

Tipos de Interpretes:

  • Interpretes puros
    • Los intérpretes puros son los que analizan y ejecutan sentencia a sentencia todo el programa fuente. Siguen el modelo de interpretación iterativa y, por tanto, se utilizan principalmente para lenguajes sencillos.
  • Interpretes avanzados o normales
    • Incorporan un paso previo de análisis de todo el programa fuente. Generando posteriormente un lenguaje intermedio que es ejecutado por ellos mismos. De esta forma en caso de errores sintácticos no pasan de la fase de análisis
  • Interpretes incrementales
    • Existen ciertos lenguajes que, por sus características, no se pueden compilar directamente. La razón es que pueden manejar objetos o funciones que no son conocidos en tiempo de compilación, ya que se crean dinámicamente en tiempo en ejecución. Entre estos lenguajes, pueden considerarse Smalltalk, Lisp o Prolog. Con el propósito de obtener una mayor eficiencia que en la interpretación simple, se diseñan compiladores incrementales. La idea es compilar aquellas partes estáticas del programa en lenguaje fuente, marcando como dinámicas las que no puedan compilarse. Posteriormente, en tiempo de ejecución, el sistema podrá compilar algunas partes dinámicas o recompilar partes dinámicas que hayan sido modificadas. Estos sistemas no producen un código objeto independiente, sino que acompañan el sistema que permite compilar módulos en tiempo de ejecución (run time system) al código objeto generado