El lugar de hospedaje

Me he hospedado en el edificio de Kruisstraat/Parnassos, un lugar muy hermoso que se encuentra en Utrecht Central, a 45 minutos a pie o 20 minutos en bici de la universidad de Utrecht.

En mi cuarto tenia una cama donde dormir (que en seria era muy comoda), un armario para la ropa y otro para mis cosas, una mesa mediana, una silla (como las de laboratorio, osea con ruedas) y otra silla de descanzar, una lampara y otros furnitures de mesa y tambien una conexion a internet que venia con su hub y cables.

En el piso tambien habia una cosina completa que no la use mucho y baños.

La Universidad de Utrecht

Para empesar la Universidad de Utrecht es gigante, no llegue a conocer todo, solo conoci algunas partes de ella.

Conoci la parte de la Facultad de Ciencias Naturales, donde se encuentra la carrera de Informatica, y tambien parte del edificio de Informatica.

Pase clases en el edificio de Minaert-Uithof, y si no me equivoco es donde esta la central de la Facultad de Ciencias Naturales; Sus ambientes son como para 50 estudiantes, equipadas con data display y computador, doble pizarra y asientos y mesas comodas para los estudiantes y tomacorrientes en cada mesa. Y sin exagerar, tenian cortinas manuales y automaticas contra el sol (cuando el sol entraba por una de las ventanas estas se cerraban automaticamente). Tambien nos asignaron cuentas para tener acceso a la web.

Los laboratorios tambien eran muy comodos, tenian instalados Windows y Linux Red Hat, con monitores medianos y sillas con ruedas y muy comodas, tambien habia pizarra doble y una computadora al lado del pizaron. Por los pasillos del edificio habian computadoras (similares a las computadoras de la bibliteca de la [Facultad de Ciencias y Tecnologia] de [San Simon]), por las cuales se podia navegar por internet.

La universidad tambien tenia varios lugares donde guardar las bicicletas, y otros lugares donde pasar el tiempo como ser jardines, pequenios lugares de recreacion (asi como en la [San Simon]) y lugares donde servirse algo de comer. En especial he conocido dos lugares de la universidad para comer, no nocozco sus nombres, pero servian bien, mejor dicho te podias servir lo que querias y eso era bueno. Tenian una gran variadad de cosar para servirse: panes, refrescos, galletas, ensaladas, bebidas, sopas, papas, etc. Y eso que no logre ver todo.

Los amigos del curso y docentes

Asistimos al curso 31 estudiantes, tuvimos dos profesores principales (Doaitse Swierstra y Andres Loeh), varios auxiliares que estaban en la maestria y doctorado y tambien otros expositores como ser Atze Dijkstra, Don Steward y Duncan Coutts.

Mis compañeros venian de distintas areas, algunos matematicos, otros de programacion web, unos con nada de conocimientos sobre programacion funcional, otros con conocimeintos previos de funcional, y otros algo expertos en el area de programacion funcional. Tambien habian de distintos niveles de carrera y edades, unos con doctorado, otros en 4to semestre de universidad, y la mayoria con un nivel de licenciatura o egreso. Las edaddes creo que variaban entre 20 y 40 anios.

Todos eramos relativamente amigables, sin embargo no llegue a conocer a todos ellos, pero tuve amigos muy cercanos.

Estrucura general de los dias

Normalmente me levantaba entre las 7 y 7:30 am, me daba un aseo general, me preparaba mi desayuno, y luego agarraba la bici o el bus o las patas para llegar a las 9:00am para la lectura de la maniana, esta lectura era desde las 9 hasta las 10:30–11:00 y luego pasabamos al laboratorio hasta las 12:30 y si queriamos podiamos seguir en el laboratorio o ir a comer, yo normalmente solia ir a comer y pasar el tiempo hasta las 14:00, que era el tiempo para la siguiente lectura, normalmente esa lectura duraba 2 horas y luego al laboratorio a seguir trabajando.

Cada dia aumentaban nuevos laboratorios, esto era de acuerdo a las lecturas y el nivel en el que uno estaba; por cierto hasta el tercer dia habia dos niveles a los que uno podia asistir, estos eran de lo de inicial y el de los avanzados.

No era facil terminar los laboratorios en los tiempos de laboratorio, asi que yo me llebava la tarea para la casa, osea me dirigia directo a casa y rapidamente para seguir programando y terminar los laboratorios. Y llegando a casa comia algo y luego a seguir programando. t;/p>

Esa era mi rutina de casi todos los dias, una que otra variacion entre dia a dia, especialmente los sabados y domingos.

Algunos temas del curso

El curso de Applied Functional Programming consistio de varias lecturas sobre varios topicos relacionados a Programacion Funcional en general y al lenguaje de programacion Haskell en particular. Los topicos cuviertos incluyeron: calculo lambda, sistema de tipos de Haskell, estructuras de datos funcionales, monads, embedded domain-specific lamguages, como tambien estructuracion, testeo, y profiling de programas funcionales.

En los laboratorios hicimos varios proyectos relacionados a las lecturas, los cuales les presentabamos a los docentes o a los auxiliares, tambien algunos presentamos un proyecto final a los companieros, yo trabaje en el proyecto de wiki-server.

Por cierto, puedes encontrar todo el material de las lecturas y laboratorios en la pagina del curso.

Otras actividades del curso

Lastimosamente no pude participar de todas las actividades del curso de verano, habia 5 actividades: almuerzo de bienvenida, cena del curso, noche de pitza, tarde de bebidas, almuerzo de despedida.

Solo asisti a 3 de ellas, el almuerzo de bienvenida, tarde de bebidas, y el almuerzo de despedida. Me perdi de las mejores, no asisti a la cena del curso porque estaba muy cansado y me regrese a casa temprano para dormir (pedi permiso), y no asiti a la noche de pitza porque me confundi las fechas, yo estaba seguro que seria el jueves, pero fue el miercoles, y justo ese dia no fui a clases de la tarde porque queria terminar mi proyecto. Y cuando me di cuenta ya era muy tarde para ir.

Tambien tuve otras actividades fuera del curso, el primer domingo [Doaitse Sweirstra] nos llevo a ver Culemborg, tambien visitamos el Museo Bativia-werf (nos subimos a un barco), tuvimos un cafesito a las orillas del oceano, participamos del IFL (que lo contare en otro post), y como parte del IFL visitamos la torre Dom, visitamos un museo de arte, tuvimos un paseo en barco por casi todo Utrecht y Amsterdam, y visitamos en automovil varios lugares que no conosco sus nombres pero que tenian una hermosa vista.

Mi fiel companiero de viaje, curso, etc

Ahora es tiempo de mensionar de un companiero fiel, que no se separaba mucho de mi, siempre andabamos juntos (en el buen sentido de la palabra), y casi todo lo que yo hacia el tambien lo hacia y visiversa.

Antonio fue mi companiero de viaje desde la ida en Cochabamba y hasta la vuela Santa Cruz, incluso fue mi companiero de cuarto durante el curso y otras visitas, tambien paso todas las lecturas junto con migo, y tambien trabajo junto con migo en ciertos proyectos, hasta teniamos casi los mismos amigos. Fue mi fiel companiero Antonio.

En resumen

Asi como uno de mis profesores lo dijo: “Ha sido toda una experiencia completa para toda la vida”, eso resume lo super que ha sido este tiempo.

Quiero agradecer a todos los que han ayudado para que todo esto se lleve adelante. Sin su ayuda nada hubiera sido como ha sido. Y ahora a aplicar todo lo aprendido y a cumplir todo lo prometido.

Hasta otra oportunidad,

Saludos Carlos Gomez

L-System

Hoy por la noche, cuando navegaba por la red me encontre con algo interesante. Y decidi iniciar un proyecto pequeño, un L-System en Haskell.

Este proyecto me trae recuerdos cuando estaba en la materia de Interfaces de Usuario con el Lic. Boris Calancha, en la que desarrollamos fractales con Java, de una forma recursiva. En aquel entonces no tenia la menor idea de que existia una generalizacion en la forma de generar fractales, pues hoy aprendi que si hay una generalizacion muy interesante, me intereso mas que todo por que esta relacionado con el campo de estudio que sigo, gramaticas, compiladores y haskell.

Pues resulta que un L-System es una tri-tupla, (muy parecido a las gramaticas que estudiamos en automatas)

G (V, w, P)

donde:

V: Alfabeto o conjunto de Simbolos
w: Simbolo Inicial
P: Reglas de Produccion o de re-writing

Asi, esta tri-tupla es capaz de generar fractales. La forma de hacerlo es atraves de derivaciones empezando con el simbolo inicial (no olviden que para hacer una derivacion usamos las reglas de produccion). Entonces de acuerdo al fractal que queramos, podemos aplicar (derivar) varias veces.

Veamos un ejemplo de wikipedia,

Example 1: Algae
variables : A B => alfabeto

constants : none

start  : A                      => simbolo inicial

rules  : (A → AB), (B → A)      => 2 reglas de produccion

which produces:

n = 0 : A

n = 1 : AB

n = 2 : ABA

n = 3 : ABAAB

n = 4 : ABAABABA

n = 5 : ABAABABAABAAB

n = 6 : ABAABABAABAABABAABABA

n = 7 : ABAABABAABAABABAABABAABAABABAABAAB

Cuando vemos este ejemplo, no parece animar ni convencer para seguir con el proyecto, sin embargo, si vale la pena seguir cuando se ve las imagenes que se puede generar (fractales), y eso se logra con la ayuda de una libreria grafica y un sistema denominado turtle para interpretacion de strings. Si quieres convencerte al igual que yo, debes ver las imagenes de wikipedia.

Bueno, y esta oportunidad queria compartirles la implementacion de una parte basica de este sistema L,

la forma en que represento un sistema L es asi:

type L = (V, W, P)              -- Sistema L

type V = [String]

type W = String

type P = [(Char, String)]       -- simbolo -> resultado == (simbolo, resultado)

genero un parser de acuerdo a las producciones:

--genParser :: [(Char, String)] -> Parser ? ?

genParser lst = if null lst

                then usererror "GenParser: the argument my not be empty list."

                else foldr1 (<|>) (map fun lst)

    where fun (val, res) = (res <$ pSym val)

y genero las iteraciones enviandole el sistema L y un N que indica el numero de iteraciones, esta funcion imprime el resultado en la pantalla.

generate :: L -> Int -> IO ()

Veamos algunos ejemplos de sistemas L:

{-

Example 1: Algae

variables : A B

constants : none

start  : A

rules  : (A → AB), (B → A)

-}
algae = (["A", "B"], "A", [('A', "AB"),('B',"A")])
{-

Example 2: Fibonacci numbers
variables : A B

constants : none

start  : A

rules  : (A → B), (B → AB)

-}
fib = (["A","B"], "A", [('A', "B"),('B',"AB")])
{-

Example 3: Cantor dust
variables : A B

constants : none

start  : A

rules  : (A → ABA), (B → BBB)

-}
cantor1 = (["A","B"], "A", [('A', "ABA"),('B',"BBB")])

cantor2 = (["-"," "], "-", [('-', "- -"),(' ',"   ")])

Ahora mostremos algunos ejemplos:

*Parser> generate fib 7
BABABBABABBABBABABBAB

*Parser> generate algae 7
ABAABABAABAABABAABABAABAABABAABAAB

*Parser> generate cantor1 4 ABABBBABABBBBBBBBBABABBBABABBBBBBBBBBBBBBBBBBBBBBBBBBBABABBBABABBBBBBBBBABABBBABA

*Parser> generate cantor2 4
- - - - - - - - - - - - - - - -
(Nota.- este utlimo no se grafico bien, pero se genera correctamente en consola)

Bueno eso es todo por hoy, si quieres ver el codigo y el proyecto, te invito que sigas este link.

data Persona = Per CI Name LastName Edad
                                        deriving Show
type CI           = Int
type Name       = String
type LastName = String
type Edad        = Int

Esto define una funcion constructora de datos de tipo:

Per ::CI -> Name -> LastName -> Edad -> Persona

Veamos algunos ejemplos:

p1 :: Persona
p1 = Per 1212 "Juan" "Block" 35

p2 :: Persona
p2 = Persona 2323 "Pedro" "Ramos" 25

Ahora definamos algunas funciones set y get para Persona

setCI :: Persona -> CI -> Persona
setCI (Persona ci nm ap ed) ci' = Per ci' nm ap ed

setNombre :: Persona -> Name -> Persona
setNombre (Persona ci nm ap ed) nm' = Per ci nm' ap ed

setApellido :: Persona -> LastName -> Persona
setApellido (Persona ci nm ap ed) ap' = Per ci nm ap' ed

setEdad :: Persona -> Edad -> Persona
setEdad (Persona ci nm ap ed) ed' = Per ci nm ap ed'

getCI :: Persona -> CI
getCI (Persona ci _ _ _) = ci

getNombre :: Persona -> Name
getNombre (Persona _ nm _ _) = nm

getApellido :: Persona -> LastName
getApellido (Persona _ _ ap _) = ap

getEdad :: Persona -> Edad
getEdad (Persona _ _ _ ed) = ed

Si hacemos algunas pruebas obtenemos:

gt;*Main> getCI p1

nos retornaria el CI de 'Juan', tambien podemos obtener nombre, apellido o edad.

Para setear un valor, podemos hacer

*Main> p1 {nombre = "juanes"}
Persona {ci = 1212, nombre = "juanes", apellido = "Block", edad = 35}

Y listo, mision cumplida, aunque un poco tedioso. 
Bueno, esto no termina aqui, resulta que Haskell provee una forma diferente de definir los datatypes, esto es nombrando los elementos de cada constructor de datos. Llamado tambien records de Haskell.

Veamos como nos ayuda esto, en nuestra definicion de setters y getters, y como cambia a lo anterior ya hecho.

data Persona = Per { ci        :: CI
                           , nombre :: Name
                           , apellido :: LastName
                           , edad     :: Edad
                           } deriving Show
type CI           = Int
type Name       = String
type LastName = String
type Edad        = Int

Bueno, eso es todo lo que tenemos que hacer, hagamos algunas pruebas para ver algo de teoria.

p3 = Per 2525 "Teo" "Flores" 43  -- creamos un instancia
* Main> ci p3
2525
* Main> p3{nombre = "Maria"}
Persona {ci = 2525, nombre = "Maria", apellido = "Flores", edad = 43}

Como veras, hicimos las operaciones de set y get.

Algo de teoria, el nombramiento de campos en los datatypes no afecta al anterior version, por ejemplo el tipo contructor de datos es el mismo. Pero hay funcionalidades que se aumentan. Entre ellos tenemos la seleccion de campos usando labels, construccion usando labels y actualizacion de campos usando labels.

La seleccion de campos usando labels, es practicamente la operacion seter de un objeto. Y lo que Haskell hace es definir una funcion con el nombre del label, el cual esta disponible para su uso. Ejemplo "ci p3".

Tambien podemos contruir instancias usando labels (p4 = Per {edad=12, ci=3434, apellido="Perez", nombre="Pedro"} ), y no solo de la forma comun (p4 = Per 3434 12 "Pedro" "Perez"). Intensionalmente he cambiado las posiciones de los labels, pues esto no afecta. Se debe cuidar de que ningun label se repita mas de una ves, pero si no especificamos algun label, este deberia inicializar como indefinido o infito (GHC lo muestra como un warning).

Para la actualizacion de campos usando labels, se tiene una sintaxis: instancia_obj {label=value, ...}, asi como en el ejemplo p3{ci=3454}. Otra ves, no se debe mencionar mas de una ves una label, y los labels deben pertenecer al tipo contructor.

Al actualizar un valor de la instancia, se genera una nueva instancia modificando asi en la nueva instancia los valores enviados. Es una caracteristica de Persistencia de Haskell. Veamos un ejemplo:

*Main> p1 {edad = 0}
Persona {ci = 1212, nombre = "Juan", apellido = "Block", edad = 0}
*Main> p1
Persona {ci = 1212, nombre = "Juan", apellido = "Block", edad = 35}

Tambien podemos mesclar los distintos contructores de datos con esta sintxis o sin ella. Y respecto a los nombres de los labels, podemos repetirlas entre las funciones contructoras de datos, siempre y cuando se tenga un tipo consistente, pero no podemos repetirnas entre los datatypes, porque generaria una incosistencia de tipos. Veamos un ejemplo sacado del reporte de Haskell 98:

data S = S1 {x :: Int}
          | S2 {x :: Int}   -- ejemplo bueno

data T = T1 {y :: Int}
          | T2 {y :: Bool}  -- ejemplo malo, tipo inconsistente

En conclusion, esta forma de creacion de datatypes, añade funcionalidad y sintaxis extra para manipular los elementos del datatype.

Algo interesante seria averiguar como definir mucha mas similitud de funcionalidad a OOP. Me refiero a definir solo funciones set o get para algunos elementos, o declarar elementos como publicos, protegidos o privados.

Hay otras extenciones de GHC que nos facilitan la manipulacion de records en Haskell. Pero los que hemos visto aqui pertenece al Haskell 98.