• Las gramáticas sirven para reconocer o producir frases correctas en un determinado lenguaje.

• Por ejemplo, podemos preguntarnos si la frase «el niño grande come mucho.» es sintácticamente correcta según la gramática anterior.

• Para ello, comprobamos si es posible derivar esa frase a partir de las producciones de la gramática, partiendo del símbolo inicial, que siempre es el primer símbolo no terminal que aparece en la gramática (en este caso, ⟨frases⟩).

• Cada paso del procedimiento se llama derivación, y consiste en ir sustituyendo, de izquierda a derecha, los símbolos no terminales que vayamos encontrando por su correspondiente definición (lo que hay a la derecha del ::= ).

• Iremos avanzando mientras encontremos símbolos terminales que coincidan con los de la frase.

• El procedimiento finalizará con éxito cuando se acabe la frase, o con fracaso si algún símbolo terminal no coincide con el esperado.

• En este caso:

  ⟨frases⟩
  \Rightarrow ⟨frase⟩ .
  \Rightarrow ⟨sujeto⟩ ⟨predicado⟩ .
  \Rightarrow ⟨artículo⟩ ⟨sustantivo⟩ ⟨adjetivo⟩^+ ⟨predicado⟩ .
  \Rightarrow el ⟨sustantivo⟩ ⟨adjetivo⟩^+ ⟨predicado⟩ .
  \Rightarrow el niño ⟨adjetivo⟩^+ ⟨predicado⟩ .
  \Rightarrow el niño grande ⟨predicado⟩ .
  \Rightarrow el niño grande ⟨verbo⟩ [⟨adverbio⟩] .
  \Rightarrow el niño grande come [⟨adverbio⟩] .
  \Rightarrow el niño grande come mucho .

• El procedimiento ha tenido éxito, por lo que podemos afirmar que la gramática ha reconocido la frase, o que la frase satisface la gramática o que cumple con la gramática.

• Eso se expresa diciendo que:

⟨frases⟩ \stackrel{\ast}{\Rightarrow} el niño grande come mucho .

• Otra forma de representarlo es mediante un diagrama llamado árbol de análisis sintáctico.

2. ¿Qué frases genera (o reconoce) la siguiente gramática? Poner ejemplos:

   ⟨expresión⟩ ::= ⟨átomo⟩ | ⟨lista⟩
   ⟨átomo⟩ ::= ⟨número⟩ | ⟨símbolo⟩
   ⟨lista⟩ ::= ( ⟨expresión⟩* )
   ⟨número⟩ ::= [+ | -] ⟨dígito⟩^+
   ⟨símbolo⟩ ::= ⟨letra⟩^+
   ⟨dígito⟩ ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
   ⟨letra⟩ ::= a | b | … | z

• Por ejemplo:

  • Comprobar que los tipos de los datos a operar son los correctos:

    Si intentamos hacer 4 + 'hola', sintácticamente puede ser correcto pero no tiene sentido sumar una cadena a un número.

  • Comprobar que un nombre está ligado a un valor antes de usarlo en una expresión.

    Sintácticamente puede ser correcto hacer 4 + x, pero si no se sabe qué es x, el programa no puede realizar la operación.

  • Comprobar que el número y tipo de argumentos en la llamada a una función coincide con el número y tipo de parámetros de la función.

    Si se quiere calcular el coseno de 24 se puede hacer cos(24), pero no tiene sentido hacer cos(24, 35) (se llama a la función con dos argumentos en vez de uno) o cos('hola') (se la llama con una cadena en lugar de un número).

• En el ejemplo que vimos de los niños y las vacas, hemos encontrado frases sintácticamente correctas según la gramática pero que no son completamente correctas o lógicas.

• Por ejemplo, la frase «la niño grande salta poco.» es sintácticamente correcta (podemos derivarla a partir del símbolo inicial de la gramática), pero sabemos que no es completamente correcta porque no hay concordancia de género entre el artículo la y el sustantivo niño.

• Ese error de concordancia es un error de semántica estática.

• 1890: Máquinas tabuladoras electromecánicas (Herman Hollerith, Tabulating Machine Company)

  • Hollerith está considerado el primer informático de la historia, por crear las primeras máquinas de procesamiento automático de la información.
  • Con ellas se creó el censo de los EE.UU.
  • Su empresa acabó llamándose IBM.

• 1936: El gran año de los modelos formales computacionales:

  • Cálculo lambda (Alonzo Church)

    • Un modelo universal de computación basado en la abstracción y aplicación de funciones.

  • Máquinas de Turing (Alan Turing)

    • Un modelo universal de computación basado en máquinas abstractas que manipulan símbolos escritos en una cinta de acuerdo a una serie de reglas definidas.

  • Sorpresa: ambos modelos son equivalentes.

• El trabajo de Konrad Zuse:

  • 1941: Ordenador Z3

    • El primer ordenador digital programable que realmente llegó a funcionar.

    • Por ello, Zuse es considerado el inventor del ordenador moderno.

  • 1945: Ordenador Z4

    • El primer ordenador digital comercial del mundo.

    • Se vendió a varias universidades.

  • 1948: Plankalkül

    • Considerado el primer lenguaje de programación.

    • Diseñado, pero no implantado en su época.

• (Hasta aquí): Todo se programa en lenguaje máquina

• 1949: Lenguaje ensamblador (EDSAC)

• Primeros Autocódigos:

  • 1952: Autocódigo de Glennie (Alick Glennie, Universidad de Manchester)

  • 1955: Autocódigo del Mark 1 (Ralph Anthony Brooker, Universidad de Manchester)

• 1957: Fortran (John Backus, IBM)

  • El primer lenguaje de alto nivel de propósito general de uso masivo en tener una implementación funcional.

• 1958: LISP (John McCarthy, Instituto de Tecnología de Massachusetts)

  • Basado en el cálculo lambda.

  • Destinado al procesamiento simbólico y a la investigación en Inteligencia Artificial.

• 1958 – 1960: Familia de lenguajes ALGOL (Backus, Naur, Wijngaarden, Bauer, Perlis, McCarthy y otros):

  • 1958: ALGOL 58

    • Introdujo el concepto de bloque de código (sentencia compuesta).

  • 1960: ALGOL 60

    • Influyó mucho en lenguajes posteriores.

    • Introdujo las funciones anidadas y el ámbito léxico.

• 1959: FLOW-MATIC (Grace Hopper, Remington Rand)

  • El primer lenguaje de alto nivel orientado a las aplicaciones de gestión.

  • El primero en usar sentencias y palabras en inglés.

• 1960: COBOL (Grace Hopper, Comisión CODASYL y Departamento de Defensa de los EE.UU.)

  • Inspirado en FLOW-MATIC.

• 1962: Simula (Ole-Johan Dahl y Kristen Nygaard, Norwegian Computer Center)

  • Considerado el primer lenguaje orientado a objetos.

• 1970: Pascal (Niklaus Wirth)

  • Lenguaje imperativo, procedimental, estructurado, pequeño, eficiente, heredero del ALGOL 60.

  • Muy usado en la enseñanza de la programación.

• 1972: Prolog (Alain Colmerauer, Universidad de Marsella)

  • El primer lenguaje de programación lógica.

• 1972: C (Dennis Ritchie, Laboratorios Bell)

  • Lenguaje de nivel medio (de alto nivel pero con acceso directo a la máquina y al sistema operativo).

  • Lenguaje de sistemas

• 1975: Scheme (Gerald Jay Sussman, Guy L. Steele, Jr., MIT)

  • Lenguaje funcional basado en LISP con ámbito léxico.

• 1978: ML (Robin Milner, Universidad de Edimburgo)

  • Lenguaje de programación funcional con sistema de tipos estático y polimórfico.

  • En realidad es una familia de lenguajes, entre los que se encuentran Standard ML, OCaml o F#.

• 1980: Smalltalk (Alan Kay, Adele Goldberg, Xerox PARC)

  • Lenguaje orientado a objetos puro, reflexivo, con tipado dinámico, con un entorno propio de desarrollo y ejecución.

• 1985: C++ (Bjarne Stroustrup, Laboratorios Bell)

  • Extensión orientada a objetos del lenguaje C.

• 1990: Haskell (Simon Peyton Jones, Paul Hudak, Philip Wadler y otros)

  • Lenguaje funcional puro con evaluación no estricta y sistema de tipos polimórfico y fuertemente tipado.

• 1991: Python (Guido Van Rossum, CWI de Holanda)

  • Lenguaje multiparadigma interpretado, dinámico y multiplataforma.

• 1995: Un año especialmente destacable:

  • Java (James Gosling, Sun Microsystems)

    • Lenguaje orientado a objetos, el más usado en la actualidad.

    • Genera código para una máquina virtual presente en millones de dispositivos en todo el mundo.

  • JavaScript (Brendan Eich, Netscape Communications)

    • Lenguaje multiparadigma, basado en prototipos e interpretado.

    • Usado como lenguaje cliente en los navegadores web.

  • PHP (Rasmus Lerdorf)

    • Lenguaje multiparadigma e interpretado.

    • Usado principalmente como lenguaje de servidor en aplicaciones web.

  • Ruby (Yukihiro Matsumoto)

    • Lenguaje interpretado orientado a objetos puro.

• 2000: C# (Anders Hejlsberg, Microsoft)

  • Lenguaje orientado a objetos para la plataforma .NET.

• 2003: Scala (Martin Odersky, Escuela Politécnica Federal de Lausana, Suiza)

  • Lenguaje multiparadigma (funcional y orientado a objetos) para la máquina virtual de Java.

• Swift, Kotlin, TypeScript, Julia, Go, Rust, Perl 6, Clojure…

• Ejemplos de lenguajes de alto nivel:

  • Fortran
  • LISP
  • COBOL
  • BASIC
  • Pascal
  • C
  • Java

  • Ruby
  • C++
  • Python
  • JavaScript
  • C#
  • PHP
  • Haskell

• El traductor transforma el programa fuente (o código fuente) en el programa objeto (o código objeto).

• El código fuente está escrito en el lenguaje fuente (que generalmente será un lenguaje de alto nivel).

• El código objeto está escrito en el lenguaje objeto (que generalmente será código máquina).

• Durante el proceso de traducción, el traductor también informa al programador de posibles errores en el código fuente.

• Un intérprete está formado por un analizador y un emulador:

  • El analizador traduce todo el código fuente a una representación interna llamada árbol sintáctico (que no hay que confundir con el árbol de análisis sintáctico).

    Ese árbol sintáctico no se vuelca directamente a la salida, sino que es consumida directamente por el emulador.

  • El emulador se encarga de recorrer el árbol sintáctico y de ir ejecutando las instrucciones que éste representa, llevando a cabo las acciones que correspondan dependiendo de la instrucción que sea.

    Para ello, tiene que ir traduciendo sobre la marcha, instrucción por instrucción, las acciones a realizar sobre la máquina abstracta en acciones a realizar sobre la máquina real.

• Programar con un intérprete es una tarea más rápida de realizar que con un compilador, ya que, para poder ejecutar el programa, no hace falta compilar ni generar el código objeto, por lo que se evita dar un paso que en muchos casos puede llegar a consumir mucho tiempo.

• Por la misma razón, a muchos programadores les resulta más cómodo y fluido programar usando un intérprete (aunque con los modernos entornos de desarrollo esto ya no supone tanta diferencia como antes).

• Sin embargo, si el programa fuente tiene errores sintácticos (o ciertos errores de semántica estática), el intérprete no informará de ellos hasta el momento en el que intente ejecutar la instrucción errónea.

  Es decir: esos errores se detectarán y se mostrarán en tiempo de ejecución, no en tiempo de compilación.

• Por tanto, muchos errores que pueden ser detectados por un compilador sólo se podrán detectar cuando ya se esté ejecutando el programa, lo que hace que el coste (en tiempo y dinero) de corregir el error sea mucho mayor.

• Además, los programas interpretados suelen ser varias veces más lentos que los compilados, ya que:

  • hay que ir recorriendo continuamente el árbol sintáctico para encontrarse con las instrucciones que allí aparecen, lo que consume tiempo y memoria;

  • hay que traducir las instrucciones de la máquina abstracta a instrucciones de la máquina real, cosa que no se hace de una vez y para siempre, sino que se va haciendo poco a poco a medida que se va encontrando con una nueva instrucción al recorrer el árbol sintáctico.

• En cambio, un compilador traduce todas las instrucciones de una vez y sólo una vez, de forma que, al ejecutarlas, ya están todas traducidas al lenguaje objeto, formando el código objeto.

• Hay lenguajes compilados y lenguajes interpretados, e incluso lenguajes que son ambas cosas (tienen compiladores e intérpretes).

• Los compiladores son ideales para:

  • Desarrollar aplicaciones que demanden altas prestaciones y que necesiten sacar el máximo rendimiento de la máquina.

  • Acceder a los recursos de la máquina al más bajo nivel.

• Los intérpretes por lotes son ideales para:

  • Desarrollo rápido de aplicaciones.

  • Escribir programas que requieran portabilidad, es decir, que el programa se pueda ejecutar en varias plataformas diferentes.

  • Escribir programas sencillos y rápidos que resuelvan tareas concretas.

• Los intérpretes interactivos son ideales para:

  • Aprender conceptos de programación.

  • Experimentar con el lenguaje.

  • Probar rápidamente el efecto de una instrucción.

• Asimismo, el editor de textos del IDE suele incorporar facilidades que ayudan a escribir código con más comodidad:

  • Resaltado de sintaxis

  • Autocompletado de código

  • Ayudas a la refactorización

• Los IDE suelen ir asociados a un lenguaje o grupo de lenguajes de programación concreto y, por lo tanto, son herramientas especializadas utilizadas para programar en el lenguaje o lenguajes para los que han sido diseñadas. Por ejemplo:

  • PyCharm es un IDE para programar en el lenguaje Python.

  • IntelliJ IDEA es un IDE para programar en el lenguaje Java.