Saltar a contenido

Fundamentos de Programación Funcional y Concurrente

Universidad del Valle, sede Tuluá · Escuela de Ingeniería de Sistemas y Computación · Agosto – Diciembre de 2026

Este sitio guarda lo que se hizo en clase: notas, ejemplos trabajados y código. El cronograma, el material de lectura previa, las entregas y las notas están en el Campus Virtual. Los dos grupos ven la misma clase, así que estas notas son comunes a ambos.

Horario

Grupo Día Hora
50 Jueves 7:00 a. m. – 10:00 a. m.
51 Jueves 2:00 p. m. – 5:00 p. m.

Cada sesión son tres horas: la primera hora y media es de exposición y el resto se dedica a resolver un ejercicio en clase, que se entrega antes de salir.

Notas de clase

Se publican después de cada sesión.

Corte 1

  1. Clase 1. Principios y elementos de programación funcional — 10 de septiembre — paradigmas y el esquema de von Neumann, las funciones como valores, el modelo de sustitución, composición con andThen y compose, cinco formas de definir una función, evaluación por valor frente a por nombre, val frente a def, el if como expresión, cortocircuito de &&, y bloques y alcance léxico. Incluye el código escrito en clase.
  2. Clase 2. Funciones y los procesos que generan — 17 de septiembre — función frente a proceso, la pila de llamadas y el StackOverflowError, recursión lineal, recursión de cola con acumulador y @tailrec, recursión de árbol con Fibonacci y con el producto por mitades, y las condiciones de entrega del Taller 1. Incluye el código escrito en clase.
  3. Clase 3. Funciones de alto orden — 24 de septiembre — el esquema que se repite en tres sumas, funciones como parámetro, funciones anónimas y cómo se lee un tipo con flecha, los huecos del avance y de la operación con el neutro que se deduce de ella, funciones que devuelven funciones, la derivada y el error de truncamiento, y currificación. Incluye el código escrito en clase.
  4. Clase 4. Funciones y datos — 1 de octubre — por qué un Double no sirve para un racional, la clase y su constructor, toString, normalizar al construir con el máximo común divisor y con la norma, encapsulación con private, el argumento implícito this, notación infija, operadores como métodos y su precedencia, precondiciones con require y el modelo de sustitución con clases. Incluye el código escrito en clase.
  5. Clase 5. Reconocimiento de patrones — 8 de octubre — el conjunto de enteros como árbol binario, clases abstractas y despacho dinámico, el objeto único, traits y por qué no hay herencia múltiple, el match sobre la forma del dato frente al isInstanceOf, listas con head y tail, tipos sellados con case class y el aviso del compilador cuando falta un caso. Sus ejercicios están publicados.
  6. Clase 6. Listas I, 15 de octubre: los dos constructores Nil y ::, la asociatividad por la derecha, head, tail e isEmpty, por qué una lista no se indexa como un arreglo, los patrones sobre listas y el orden de los casos, la suma genérica que no compila y de dónde sale ese error, las funciones recursivas ultimo, inicio, concat y reversa con sus costos, el ordenamiento por inserción, los métodos predefinidos y flatten. Incluye el código escrito en clase. Sus ejercicios están publicados.
  7. Clase 7. Listas II, 22 de octubre: las tuplas y en qué se apartan de la lista, el reconocimiento de patrones sobre una tupla de dos listas, el ordenamiento por mezcla con splitAt y merge con su traza completa, la suma genérica que se resuelve pasando la operación por parámetro, map y el cambio de tipo, filter frente a takeWhile, span con empaquetar y codificar, y reduce y fold con la asociatividad que decide cuál de los dos sirve. Incluye el código escrito en clase. Sus ejercicios están publicados.
  8. Clase 8. Colecciones I, 29 de octubre: por qué una lista no se indexa y qué secuencias la relevan, Array frente a Vector y la actualización en su sitio, los dos agregados, los rangos y lo que guardan, exists y forall, el test de primalidad con la guarda y por qué basta llegar a la raíz, flatMap para combinar dos colecciones sin anidar, las cadenas de texto y los conjuntos sin orden ni repetidos, las expresiones for y su traducción, y las fechas válidas de un intervalo de años resueltas de las dos formas. Incluye el código escrito en clase. Sus ejercicios están publicados.
  9. Clase 9. Colecciones II: mapas y flujos, 5 de noviembre: una consulta con for leída como una consulta de base de datos, con los generadores de FROM, los filtros de WHERE y el yield de SELECT; agrupar con groupBy; el tipo Map y qué hacer cuando la clave no está, con get, Option y getOrElse; el segundo primo entre 1000 y 10000 como el problema que obliga a calcular por demanda; LazyList y lo que queda sin evaluar; los flujos infinitos; la criba de Eratóstenes; y los capicúas primos. Incluye el código escrito en clase. Sus ejercicios están publicados.

Corte 2

  1. Clase 10. Principios y abstracciones de la concurrencia, 12 de noviembre: qué tiene cada hilo y qué comparte con los demás; el no determinismo de dos operaciones sobre el mismo valor; el generador de identificadores que pierde una actualización cuando dos hilos leen antes de escribir; la jerarquía de caché y por qué la visibilidad no se arregla ordenando instrucciones; el cerrojo con synchronized y el contador que llega a 2000; el speedup de 2,80 frente al 4 que darían cuatro núcleos; parallel y los parámetros por nombre; el umbral de divide y vencerás; task y dónde va el join; y Monte Carlo sin estado compartido. Sus ejercicios están publicados.
  2. Clase 11. Complejidad de la concurrencia — 19 de noviembre.
  3. Clase 12. Paralelismo de tareas y de datos — 26 de noviembre.

Clases en video

Las grabaciones de cada sesión están en la lista de reproducción del curso, en orden cronológico: la sesión más reciente queda al final y la lista se va llenando a medida que avanza el semestre. Es una sola lista para los dos grupos, y cada sesión se parte en varios videos cortos, para volver a un tema puntual sin recorrer la clase entera. El reproductor de abajo va sobre la lista completa; la barra que lo encabeza la abre en YouTube, en una pestaña nueva.

Ejercicios de apoyo

Ejercicios interactivos para recorrer en el navegador, uno por tema. No se entregan ni tienen nota: sirven para llegar a clase con la mecánica ya vista y para volver sobre ella cuando algo no cuadre. Se publican antes de cada clase.

Las clases se numeran por orden dictado. La primera corresponde a la sesión 03 del campus, porque las dos primeras semanas del semestre fueron jornada de reuniones docentes y jornada de reflexión.

Clase Tema Ejercicios
1 Principios y elementos de programación sustituir y evaluación
2 Funciones y los procesos que generan nueve ejercicios, tres por tema
3 Funciones de alto orden doce ejercicios: tablas, pasos y trazas por revisar
4 Funciones y datos ocho ejercicios: del racional a los operadores
5 Reconocimiento de patrones diez ejercicios: del despacho al árbol de expresiones
6 Listas I: diseño, uso y recursión sobre listas cuatro ejercicios: de los dos constructores a la inserción
7 Listas II: tuplas, ordenamiento por mezcla y alto orden once ejercicios: de las tuplas a fold
8 Colecciones I: secuencias y conjuntos once ejercicios: de escoger la colección a las ternas
9 Colecciones II: mapas y flujos seis ejercicios: de las consultas a la criba
10 Principios y abstracciones de la concurrencia nueve ejercicios: de las intercalaciones a Monte Carlo
11 Complejidad de la concurrencia seis ejercicios: del trabajo y la profundidad al calentamiento de la JVM

Ejercicios de clase

Cada sesión tiene su repositorio. Se resuelve haciendo un fork, y la entrega es la dirección del fork con el identificador del último commit, que se reporta en el Campus Virtual antes de terminar la clase.

Sesión Ejercicio
1 Scala, Gradle y pruebas
2 Recursión de cola: sumatorias con acumulador
3 Currificación: suma4, reducirC y composición
4 Funciones y datos I: clases, invariantes y operadores
5 Funciones y datos II: figuras, patrones y expresiones
6 Listas I: if/else, match, inserción, aplanar y corridas
7 Listas II: tuplas, merge sort y alto orden
8 Colecciones I: secuencias, flatMap, for y conjuntos
9 Colecciones II: índice, frecuencias, flujos y criba
10 Principios de concurrencia: intercalaciones, carrera y medida
10 Abstracciones: parallel, umbral, task y Monte Carlo
11 Complejidad: reduce paralelo, Amdahl y ScalaMeter
12 Paralelismo de tareas y de datos

Talleres

Se entregan como fork del repositorio del taller, uno por grupo, y la entrega es la dirección del fork con el hash del último commit, registrada en el Campus Virtual antes del cierre. El enunciado completo, con la rúbrica, es el PDF del campus; el repositorio trae el proyecto configurado, las pruebas y los ejemplos de los informes.

Taller Tema Cierre
1 Cifrados clásicos con recursión jueves 8 de octubre, 23:59
2 Un robot en la cuadrícula jueves 22 de octubre, 23:59
3 Consulta sobre un registro sísmico jueves 12 de noviembre, 23:59
4 Simulación de partículas en paralelo jueves 26 de noviembre, 23:59

Reglas del código

Todo el código del curso se escribe en estilo funcional: sin var, sin while, sin return y sin estado que cambie. Se resuelve con val, recursión, composición de funciones y funciones de alto orden.

Referencias

  • Odersky, Spoon y Venners. Programming in Scala, 3.ª edición. Artima, 2016.
  • Abelson y Sussman. Structure and Interpretation of Computer Programs.