Cursada 2018‎ > ‎

Bitácora

Aquí iremos subiendo clase a clase los temas vistos, junto con material teórico y práctico complementario.

Clase 10 - Introducción a Lógico

publicado a la‎(s)‎ 22 may. 2018 2:40 por Nahuel Palumbo

¡Comenzamos con el paradigma lógico!

Introducimos que se trata de un paradigma declarativo que permite inferir verdades que se encuentran en la base de conocimiento (basado en el Principio de Universo Cerrado) en modo de predicados (poseen un valor de verdad) compuestos por cláusulas (hechos o reglas)Luego estuvimos haciendo consultas, tanto individuales como existenciales.
Si todos estos nombres los confunden, les dejamos este artículo que ordena un poco todo lo del párrafo anterior.

Luego vimos como escribir conjunciones y disyunciones. Y nos sorprendimos con la capacidad de otorgar múltiples respuestas para una consulta.

Todo esto lo pueden encontrar en el módulo 1 y módulo 2 de la sección de apuntes.

Finalmente, comenzamos a hacer las siguientes guías de Mumuki:
Y quedó de tarea comenzar (primeros 4 ejercicios)

Clase 9 - Parcial de Funcional

publicado a la‎(s)‎ 8 may. 2018 14:26 por Nahuel Palumbo

Tomamos el parcial de Piratas del Caribe. ¡Esperamos que les haya ido bien!

Clase 8 - Día del trabajador

publicado a la‎(s)‎ 8 may. 2018 3:37 por Nahuel Palumbo

¡Disfruten el feriado! :)

Clase 7 - Entrega de TP

publicado a la‎(s)‎ 8 may. 2018 3:36 por Nahuel Palumbo

Tuvimos la última entrega del TP de funcional. Muy buen trabajo de todos!!

Luego planteamos distintas versiones de la función esMultiploDe con sus explicaciones:
  esMultiploDe n m = (== 0) . rem n m
Esto NO tipa porque rem n m (al estar aplicado totalmente) ya es un número, y no se puede componer. Para salvar eso habría que cortar esa aplicación con unos paréntesis: esMultiploDe n m = ((== 0) . rem n) m

  esMultiploDe n = (== 0) . rem n
Esta solución compila perfecto. En esta versión point-free estamos pensando en términos de funciones: si necesitamos una función que nos diga si un número es múltiplo de otro, solo necesito saber ese número para armar la función (recibo un número y devuelvo una función). Así es como piensa un programador funcional!

  esMultiploDe = (== 0) . rem
Esto NO tipa porque, si pensamos que la función rem está currificada: la podríamos ver como una función que espera un parámetro y retorna otra función (la que espera el segundo parámetro), pero el (== 0) espera un número, no una función.

Clase 6 - Práctica con parciales

publicado a la‎(s)‎ 21 abr. 2018 15:08 por Nahuel Palumbo

Terminamos de resolver el parcial de Monsters Inc. que comenzamos la clase pasada.
Y, además, implementamos una posible solución para el parcial de OSPF.
Dejamos el código hecho en clase acá adjunto.

La clase que viene es la última entrega del TP. Aprovechen la entrega presencial para sacarse todas las dudas para el parcial.
Les dejamos el parcial de Maquinitas por si quieren meterle más práctica para el parcial. Podemos hacer una puesta en común al finalizar la corrección.

También dejamos de nuevo el código de la clase 5 sobre Typeclasses: evitando el problema Show de datas con funciones a partir de hacer Show las funciones y derivando.

Clase 5 - Evaluación diferida y Typeclasses

publicado a la‎(s)‎ 17 abr. 2018 5:16 por Nahuel Palumbo

Terminamos de ver los temas faltantes / pendientes:
  • Vimos que Haskell posee clase de tipos - typeclass - como forma de tratar polimórficamente distintos tipos de datos. En ellas se declaran las operaciones, como las interfaces de Java, pero no definen un tipo en sí mismas.
  • Por último, prestamos más atención a cómo funciona el motor de reducciones, sobre todo para el extraño caso de listas infinitas (y al operar sobre ellas). Descubrimos que tiene una forma de evaluación diferida que hace que solo se ejecute las expresiones necesarias para el resultado final. Esto es posible gracias a la ausencia de efecto colateral!
Los apuntes son:
Luego comenzamos a resolver el ejercicio de Monsters Inc. Les dejamos este apunte con una posible solución (no es exactamente el mismo enunciado pero supongo que les va a servir).
Todo el código de la clase lo pueden descargar acá abajo.

Clase 4 - Expresiones Lambdas, Currificación y Recursividad

publicado a la‎(s)‎ 6 abr. 2018 23:04 por Nahuel Palumbo

Tuvimos la primera entrega del TP! Espero que les haya servido.
Después vimos expresiones lambdas como funciones anónimas que se crean in situ, y que es la forma de ver a las funciones que tiene Haskell. Luego de poca discusión, concordamos en que no nos van a ser muy útiles, porque la mayoría de las funciones que creamos son abstracciones a las cuales nos gustaría ponerle un nombre.
Continuamos excavando en las entrañas de Haskell a partir de que si el tipo de la función depende de la cantidad de parámetros que espera entonces deberían existir infinitos tipos de funciones. Pero vimos que no es así, que todas las funciones de Haskell esperan un solo parámetro, también conocidas como funciones currificadas, en honor a Haskell Curry.
Finalmente hablamos sobre recursividad, como una forma de modelar el proceso inductivo, como funciones que se llaman a sí mismas. En las cuales es necesario determinar un caso base y otro recursivo.

Como siempre, pueden descargarse el código de la clase acá abajo. Y los apuntes de esta clase son:
También ya pueden encontrar en la sección de TPs en enunciado de la segunda parte del TP. Les recomendamos haberlo comenzado para la clase que viene por si tienen dudas en la implementación. No cuelguen con el TP!

Clase 3 - Listas + Orden Superior + Aplicación Parcial + TADs

publicado a la‎(s)‎ 29 mar. 2018 12:12 por Nahuel Palumbo   [ actualizado el 29 mar. 2018 12:49 ]

Terminamos de ver la estructura de modelado: Listas.
Vimos las operaciones más comunes, sobre todo aquellas funciones de orden superior: map, filter, any, all, fold. Y vimos que ya usábamos la composición que es una función de orden superior, o sea, que esperan otra función por parámetro.
Luego vimos que podemos aplicar una función con menos parámetros de los que espera, lo cual nos devuelve una nueva función que espera los parámetros que faltan. Eso se conoce como aplicación parcial, y es la tercer forma que aprendimos para crear funciones (sumadas al definirlas explícitamente y usando composición).
Para finalizar, hicimos un ejercicio y hablamos de TADs. Separando operaciones primitivas (acopladas a la estructura interna del dato) de las no-primitivas (acopladas a las primitivas). Eso nos permite construir soluciones más flexibles, disminuyendo el acoplamiento entre componentes!

Toda la teoría la pueden encontrar en:

Como siempre, acá abajo podrán encontrar el código hecho en clase. Y las guías de Mumuki para practicar se encuentran en la planificación.

RECUERDEN que la clase que viene tenemos checkpoint de la primera parte del TP. Les linkeamos el apunte de testing con HSpec (si no lo pueden hacer andar no se preocupen, hagan las pruebas manuales y lo vemos en clase). Traten de llegar temprano así tenemos tiempo de ver las magias de Haskell.


Clase 2 - Funciones compuestas y modelado de información

publicado a la‎(s)‎ 24 mar. 2018 21:46 por Nahuel Palumbo

Nos adentramos en el mundo funcional tratando a las funciones como valores, y combinándolas por medio de la composición.
Luego hicimos un ejercicio para conocer las estructuras de modelado: Datos simples, Tuplas, Data y las mismas funciones. También aprendimos del Pattern Matching en todos los casos (salvo funciones que no se puede, ya hablaremos de esto).
El código del ejercicio lo pueden encontrar en github: https://github.com/pdp-unsam/eg-tragos-funcional.

Estos temas se encuentran en el módulo 3 y primera mitad del módulo 2.

Clase 1 - El paradigma funcional

publicado a la‎(s)‎ 24 mar. 2018 21:36 por Nahuel Palumbo   [ actualizado el 24 mar. 2018 22:01 ]

Comenzamos con una primera comparación entre paradigmas y presentamos el paradigma funcional.
Hablamos de conceptos que ya conocíamos de las clases de matemática, como función, variable (matemática), aplicación. Y otros más cercanos a la programación como declaratividad y la importancia de la transparecia referencial.
Todo esto lo probamos con Haskell, que tiene un sistema de tipos interesante. Terminamos viendo lo más precido a un if que vamos a tener, las funciones por partes o guardas.

Todo esto se encuentra en el módulo 1 de los apuntes.

1-10 of 10