Curricula CS-UNI

2.5. Fundamentos de los Lenguajes de Programación (FPL)

Los fundamentos de los lenguajes de programación están enraizados en las matemáticas discretas, la lógica y los lenguajes formales, y proporcionan una base para la comprensión de los complejos lenguajes de programación modernos. Aunque los lenguajes de programación varían según el paradigma del lenguaje y el dominio del problema, y evolucionan en respuesta tanto a las necesidades sociales como al avance tecnológico, comparten un modelo abstracto subyacente de computación y desarrollo de programas. Esto sigue siendo cierto incluso a medida que el hardware del procesador y su interfaz con las herramientas de programación se entrelazan y complejizan progresivamente. Una comprensión de las abstracciones y paradigmas de programación comunes permite un aprendizaje más rápido de los lenguajes de programación.

El área de conocimiento de Fundamentos de los Lenguajes de Programación se ocupa de articular los conceptos y principios subyacentes de los lenguajes de programación, la especificación formal de un lenguaje de programación y el comportamiento de un programa, explicar cómo se implementan los lenguajes de programación, comparar las fortalezas y debilidades de varios paradigmas de programación, y describir cómo los lenguajes de programación interactúan con entidades como sistemas operativos y hardware. Los conceptos aquí cubiertos son aplicables a varios lenguajes y comprender estos principios ayuda al aprendiz a pasar fácilmente de un lenguaje a otro, así como a seleccionar un paradigma y lenguaje de programación que mejor se adapte al problema en cuestión.

Los lenguajes de programación son el medio a través del cual los programadores describen conceptos con precisión, formulan algoritmos y razonan sobre soluciones. A lo largo de su carrera, un científico de la computación aprenderá y trabajará con muchos lenguajes diferentes, por separado o juntos. Los desarrolladores de software deben entender diferentes modelos de programación, características y construcciones de programación, y conceptos subyacentes para tomar decisiones de diseño informadas entre lenguajes que admiten múltiples enfoques complementarios. Sería útil saber cómo se definen, componen e implementan las características de los lenguajes de programación para mejorar la eficiencia de ejecución y el mantenimiento a largo plazo del software desarrollado. También es útil un conocimiento básico de la traducción de lenguajes, el análisis de programas, el comportamiento en tiempo de ejecución, la gestión de memoria y la interacción de procesos concurrentes que se comunican entre sí mediante paso de mensajes, memoria compartida y sincronización. Finalmente, algunos desarrolladores e investigadores necesitarán diseñar nuevos lenguajes, un ejercicio que requiere una mayor familiaridad con los principios básicos.

área de Conocimiento (Knowledge Area-KA) (KA)	Core Tier1	Core Tier2	Electivo
2.5.1 Programación Orientada a Objetos I: Fundamentos			No
2.5.2 Programación Orientada a Objetos II: Encapsulación, Subtipado y Reflexión			No
2.5.3 Programación Funcional			No
2.5.4 Programación Lógica			No
2.5.5 Scripting de Shell			No
2.5.6 Programación Dirigida por Eventos y Reactiva			No
2.5.7 Computación Paralela y Distribuida			No
2.5.8 Programación Orientada a Aspectos			No
2.5.9 Sistemas de Tipos I: Fundamentos			No
2.5.10 Sistemas de Tipos II: Polimorfismo y Tipado Complementario			No
2.5.11 Teoría de Tipos Avanzada			No
2.5.12 Modelo de Ejecución y Memoria de Sistemas			No
2.5.13 Gestión de Memoria			No
2.5.14 Traducción y Ejecución de Lenguajes			No
2.5.15 Abstracción y Representación de Programas			No
2.5.16 Análisis Sintáctico			No
2.5.17 Análisis Semántico del Compilador			No
2.5.18 Análisis de Programas y Analizadores			No
2.5.19 Generación de Código			No
2.5.20 Comportamiento en Tiempo de Ejecución y Sistemas			No
2.5.21 Construcciones de Programación Avanzadas			No
2.5.22 Pragmática del Lenguaje			No
2.5.23 Semántica Formal			No
2.5.24 Metodologías de Desarrollo Formal			No
2.5.25 Principios de Diseño de Lenguajes de Programación			No
2.5.26 Sociedad, ética y Profesión			No

2.5.1. FPL/Programación Orientada a Objetos I: Fundamentos

Temas:
Core

Programación imperativa como subconjunto de la programación orientada a objetos.
Diseño orientado a objetos:
1.
Descomposición en objetos que poseen estado y tienen comportamiento.
2.
Diseño de jerarquía de clases para modelado.
Definición de clases: campos, métodos y constructores.
Subclases, herencia (incluyendo herencia múltiple) y sobrescritura de métodos.
Despacho dinámico: definición de llamada a método.
Manejo de excepciones.

Aprendizaje esperado (Learning Outcomes):
Core:

1.: Enumerar las diferencias entre los paradigmas de programación imperativa y orientada a objetos [Enumerar]
2.: Componer una clase a través del diseño, implementación y prueba para cumplir con los requisitos de comportamiento [Componer]
3.: Construir una jerarquía de clases simple utilizando subclases que permita reutilizar código para subclases distintas [Crear]
4.: Predecir y validar el flujo de control en un programa usando despacho dinámico [Evaluar]
5.: Comparar y contrastar cómo difieren las soluciones computacionales a un problema en los enfoques procedural, funcional y orientado a objetos [Comparar]
6.: Comparar y contrastar los mecanismos para definir y proteger elementos de datos dentro de los enfoques procedural, funcional y orientado a objetos [Comparar]

2.5.2. FPL/Programación Orientada a Objetos II: Encapsulación, Subtipado y Reflexión

Temas:
Core

Idiomas orientados a objetos para encapsulación:
1.
Privacidad, ocultación de datos y visibilidad de miembros de clase.
2.
Interfaces que revelan solo firmas de métodos.
3.
Clases base abstractas, rasgos (traits) y mixins.
Propiedades dinámicas vs estáticas.
Composición vs herencia.

Subtipado:
1.
Polimorfismo de subtipos; conversiones ascendentes (upcasts) implícitas en lenguajes tipados.
2.
Noción de reemplazo conductual: los subtipos actúan como el supertipo.
3.
Relación entre subtipado y herencia.
Clases de colecciones, iteradores y otros componentes comunes de biblioteca.
Metaprogramación y reflexión.

Aprendizaje esperado (Learning Outcomes):
Core:

1.: Comparar y contrastar los beneficios y costos/impacto de usar herencia (subclases) y composición (específicamente, cómo basar la composición en funciones de orden superior) [Comparar]
2.: Explicar la relación entre la herencia orientada a objetos (compartición de código y sobrescritura) y el subtipado (la idea de que un subtipo sea usable en un contexto que espera el supertipo) [Explicar]
3.: Usar mecanismos de encapsulación orientados a objetos como interfaces y miembros privados [Usar]
4.: Definir y usar iteradores y otras operaciones en agregados, incluyendo operaciones que toman funciones como argumentos, en múltiples lenguajes de programación, seleccionando los idiomas más naturales para cada lenguaje [Definir]
5.: Usar clases de colecciones e iteradores efectivamente para resolver un problema [Usar]
6.: Comparar y contrastar cómo difieren las soluciones computacionales a un problema en los enfoques procedural, funcional y orientado a objetos [Comparar]
7.: Comparar y contrastar los mecanismos para definir y proteger elementos de datos dentro de los enfoques procedural, funcional y orientado a objetos [Comparar]

2.5.3. FPL/Programación Funcional

Temas:
Core

Expresiones lambda y evaluación:
1.
Enlace (binding) de variables y reglas de ámbito (scope).
2.
Paso de parámetros.
3.
Expresiones lambda anidadas y orden de reducción.
Programación libre de efectos secundarios:
1.
Las llamadas a funciones no tienen efectos secundarios, facilitando el razonamiento composicional.
2.
Variables inmutables y copia de datos vs reducción.
3.
Uso de recursión vs bucles vs tuberías (map/reduce).
Procesamiento de datos estructurados (por ejemplo, árboles) mediante funciones con casos para cada variante de datos:
1.
Funciones definidas sobre datos compuestos en términos de funciones aplicadas a las piezas constituyentes.
2.
Estructuras de datos persistentes.
Usar funciones de orden superior (tomar, devolver y almacenar funciones).
Metaprogramación y reflexión.
Clausuras (closures) de funciones (funciones que usan variables en el entorno léxico circundante):
1.
Significado y definición básica: crear clausuras en tiempo de ejecución capturando el entorno.
2.
Idiomas canónicos: devoluciones de llamada (callbacks), argumentos para iteradores, código reutilizable mediante argumentos de funciones.
3.
Usar una clausura para encapsular datos en su entorno.
4.
Evaluación diferida (lazy) vs ansiosa (eager).

Non Core

Máquina de reducción de grafos (graph reduction) y llamada por necesidad (call-by-need).
Implementar evaluación diferida.
Integración con el paradigma de programación lógica usando conceptos como lógica ecuacional, estrechamiento (narrowing), residuación (residuation) y unificación semántica.
Integración con otros paradigmas de programación como imperativo y orientado a objetos.

Aprendizaje esperado (Learning Outcomes):
Core:

1.: Desarrollar algoritmos básicos que eviten asignar a estados mutables o considerar igualdad referencial [Crear]
2.: Desarrollar funciones útiles que tomen y devuelvan otras funciones [Crear]
3.: Explicar un ejemplo simple de una expresión lambda implementada usando una máquina virtual, como una máquina SECD, mostrando el almacenamiento y recuperación del entorno [Explicar]
4.: Interpretar correctamente las variables y el ámbito léxico en un programa que usa clausuras de funciones [Interpretar]
5.: Usar mecanismos de encapsulación funcional como clausuras e interfaces modulares [Usar]
6.: Comparar y contrastar ejecución con estado (stateful) vs sin estado (stateless) [Comparar]
7.: Definir y usar iteradores y otras operaciones en agregados, incluyendo operaciones que toman funciones como argumentos, en múltiples lenguajes de programación, seleccionando los idiomas más naturales para cada lenguaje [Definir]

NonCore:

8.: Ilustrar la reducción de grafos usando una expresión λ con una subexpresión compartida [Aplicar]
9.: Ilustrar la ejecución de una expresión λ anidada simple usando una máquina abstracta, como una máquina ABC [Aplicar]
10.: Ilustrar estrechamiento (narrowing), residuación y unificación semántica usando ejemplos ilustrativos simples [Aplicar]
11.: Ilustrar las construcciones de concurrencia usando ejemplos de programación simples de conceptos conocidos, como un búfer siendo leído y escrito concurrentemente o secuencialmente [Aplicar]

2.5.4. FPL/Programación Lógica

Temas:
Core

Cuantificadores universales vs existenciales.
Lógica de predicados de primer orden vs lógica de orden superior.
Expresar relaciones complejas usando conectivos lógicos y relaciones más simples.
Definiciones de cláusula de Horn, hechos (facts), metas (goals) y submetas (subgoals).
Unificación y algoritmo de unificación; unificación vs aserción vs evaluación de expresiones.
Mezclar relaciones con funciones.
Cortes (cuts), retroceso (backtracking) y no determinismo.
Suposiciones de mundo cerrado (closed-world) vs mundo abierto (open-world).

Non Core

Sobrecarga de memoria por copia de variables al manejar programas iterativos.
Construcciones de programación para almacenar cómputo parcial y podar árboles de búsqueda.
Mezclar programación funcional y programación lógica usando conceptos como lógica ecuacional, estrechamiento (narrowing), residuación y unificación semántica.
Programación lógica de orden superior, con restricciones (constraint) e inductiva.
Integración con otros paradigmas de programación como la programación orientada a objetos.
Construcciones de programación avanzadas como listas de diferencia (difference-lists), creación de estructuras de datos definidas por el usuario, conjunto de (set of), etc.

Aprendizaje esperado (Learning Outcomes):
Core:

1.: Usar un lenguaje lógico para implementar un algoritmo convencional [Usar]
2.: Usar un lenguaje lógico para implementar un algoritmo que emplee búsqueda implícita usando cláusulas, relaciones y cortes (cuts) [Usar]
3.: Usar un ejemplo ilustrativo simple para mostrar la correspondencia entre la Lógica de Predicados de Primer Orden (FOPL) y los programas lógicos que usan cláusulas de Horn [Usar]
4.: Usar ejemplos para ilustrar el algoritmo de unificación y su papel en el paso de parámetros en la reducción de consultas [Usar]
5.: Usar programas lógicos simples que entrelazan relaciones, funciones y programación recursiva, como números factoriales y de Fibonacci, y relaciones complejas simples entre entidades, e ilustrar la ejecución y paso de parámetros usando unificación y retroceso [Usar]

NonCore:

6.: Ilustrar el cómputo de programas simples como Fibonacci y mostrar la sobrecarga por recomputación, y luego mostrar cómo mejorar la sobrecarga de ejecución [Aplicar]

2.5.5. FPL/Scripting de Shell

Temas:
Core

Manejo de errores/excepciones
Tuberías (piping)
Comandos del sistema:
1.
Interfaz con sistemas operativos
Variables de entorno
Abstracción de archivo y operadores
Estructuras de datos, como arreglos y listas.
Expresiones regulares
Programas y procesos
Flujo de trabajo

Aprendizaje esperado (Learning Outcomes):
Core:

1.: Crear y ejecutar scripts automatizados para gestionar varias tareas del sistema [Crear]
2.: Resolver varios problemas de procesamiento de texto mediante scripting [Resolver]

2.5.6. FPL/Programación Dirigida por Eventos y Reactiva

Temas:
Core

Programación procedural vs programación reactiva: ventajas de la programación reactiva para capturar eventos.
Componentes de la programación reactiva: fuente de eventos, señales de eventos, escuchas (listeners) y despachadores (dispatchers), objetos de evento, adaptadores, manejadores de eventos (event-handlers).
Modelos sin estado (stateless) y de transición de estado (state-transition) de programación basada en eventos.
Usos canónicos como interfaces gráficas de usuario (GUIs), dispositivos móviles, robots, servidores.

Usar un framework reactivo:
1.
Definir manejadores/escuchas de eventos
2.
Parametrización de emisores de eventos y argumentos de eventos
3.
Eventos generados externamente y eventos generados por el programa
Separación de modelo, vista y controlador
Programas dirigidos por eventos y reactivos como sistemas de transición de estado

Aprendizaje esperado (Learning Outcomes):
Core:

1.: Implementar manejadores de eventos para usar en sistemas reactivos, como GUIs [Implementar]
2.: Examinar por qué un estilo de programación dirigida por eventos es natural en dominios donde los programas reaccionan a eventos externos [Examinar]
3.: Definir y usar un framework reactivo [Definir]
4.: Describir un sistema interactivo en términos de un modelo, una vista y un controlador [Describir]

2.5.7. FPL/Computación Paralela y Distribuida

Temas:
Core

Seguridad (safety) y vivacidad (liveness):
1.
Condiciones de carrera (race conditions)
2.
Dependencias/precondiciones
3.
Modelos de fallos (fault models)
4.
Terminación
Modelos de programación:
1.
Modelo de actores (actor models)
2.
Modelos procedurales y reactivos
3.
Modelos de programación síncrona/asíncrona
4.
Paralelismo de datos (data parallelism)
Propiedades:
1.
Propiedades basadas en orden:
a)
Conmutatividad
b)
Independencia

2.
Propiedades basadas en consistencia:
a)
Atomicidad
b)
Consenso
Control de ejecución:
1.
Espera asíncrona Async await
2.
Promesas (promises)
3.
Hilos (threads)
Comunicación y coordinación:
1.
Mutexes
2.
Paso de mensajes (message-passing)
3.
Memoria compartida (shared memory)
4.
Cobegin-coend
5.
Monitores
6.
Canales (channels)
7.
Hilos (threads)
8.
Guardas (guards)
Futuros (futures)
Soporte del lenguaje para paralelismo de datos como forall, desenrollado de bucles (loop unrolling), map/reduce
Efecto de los modelos de consistencia de memoria en la semántica del lenguaje y la generación correcta de código
Interfaces de Programación de Aplicaciones de Transferencia de Estado Representacional (REST APIs)
Tecnologías y enfoques: computación en la nube (cloud computing), computación de alto rendimiento, computación cuántica, computación ubicua
Sobrecarga del paso de mensajes
Granularidad del programa para una explotación eficiente de la concurrencia
Concurrencia y otros paradigmas de programación (por ejemplo, funcional)

Aprendizaje esperado (Learning Outcomes):
Core:

1.: Explicar por qué los lenguajes de programación no garantizan la consistencia secuencial en presencia de condiciones de carrera (data races) y qué deben hacer los programadores como resultado [Explicar]
2.: Implementar programas concurrentes correctos usando múltiples modelos de programación, como memoria compartida, actores, futuros, construcciones de sincronización y primitivas de paralelismo de datos [Implementar]
3.: Usar un modelo de paso de mensajes para analizar un protocolo de comunicación [Usar]
4.: Usar construcciones de sincronización como métodos monitorizados/sincronizados en un programa simple [Usar]
5.: Modelar dependencia de datos usando construcciones de programación simples que involucran variables, lectura y escritura [Implementar]
6.: Modelar dependencia de control usando construcciones simples como selección e iteración [Implementar]
7.: Explicar cómo las APIs REST integran aplicaciones y automatizan procesos [Explicar]
8.: Explicar beneficios, limitaciones y desafíos relacionados con la computación distribuida y paralela [Explicar]

2.5.8. FPL/Programación Orientada a Aspectos

Temas:
Non Core

Aspectos
Puntos de unión (join points)
Consejos (advice):
1.
Antes (before)
2.
Después (after) (como finally, returning o throwing)
3.
Alrededor (around)
Cortes de punto (point cuts):
1.
Designadores
Tejido (weaving) - estático y dinámico
Alternativas incluyendo anotaciones y IDEs

Aprendizaje esperado (Learning Outcomes):
NonCore:

1.: Describir los conceptos fundamentales de la programación orientada a aspectos, incluyendo aspectos, puntos de unión, consejos y cortes de punto [Describir]
2.: Aplicar estrategias de tejido estático y dinámico para modularizar los conceptos transversales en un programa [Aplicar]
3.: Analizar alternativas a la programación orientada a aspectos, como anotaciones y enfoques basados en IDEs, para el manejo de conceptos transversales [Analizar]

2.5.9. FPL/Sistemas de Tipos I: Fundamentos

Temas:
Core

Un tipo como un conjunto de valores junto con un conjunto de operaciones:
1.
Tipos primitivos (por ejemplo, números, booleanos)
2.
Tipos compuestos construidos a partir de otros tipos (por ejemplo, registros/estructuras, uniones, arreglos, listas, funciones, referencias usando operaciones de conjuntos)
Asociación de tipos a variables, argumentos, resultados y campos
Seguridad de tipos (type safety) como un aspecto de la corrección del programa
Seguridad de tipos y errores causados por usar valores inconsistentemente dados sus tipos pretendidos
Objetivos y limitaciones del tipado estático y dinámico: detectar y eliminar errores lo antes posible.
Equivalencia de tipos: equivalencia estructural vs nominal

Aprendizaje esperado (Learning Outcomes):
Core:

1.: Describir, tanto para un tipo primitivo como para uno compuesto, los valores que tienen ese tipo [Describir]
2.: Describir, para un lenguaje con un sistema de tipos estático, las operaciones que están prohibidas estáticamente, como pasar el tipo incorrecto de valor a una función o método [Describir]
3.: Describir ejemplos de errores de programa detectados por un sistema de tipos [Describir]
4.: Identificar propiedades del programa, para múltiples lenguajes de programación, que se verifican estáticamente y propiedades del programa que se verifican dinámicamente [Analizar]
5.: Describir un programa de ejemplo que no verifica tipos en un lenguaje particular y que sin embargo no tendría error si se ejecutara [Describir]
6.: Usar tipos y mensajes de error de tipos para escribir y depurar programas [Usar]
7.: Explicar cómo las reglas de tipado definen el conjunto de operaciones que son legales para un tipo [Explicar]
8.: Enumerar las reglas de tipo que gobiernan el uso de un tipo compuesto particular [Listar/Enumerar]
9.: Explicar por qué la indecidibilidad requiere que los sistemas de tipos aproximen conservadoramente el comportamiento del programa [Explicar]
10.: Explicar múltiples beneficios y limitaciones del tipado estático al escribir, mantener y depurar software [Explicar]

2.5.10. FPL/Sistemas de Tipos II: Polimorfismo y Tipado Complementario

Temas:
Core

Tipos genéricos (polimorfismo paramétrico):
1.
Definición y ventajas del polimorfismo: paramétrico, de subtipado (subtyping), de sobrecarga (overloading) y de coerción
2.
Comparación de tipos monomórficos y polimórficos
3.
Comparación con polimorfismo ad-hoc (sobrecarga) y polimorfismo de subtipos
4.
Parámetros genéricos y tipado
5.
Uso de bibliotecas genéricas como colecciones
6.
Comparación con polimorfismo ad hoc (sobrecarga) y polimorfismo de subtipos
7.
Polimorfismo prescriptivo vs descriptivo
8.
Modelos de implementación de tipos polimórficos
9.
Subtipado
Beneficios complementarios del tipado estático y dinámico:
1.
Errores tempranos vs errores tardíos/evitados
2.
Hacer cumplir invariantes durante el desarrollo y mantenimiento del código vs posponer decisiones de tipado mientras se prototipa y permitir convenientemente patrones de codificación flexibles como colecciones heterogéneas.
3.
Reglas de tipado para tipos de función, producto y suma
4.
Evitar mal uso del código vs permitir más reutilización de código
5.
Detectar programas incompletos vs permitir que programas incompletos se ejecuten
6.
Relación con el análisis estático
7.
Decidibilidad

Aprendizaje esperado (Learning Outcomes):
Core:

1.: Definir y usar piezas de programa (como funciones, clases, métodos) que usen tipos genéricos, incluyendo para colecciones [Definir]
2.: Discutir las diferencias entre genéricos, subtipado y sobrecarga [Debatir]

2.5.11. FPL/Teoría de Tipos Avanzada

Temas:
Non Core

Constructores de tipos composicionales, como tipos producto (para agregados), tipos suma (para uniones), tipos función, tipos cuantificados y tipos recursivos
Verificación de tipos (type checking)
Subtipado:
1.
Polimorfismo de subtipos; conversiones ascendentes implícitas en lenguajes tipados
2.
Noción de reemplazo conductual: los subtipos actúan como el supertipo
3.
Relación entre subtipado y herencia
Seguridad de tipos como preservación más progreso (preservation plus progress)

Inferencia de tipos
Sobrecarga estática
Proposiciones como tipos (implicación como función, conjunción como producto, disyunción como suma)
Tipos dependientes (cuantificación universal como función dependiente, cuantificación existencial como producto dependiente).

Aprendizaje esperado (Learning Outcomes):
NonCore:

1.: Definir un sistema de tipos de manera precisa y composicional [Definir]
2.: Para varios constructores de tipos fundamentales, identificar los valores que describen y los invariantes que hacen cumplir [Analizar]
3.: Describir precisamente los invariantes preservados por un sistema de tipos sano (sound) [Describir]
4.: Demostrar seguridad de tipos para un lenguaje simple en términos de teoremas de preservación y progreso [Probar/Demostrar]
5.: Implementar un algoritmo de inferencia de tipos basado en unificación para un lenguaje simple [Implementar]
6.: Explicar cómo la sobrecarga estática y los algoritmos de resolución asociados influyen en el comportamiento dinámico de los programas [Explicar]

2.5.12. FPL/Modelo de Ejecución y Memoria de Sistemas

Temas:
Core

Estructuras de datos para traducción, ejecución, traducción y movilidad de código como pila, montón (heap), alias (compartición usando punteros), secuencia indexada y cadena
Acceso directo, indirecto e indexado a ubicación de memoria
Representación en tiempo de ejecución de abstracciones de datos como variables, arreglos, vectores, registros, elementos de datos basados en punteros como listas enlazadas y árboles, y objetos
Máquina de bajo nivel abstracta con instrucción simple, pila y montón para explicar traducción y ejecución
Distribución en memoria en tiempo de ejecución: registro de activación (con varios punteros), datos estáticos, pila de llamadas, montón:
1.
Traducción de construcciones de selección e iterativas a diagramas de flujo de control
2.
Traducción de diagramas de flujo de control a código abstracto de bajo nivel
3.
Implementación de bucles, recursión y llamadas de cola (tail calls)
4.
Traducción de llamadas a funciones/procedimientos y retorno de llamadas, incluyendo diferentes mecanismos de paso de parámetros usando una máquina abstracta
Computación verde (green computing).

Aprendizaje esperado (Learning Outcomes):
Core:

1.: Explicar cómo se ejecuta una construcción central del lenguaje, como abstracciones de datos y abstracciones de control [Explicar]

2.5.13. FPL/Gestión de Memoria

Temas:
Core

Asignación y acceso de bajo nivel a estructuras de datos de alto nivel como tipos de datos básicos, arreglos n-dimensionales, vectores, registros y objetos
Retorno de procedimiento como mecanismo de desasignación automática para elementos de datos locales en la pila
Gestión manual de memoria: asignar, desasignar y reutilizar memoria del montón
Gestión automática de memoria: recolección de basura (garbage collection) como técnica automatizada usando la noción de alcanzabilidad (reachability)

Aprendizaje esperado (Learning Outcomes):
Core:

1.: Explicar cómo las implementaciones de lenguajes de programación típicamente organizan la memoria en secciones de datos globales, texto, montón y pila, y cómo características como recursión y gestión de memoria se mapean a este modelo de memoria [Explicar]
2.: Explicar por qué ocurren las fugas de memoria (memory leaks) y los problemas de punteros colgantes (dangling pointers), y qué puede hacer un programador para evitarlos/corregirlos [Explicar]

2.5.14. FPL/Traducción y Ejecución de Lenguajes

Temas:
Core

Modelos de ejecución para JIT (Just-In-Time), compilador, intérprete
Uso de código intermedio, por ejemplo, bytecode
Limitaciones y beneficios de JIT, compilador e intérprete
Compiladores/transpiladores cruzados (cross compilers/transpilers)
Representación BNF y BNF extendida de gramática libre de contexto
árbol de análisis (parse tree) usando una oración simple como expresión aritmética o sentencia if-then-else
Ejecución como código nativo o dentro de una máquina virtual
Canalización de traducción de lenguaje: análisis sintáctico, análisis (parsing), verificación de tipos opcional, generación de código/traducción y optimización, enlace (linking), carga (loading), ejecución
Representación en tiempo de ejecución de construcciones centrales del lenguaje como objetos (tablas de métodos) y funciones que pueden pasarse como parámetros a y devolverse desde funciones (clausuras)
Desarrollo seguro de compiladores

Aprendizaje esperado (Learning Outcomes):
Core:

1.: Explicar y comprender las diferencias entre implementaciones de lenguaje compilado, JIT e interpretado, incluyendo los beneficios y limitaciones de cada una [Explicar]
2.: Diferenciar sintaxis y análisis (parsing) de semántica y evaluación [Diferenciar]
3.: Usar BNF y BNF extendida para especificar la sintaxis de construcciones simples como if-then-else, declaración de tipo y construcciones iterativas para lenguajes conocidos como C++ o Python [Usar]
4.: Ilustrar el árbol de análisis usando una oración/expresión aritmética simple [Aplicar]
5.: Ilustrar traducción de diagramas de sintaxis a BNF/BNF extendida para construcciones simples como if-then-else, declaración de tipo, construcciones iterativas, etc [Aplicar]
6.: Ilustrar ambigüedad en el análisis usando if-then-else anidado/expresión aritmética y mostrar resolución usando orden de precedencia [Aplicar]
7.: Discutir los beneficios y limitaciones de la recolección de basura, incluyendo la noción de alcanzabilidad [Debatir]

2.5.15. FPL/Abstracción y Representación de Programas

Temas:
Core

BNF y expresiones regulares
Programas que toman (otros) programas como entrada, como intérpretes, compiladores, verificadores de tipos, generadores de documentación
Componentes de un lenguaje:
1.
Definiciones de alfabetos, delimitadores, oraciones, sintaxis y semántica
2.
Sintaxis vs semántica
Programa como un conjunto de oraciones significativas no ambiguas
Abstracciones básicas de programación: constantes, variables, declaraciones (incluyendo declaraciones anidadas), comando, expresión, asignación, selección, iteración definida e indefinida, iteradores, función, procedimiento, módulos, manejo de excepciones
Variables mutables vs inmutables: ventajas y desventajas de reutilizar ubicación de memoria existente vs ventajas de copiar y mantener valores antiguos; almacenar cómputo parcial vs recomputación
Tipos de variables: estáticas, locales, no locales (nonlocal), globales; necesidad y problemas con variables no locales y globales.
Reglas de ámbito (scope): estático vs dinámico; visibilidad de variables; efectos secundarios (side-effects).
Efectos secundarios inducidos por variables no locales, variables globales y variables con alias (aliased).

Non Core

Valores-L (L-values) y Valores-R (R-values): mapear nombre de variable mutable a Valores-L; mapear nombres de variables inmutables a Valores-R
Entorno (environment) vs almacén (store) y sus propiedades

Abstracción de datos y de control
Mecanismos para intercambio de información entre unidades de programa como procedimientos, funciones y módulos: variables no locales, variables globales, paso de parámetros, importación-exportación entre módulos
Estructuras de datos para representar código para ejecución, traducción o transmisión.
Representación de instrucciones de bajo nivel como instrucciones de máquina virtual, lenguaje ensamblador y representación binaria
Cálculo lambda, enlace de variables (variable binding) y renombrado de variables.
Tipos de semántica: operacional, axiomática, denotacional, conductual; definir y usar árboles de sintaxis abstracta; contrastar con sintaxis concreta.

Aprendizaje esperado (Learning Outcomes):
Core:

1.: Ilustrar el ámbito de variables y visibilidad usando programas simples [Aplicar]
2.: Ilustrar diferentes tipos de paso de parámetros usando un lenguaje de programación pseudo simple [Aplicar]
3.: Explicar el efecto secundario usando variables globales y no locales y cómo corregir tales programas [Explicar]
4.: Explicar cómo los programas que procesan otros programas tratan a los otros programas como sus datos de entrada [Explicar]
5.: Describir una gramática y un árbol de sintaxis abstracta para un lenguaje pequeño [Describir]
6.: Describir los beneficios de tener representaciones de programas distintas de cadenas de código fuente [Describir]
7.: Implementar un programa para procesar alguna representación de código para algún propósito, como un intérprete, un optimizador de expresiones o un generador de documentación [Implementar]

2.5.16. FPL/Análisis Sintáctico

Temas:
Non Core

Gramáticas regulares vs gramáticas libres de contexto
Escaneo (scanning) y análisis (parsing) basados en especificaciones de lenguaje

Análisis léxico usando expresiones regulares
Tokens y su uso
Estrategias de análisis (parsing) incluyendo técnicas descendentes (top-down) (por ejemplo, descenso recursivo o LL) y ascendentes (bottom-up) (por ejemplo, LR o GLR):
1.
Tablas de anticipación (lookahead) y su aplicación al análisis
Teoría de lenguajes:
1.
Jerarquía de Chomsky
2.
Derivación más a la izquierda/más a la derecha y ambigüedad
3.
Transformación de gramáticas
Mecanismos de recuperación de errores del analizador (parser)
Generar escáneres y analizadores a partir de especificaciones declarativas

Aprendizaje esperado (Learning Outcomes):
NonCore:

1.: Usar gramáticas formales para especificar la sintaxis de lenguajes [Usar]
2.: Ilustrar el papel de las tablas de anticipación en el análisis [Aplicar]
3.: Usar herramientas declarativas para generar analizadores y escáneres [Usar]
4.: Reconocer problemas clave en definiciones de sintaxis: ambigüedad, asociatividad, precedencia [Reconocer]

2.5.17. FPL/Análisis Semántico del Compilador

Temas:
Non Core

árboles de sintaxis abstracta; contraste con sintaxis concreta
Definir, recorrer y modificar representaciones de programa de alto nivel
ámbito (scope) y resolución de enlaces (binding)
Semántica estática:
1.
Verificación de tipos.
2.
Definir antes de usar
3.
Anotaciones y entornos (frameworks) de verificación estática extendida (extended static checking).
Valores-L/Valores-R
Semántica de llamada
Tipos de paso de parámetros con ilustraciones simples y comparación: llamada por valor (call by value), llamada por referencia (call by reference), llamada por valor-resultado (call by value-result), llamada por nombre (call by name), llamada por necesidad (call by need) y sus variaciones
Especificaciones declarativas como gramáticas atribuidas (attribute grammars) y sus aplicaciones en manejo de gramáticas sensibles al contexto limitadas

Aprendizaje esperado (Learning Outcomes):
NonCore:

1.: Dibujar el árbol de sintaxis abstracta para un lenguaje pequeño [Diagramar]
2.: Implementar análisis estáticos sensibles al contexto, a nivel de fuente, como verificadores de tipos o resolver identificadores para identificar sus ocurrencias de enlace (binding) [Implementar]
3.: Describir análisis semánticos usando una gramática atribuida [Describir]

2.5.18. FPL/Análisis de Programas y Analizadores

Temas:
Non Core

Representaciones de programa relevantes, como bloques básicos (basic blocks), grafos de flujo de control (control-flow graphs), cadenas definición-uso (def-use chains) y asignación única estática (static single assignment)
Indecidibilidad y consecuencias para el análisis de programas
Análisis insensible al flujo (flow-insensitive), como verificación de tipos y análisis de punteros y alias escalables
Análisis sensible al flujo (flow-sensitive), como análisis de flujo de datos (dataflow) hacia adelante y hacia atrás
Análisis sensible a la ruta (path-sensitive), como verificación de modelos de software (software model checking) y verificación de software
Herramientas y frameworks para implementar analizadores
Papel del análisis estático en la optimización de programas y el análisis de dependencia de datos durante la explotación de concurrencia
Papel del análisis de programas en la verificación (parcial) y la búsqueda de errores (bug-finding)
Paralelización:
1.
Análisis para auto-paralelización
2.
Análisis para detectar errores de concurrencia

Aprendizaje esperado (Learning Outcomes):
NonCore:

1.: Explicar la diferencia entre grafo de flujo de datos (dataflow graph) y grafo de flujo de control [Explicar]
2.: Explicar por qué los análisis de programa no triviales y sólidos (sound) deben ser aproximados [Explicar]
3.: Argumentar por qué un análisis es correcto (sound y terminante) [Argumentar]
4.: Explicar por qué el alias potencial limita el análisis de programa sólido y cómo el análisis de alias puede ayudar [Explicar]
5.: Usar los resultados de un análisis de programa para optimización de programas y/o corrección parcial del programa [Usar]

2.5.19. FPL/Generación de Código

Temas:
Non Core

Conjuntos de instrucciones
Flujo de control
Gestión de memoria
Llamadas a procedimientos y despacho de métodos (method dispatching)
Compilación separada; enlace (linking)
Selección de instrucciones
Planificación de instrucciones (por ejemplo, encadenamiento - pipelining)
Asignación de registros
Optimización de código como una forma de análisis de programas
Generación de programas mediante IA generativa

Aprendizaje esperado (Learning Outcomes):
NonCore:

1.: Identificar todos los pasos esenciales para convertir automáticamente código fuente en lenguaje ensamblador u otros lenguajes de bajo nivel [Analizar]
2.: Explicar el código de bajo nivel necesario para llamar a funciones/métodos en lenguajes modernos [Explicar]
3.: Discutir por qué la compilación separada requiere convenciones de llamada uniformes [Debatir]
4.: Discutir por qué la compilación separada limita la optimización debido a efectos desconocidos de las llamadas [Debatir]
5.: Discutir oportunidades para la optimización introducidas por la traducción ingenua y enfoques para lograr la optimización, como selección de instrucciones, planificación de instrucciones, asignación de registros y optimización de mirilla (peephole optimization) [Debatir]

2.5.20. FPL/Comportamiento en Tiempo de Ejecución y Sistemas

Temas:
Non Core

Modelos de proceso usando pilas y montones para asignar y desasignar registros de activación y recuperar entornos usando punteros de marco (frame pointers) y direcciones de retorno durante una llamada a procedimiento, incluyendo ejemplos de paso de parámetros
Esquemas de búsqueda de código usando tablas hash para métodos en implementaciones de programas orientados a objetos
Distribución de datos para objetos y registros de activación
Asignación de objetos en el montón (heap)
Implementar entidades virtuales y métodos virtuales; tablas de métodos virtuales (virtual method tables) y su aplicación
Comportamiento en tiempo de ejecución de programas orientados a objetos
Comparar y contrastar la asignación de memoria durante el intercambio de información usando paso de parámetros y variables no locales (usando cadena de enlaces estáticos).
Enfoques y técnicas de gestión dinámica de memoria: malloc/free, recolección de basura (mark-sweep, copying, reference counting), regiones (también conocidas como arenas o zonas)
Compilación justo a tiempo (just-in-time) y recompilación dinámica
Interfaz con el sistema operativo (por ejemplo, para inicialización del programa)
Interoperabilidad entre lenguajes de programación incluyendo mecanismos de paso de parámetros y representación de datos:
1.
Big endian, little endian
2.
Distribución de datos de tipos de datos compuestos como arreglos
Otras características comunes de las máquinas virtuales, como carga de clases (class loading), hilos (threads) y verificación de seguridad
Sandboxing

Aprendizaje esperado (Learning Outcomes):
NonCore:

1.: Discutir beneficios y limitaciones de la gestión automática de memoria [Debatir]
2.: Explicar el uso de metadatos en representaciones en tiempo de ejecución de objetos y registros de activación, como punteros de clase, longitudes de arreglo, direcciones de retorno y punteros de marco (frame pointers) [Explicar]
3.: Comparar y contrastar asignación estática vs asignación basada en pila vs asignación basada en montón de elementos de datos [Comparar]
4.: Explicar por qué algunos elementos de datos no pueden desasignarse automáticamente al final de una llamada a procedimiento/método (necesidad de recolección de basura) [Explicar]
5.: Discutir ventajas, desventajas y dificultades de la compilación justo a tiempo y la recompilación dinámica [Debatir]
6.: Discutir el uso del sandboxing en código móvil [Debatir]
7.: Identificar los servicios proporcionados por los sistemas en tiempo de ejecución de lenguajes modernos [Analizar]

2.5.21. FPL/Construcciones de Programación Avanzadas

Temas:
Non Core

Mecanismos de encapsulación
Evaluación diferida (delayed evaluation) y flujos infinitos (infinite streams)
Comparar y contrastar evaluación diferida vs evaluación ansiosa (eager)
Unificación vs aserción vs evaluación de expresiones
Abstracciones de control: manejo de excepciones, continuaciones (continuations), mónadas (monads).
Abstracciones orientadas a objetos: herencia múltiple, mixins, rasgos (traits), multimétodos (multimethods)
Metaprogramación: macros, programación generativa, desarrollo basado en modelos (model-based development)
Manipulación de cadenas mediante coincidencia de patrones (pattern-matching) (expresiones regulares)
Evaluación dinámica de código (eval")
Soporte del lenguaje para verificar aserciones, invariantes y pre/post-condiciones
Lenguajes específicos del dominio, como lenguajes de bases de datos, lenguajes de ciencia de datos, lenguajes de computación embebida, lenguajes síncronos, lenguajes de interfaz de hardware
Modelos y lenguajes de computación de alto rendimiento masivamente paralelos

Aprendizaje esperado (Learning Outcomes):
NonCore:

1.: Usar varias construcciones e idiomas de programación avanzados correctamente [Usar]
2.: Discutir cómo varias construcciones de programación avanzadas tienen como objetivo mejorar la estructura del programa, la calidad del software y la productividad del programador [Debatir]
3.: Discutir cómo varias construcciones de programación avanzadas interactúan con la definición e implementación de otras características del lenguaje [Debatir]

2.5.22. FPL/Pragmática del Lenguaje

Temas:
Non Core

Efecto de las necesidades tecnológicas y los requisitos de software en el desarrollo y evolución de los lenguajes de programación
Dominios de problemas y paradigma de programación
Criterios para un buen diseño de lenguaje de programación:
1.
Principios de diseño de lenguajes como la ortogonalidad
2.
Definir construcciones de control e iteración
3.
Modularización de software grande
Orden de evaluación, precedencia y asociatividad
Evaluación ansiosa vs diferida
Definir construcciones de control e iteración
Llamadas externas y bibliotecas del sistema

Aprendizaje esperado (Learning Outcomes):
NonCore:

1.: Discutir el papel de conceptos como la ortogonalidad y valores por defecto bien elegidos en el diseño de lenguajes [Debatir]
2.: Evaluar objetivamente y justificar decisiones de diseño de lenguaje [Evaluar]
3.: Implementar un programa de ejemplo cuyo resultado pueda diferir bajo diferentes reglas para el orden de evaluación, precedencia o asociatividad [Implementar]
4.: Ilustrar usos de la evaluación diferida, como abstracciones de control definidas por el usuario [Aplicar]
5.: Discutir la necesidad de permitir llamadas a llamadas externas y bibliotecas del sistema y las consecuencias para la implementación del lenguaje [Debatir]

2.5.23. FPL/Semántica Formal

Temas:
Non Core

Sintaxis vs semántica
Enfoques de semántica: axiomática, operacional, denotacional, basada en tipos
Semántica axiomática de construcciones abstractas como asignación, selección, iteración usando precondición, postcondiciones e invariante de bucle
Análisis de semántica operacional de construcciones abstractas y secuencia de tales como asignación, evaluación de expresión, selección, iteración usando entorno y almacén:
1.
Ejecución simbólica (symbolic execution)
2.
Verificadores de restricciones (constraint checkers)
Semántica denotacional:
1.
Cálculo Lambda.
Demostraciones por inducción sobre la semántica del lenguaje
Definiciones y demostraciones formales para sistemas de tipos:
1.
Proposiciones como tipos (implicación como función, conjunción como producto, disyunción como suma)
2.
Tipos dependientes (cuantificación universal como función dependiente, cuantificación existencial como producto dependiente)
3.
Parametricidad

Aprendizaje esperado (Learning Outcomes):
NonCore:

1.: Construir semántica formal para un lenguaje pequeño [Crear]
2.: Escribir un programa de cálculo lambda y mostrar su evaluación a una forma normal [Escribir]
3.: Discutir los diferentes enfoques de la semántica operacional, denotacional y axiomática [Debatir]
4.: Usar inducción para demostrar propiedades de todos los programas en un lenguaje [Usar]
5.: Usar inducción para demostrar propiedades de todos los programas en un lenguaje que está bien tipado según un sistema de tipos definido formalmente [Usar]
6.: Usar parametricidad para establecer el comportamiento del código dado solo su tipo [Usar]

2.5.24. FPL/Metodologías de Desarrollo Formal

Temas:
Non Core

Lenguajes y metodologías de especificación formal
Demostradores de teoremas (theorem provers), asistentes de prueba (proof assistants) y lógicas
Verificadores de restricciones (constraint checkers)
Tipos dependientes (cuantificación universal como función dependiente, cuantificación existencial como producto dependiente)
Especificación y descarga de pruebas (proof discharge) para sistemas de software completamente verificados usando pre/post condiciones, tipos de refinamiento (refinement types), etc.
Modelado formal e implementación/refinamiento manual de sistemas de software.
Uso de pruebas simbólicas (symbolic testing) y fuzzing en el desarrollo de software.
Verificación de modelos (model checking).
Comprensión de situaciones donde los métodos formales pueden aplicarse efectivamente y cómo estructurar el desarrollo para maximizar su valor.

Aprendizaje esperado (Learning Outcomes):
NonCore:

1.: Usar técnicas de modelado formal para desarrollar y validar arquitecturas [Usar]
2.: Usar lenguajes de programación asistidos por pruebas (proof assisted) para desarrollar artefactos de software completamente especificados y verificados [Usar]
3.: Usar soporte de verificador y especificación en lenguajes de programación para validar formalmente propiedades del sistema [Usar]
4.: Integrar herramientas de validación simbólica en un flujo de trabajo de programación [Integrar]
5.: Discutir cuándo y cómo los métodos formales pueden usarse efectivamente en el proceso de desarrollo [Debatir]

2.5.25. FPL/Principios de Diseño de Lenguajes de Programación

Temas:
Non Core

Principios de diseño de lenguajes:
1.
Simplicidad
2.
Seguridad
3.
Traducción rápida
4.
Código objeto eficiente
5.
Ortogonalidad
6.
Legibilidad
7.
Completitud
8.
Estrategias de implementación
Diseñar un lenguaje para ajustarse a un dominio o problema específico
Interoperabilidad entre lenguajes de programación
Portabilidad del lenguaje
Descripción formal de un lenguaje de programación
Principios de computación verde (green computing)

Aprendizaje esperado (Learning Outcomes):
NonCore:

1.: Entender qué constituye un buen diseño de lenguaje y aplicar ese conocimiento para evaluar un lenguaje de programación real [Evaluar]

2.5.26. FPL/Sociedad, ética y Profesión

Temas:
Non Core

Impacto de los lenguajes de programación centrados en inglés
Mejorar la accesibilidad e inclusión para personas con discapacidades - Compatibilidad con tecnologías de asistencia
Factores humanos relacionados con los lenguajes de programación y la usabilidad:
1.
Impacto de la sintaxis en la accesibilidad
2.
Compatibilidad con diferencias culturales (por ejemplo, moneda, decimales, fechas)
3.
Neurodiversidad
Etimología de términos como çlase"(class), "maestro"(master) y esclavo"(slave) en lenguajes de programación
Aumentar la accesibilidad mediante el soporte de múltiples idiomas dentro de las aplicaciones (UTF)

Aprendizaje esperado (Learning Outcomes):
NonCore:

1.: Diseñar conscientemente lenguajes de programación para que sean inclusivos y no ofensivos [Diseñar]